|
Size: 15772
Comment: Copy+Adapt from 2023
|
← Revision 19 as of 2024-03-09 21:36:00 ⇥
Size: 12701
Comment: another tensor link
|
| Deletions are marked like this. | Additions are marked like this. |
| Line 7: | Line 7: |
| The [[https://summerofcode.withgoogle.com/how-it-works/#timeline | Timeline]] for GSoC 2024. | |
| Line 8: | Line 9: |
| [[https://summerofcode.withgoogle.com/how-it-works/#timeline | Timeline]] Please subscribe to the [[https://groups.google.com/forum/#!forum/sage-gsoc|sage-gsoc]] mailing list and the GAP developer list for discussion on possible GAP GSoC projects. Also, make sure you have gone through the '''[[https://wiki.sagemath.org/GSoC/Students | information regarding application procedures, requirements and general advice]]'''. The Application Template is also available on that wiki page. Archives of past GSoC project ideas can be found [[https://wiki.sagemath.org/GSoC | here]]. All projects will start with an introduction phase to learn about Sage``Math’s (or sister projects') internal organization and to get used to their established development process. '''We modernized our development workflow in 2023, which is now entirely on !GitHub!)''' |
Make sure you have gone through the '''[[https://wiki.sagemath.org/GSoC/Contributors|information regarding application procedures, requirements and general advice]]'''. The Application Template is also available on that wiki page. Also, please subscribe to the [[https://groups.google.com/forum/#!forum/sage-gsoc|sage-gsoc]] mailing list and the Sage developer list. Archives of past GSoC project ideas can be found [[https://wiki.sagemath.org/GSoC | here]]. |
| Line 16: | Line 13: |
| Apart from the project ideas listed below, there is also a long wishlist for new features in our [[https://github.com/sagemath/sage/issues?q=sort%3Aupdated-desc+is%3Aopen|5000 open GitHub Issues]]! | Apart from the project ideas listed below, there is also a wishlist for new features in our [[https://github.com/sagemath/sage/issues?q=sort%3Aupdated-desc+is%3Aopen|open GitHub Issues]]. |
| Line 18: | Line 15: |
| Note that projects can be one of three lengths: * Small: 90 hours * Medium: 175 hours * Large: 350 hours |
|
| Line 24: | Line 26: |
| Other well-motivated proposals from students involving SageMath in a substantial way will be gladly considered, as well. | Other well-motivated proposals from prospective contributors involving SageMath in a substantial way will be gladly considered, as well. |
| Line 36: | Line 38: |
| || Skills || What the student should bring ... || | || Skills || What the contributor should bring ... || |
| Line 63: | Line 65: |
| == Improve exterior algebra and Gröbner bases code and expand to graded commutative algebras == | == Coordinate the graded commutative algebra and exterior algebra implementations and Gröbner bases == |
| Line 71: | Line 73: |
| The exterior (or Grassmann) algebra is a fundamental object in mathematics that recently obtained an implementation of Gröbner bases. However, it is currently quite slow with a goal to improve it (see, e.g., [[https://github.com/sagemath/sage/issues/34437|#34437]]). The second goal of this project would be to implement Gröbner bases for the general graded commutative algebra code within Sage. This includes possibly redoing the underlying implementation to to not rely on the more generic [[https://www.singular.uni-kl.de/Manual/4-0-2/sing_469.htm|plural]] for computations (except perhaps those involving ideals). For the ambitious, these computations would be extracted to an independent C++ library for many common rings (implemented using other libraries). | A graded commutative algebra (GCA) is an algebra where the even generators commute and the odd generators skew-commute. The implementation currently relies on singular's library [[https://www.singular.uni-kl.de/Manual/4-0-2/sing_469.htm|plural]] as a quotient ring of a g-algebra. SageMath has a native implementation of the exterior algebra, but it does not interface well with the GCA implementation. The primary goal of this project would be to improve the interaction between the two implementations; likely with a native implementation of GCAs. A second goal would be to improve the implementation of SageMath's implementation of Gröbner bases for the exterior algebra, which is currently quite slow (see, e.g., [[https://github.com/sagemath/sage/issues/34437|#34437]]). For the ambitious, these computations would be extracted to an independent C++ library for many common rings (implemented using other libraries). |
| Line 74: | Line 76: |
| == Implement Schubert and Grothendieck polynomials == | == Direct implementation of Chow rings of matroids == |
| Line 77: | Line 79: |
| || Area || Algebra, Combinatorics, Schubert Calculus || || Skills || Foundations in combinatorics, experience reading research papers. || |
|| Area || Algebra, Combinatorics || || Skills || Foundations in algebra and combinatorics, experience reading research papers recommended. || |
| Line 82: | Line 84: |
| Schubert calculus can roughly be stated as the study of the intersections of lines, through which certain algebras arise that can be represented using Schubert polynomials and Grothendieck polynomials. The main goal of this project is to finish the implementation started in [[https://github.com/sagemath/sage/issues/6629|#6629]], as well as implement the symmetric Grothendieck polynomials and their duals in symmetric functions. There are also new methods to compute completions in the ring of symmetric functions, allowing expansions of Grothendieck polynomials in Schur functions. | SageMath currently has an implementation of the Chow ring of a matroid, but it is based on constructing the explicit ideal and taking the corresponding quotient ring. However, explicit an Gröbner basis is known and could be used to implement the multiplication directly. This would require a custom class for the Chow rings, which is the main goal of this project. This would significantly speed up the construction and computations, as well as give more features that are not currently implemented from the generic quotients. See [[https://github.com/sagemath/sage/issues/36479|#36479]]. |
| Line 84: | Line 86: |
== Tensor operations in Sage using Python libraries as backends == || Mentor || Matthias Koeppe || || Area || Linear/multilinear algebra || || Skills || Solid knowledge of linear algebra, Python experience, ideally experience with numpy, !PyTorch, JAX, or !TensorFlow || || Length || 350 hours || || Difficulty || Hard || In this project, we develop new backends for the [[https://sagemanifolds.obspm.fr/tensor_modules.html|tensor modules from the SageManifolds project]]. Amongst the goals of the project are such elements as a [[https://github.com/sagemath/sage/issues/30308|fast implementation of tensor operations using numpy]] and [[https://github.com/sagemath/sage/issues/30096|using TensorFlow Core and PyTorch]]. (Remark: It might be worth looking at the [[https://github.com/thetensor-space|TensorSpace]] project for Magma.) == Integration of Sage with proof assistants / theorem provers / SMT systems / constraint programming systems == || Mentor || Matthias Koeppe || || Area || Various || || Skills || Solid knowledge of a system such as LEAN, Isabelle, CVC5, !MiniZinc; Python experience || || Length || 350 hours || || Difficulty || Hard || == Enhanced optimization solver interfaces for Sage == || Mentor || Matthias Koeppe || || Area || Optimization || || Skills || Solid knowledge of linear optimization, Python experience, ideally experience with Python optimization interfaces || || Length || 350 hours || || Difficulty || Hard || See [[https://github.com/sagemath/sage/issues/26511|Meta-ticket #26511: Use Python optimization interfaces: SCIP, cvxpy, PuLP, Pyomo, cylp...]] == Connecting manifolds and optimization == || Mentor || Matthias Koeppe || || Area || Optimization, Differential Geometry || || Skills || Solid knowledge of nonlinear optimization, basic knowledge of differential geometry, Python experience, ideally experience with Python optimization interfaces || || Length || 350 hours || || Difficulty || Hard || See [[https://github.com/sagemath/sage/issues/26511|Meta-ticket #26511]], [[https://github.com/sagemath/sage/issues/30525|Meta-ticket #30525]] == Create an interface to the SmallGrp database == || Mentor || TBD || || Area || Group Theory || || Skills || Group Theory, GAP and Python experience || || Length || 350 hours || || Difficulty || Medium-hard || Create a convenient Pythonic interface to the small groups database that wraps the [[https://gap-packages.github.io/smallgrp/|SmallGrp]] GAP package. This will enable to create all small groups satisfying certain properties (e.g. abelian, solvable, non-nilpotent, given order) in an easy way, and to provide information about them. This project should also aim to improve the connection between the implementations of permutation, matrix and finitely presented groups in Sage``Math. This can also include programmable access to information about each group, like the subgroup lattice, as in [[http://groupnames.org|GroupNames]]. As an example, the interface might be {{{SmallGroups(60, nilpotent=True, type="permutation")}}} for an iterator that return Sage's !PermutationGroup objects of all nilpotent groups of order 60, say sorted by GAP ID. For the implementation, the !SmallGroups class might inherit from [[https://doc.sagemath.org/html/en/reference/sets/sage/sets/condition_set.html#sage.sets.condition_set.ConditionSet|ConditionSet]], and add methods for the information the !SmallGrp GAP package provides such as cardinality and short summery as in !SmallGroupsInformation. == Implement matrix spaces over commutative semirings == || Mentor || TBD || || Area || Mainly algebra, linear algebra and Sage basic data structures || || Skills || At least an intermediate knowledge in Python. Knowing Cython or the Sage category framework is a big advantage || || Length || 350 hours || || Difficulty || Medium-hard || The natural numbers with the standard addition and multiplication, and the min-plus [[https://doc.sagemath.org/html/en/reference/semirings/sage/rings/semirings/tropical_semiring.html|tropical algebra]] over a commutative ring, are examples of well-known commutative semirings. The aim of this project is to implement matrix spaces and matrices over such semirings. They have many uses in combinatorics, optimization and other mathematical areas. The mathematical background needed is not advanced. The main difficulty will be to understand the current implementation of matrix spaces over rings, and how to add support for semirings that plays well with it. If time permits, an implementation of polynomial (semi)rings over semirings can be implemented. |
|
| Line 166: | Line 105: |
| == Dynamical Systems with Multiple Functions == | |
| Line 168: | Line 106: |
| || Mentor || Alex Galarraga and Ben Hutz || || Area || Dynamics || || Skills || At least an intermediate knowledge in Python || || Length || 175 hours || || Difficulty || Medium || |
== Tensor operations in Sage using Python libraries as backends == |
| Line 174: | Line 108: |
| A typical dynamical system is the iteration of a single function. However, it is possible to create dynamical systems from sets of functions. There are several different definitions that could be applied. For example, an orbit could be the forward images of the point under every function or you could apply a function at random. There is currently nothing implemented for these types of dynamical, but there have been several papers studying them. The goal would be to implement the functionality that would be most helpful to the current research directions in this area. | || Mentor || [[https://www.math.ucdavis.edu/~mkoeppe/|Matthias Köppe]] || || Area || Linear/multilinear algebra || || Skills || Solid knowledge of linear algebra, Python experience, ideally experience with numpy, !PyTorch, JAX, or !TensorFlow || || Length || 350 hours || || Difficulty || Hard || In this project, we develop new backends for the [[https://sagemanifolds.obspm.fr/tensor_modules.html|tensor modules from the SageManifolds project]]. Amongst the goals of the project are such elements as a [[https://github.com/sagemath/sage/issues/30308|fast implementation of tensor operations using numpy]] and [[https://github.com/sagemath/sage/issues/30096|using TensorFlow Core and PyTorch]]. Other relevant reading: - https://data-apis.org/array-api/latest/API_specification/array_object.html - https://dmlc.github.io/dlpack/latest/python_spec.html (Remark: It might be worth looking at the [[https://github.com/thetensor-space|TensorSpace]] project for Magma.) == Integration of Sage with proof assistants / theorem provers / SMT systems / constraint programming systems == || Mentor || [[https://www.math.ucdavis.edu/~mkoeppe/|Matthias Köppe]] || || Area || Various || || Skills || Solid knowledge of a system such as LEAN, Isabelle, CVC5, !MiniZinc; Python experience || || Length || 350 hours || || Difficulty || Hard || == Enhanced optimization solver interfaces for Sage == || Mentor || [[https://www.math.ucdavis.edu/~mkoeppe/|Matthias Köppe]] || || Area || Optimization || || Skills || Solid knowledge of linear optimization, Python experience, ideally experience with Python optimization interfaces || || Length || 350 hours || || Difficulty || Hard || See [[https://github.com/sagemath/sage/issues/26511|Meta-ticket #26511: Use Python optimization interfaces: SCIP, cvxpy, PuLP, Pyomo, cylp...]] == Connecting manifolds and optimization == || Mentor || [[https://www.math.ucdavis.edu/~mkoeppe/|Matthias Köppe]] || || Area || Optimization, Differential Geometry || || Skills || Solid knowledge of nonlinear optimization, basic knowledge of differential geometry, Python experience, ideally experience with Python optimization interfaces || || Length || 350 hours || || Difficulty || Hard || See [[https://github.com/sagemath/sage/issues/26511|Meta-ticket #26511]], [[https://github.com/sagemath/sage/issues/30525|Meta-ticket #30525]] |
| Line 177: | Line 151: |
| == Algorithms for Dynamical Systems == | == Poincare normal form of Riemann matrices == |
| Line 179: | Line 153: |
| || Mentor || Alex Galarraga and Ben Hutz || || Area || Dynamics || || Skills || At least an intermediate knowledge in Python, basic algebraic number theory || || Length || 175 hours || |
|| Mentor || [[https://eps.leeds.ac.uk/maths/staff/14138/dr-linden-disney-hogg|Linden Disney-Hogg]] || || Area || Algebra, Algebraic Geometry || || Skills || Knowledge of abstract algebra and Riemann surfaces desirable || || Length || 350 hours || || Difficulty || Medium-Easy, becoming harder if desired by tackling the research questions || Riemann surfaces are key objects in many areas of maths, from mathematical physics to algebraic and arithmetic geometry, with modern usage of Sage typically focusing around computing the Riemann matrix and calculating the associated theta function. The project would involve an implementation of Poincare reduction of the Riemann matrix which allows the theta function to be factorised, following the paper of Martens (http://www.jstor.org/stable/43737152), which in turn will require some matrix methods to be implemented. There is scope for an enterprising applicant to make this into a research paper in two directions, either by analysing the improvement to complexity from computing with factorised theta functions, or by developing an algorithm to go from one reduction to a complete reduction. == Create an interface to the SmallGrp database == || Mentor || TBD || || Area || Group Theory || || Skills || Group Theory, GAP and Python experience || || Length || 350 hours || |
| Line 185: | Line 169: |
| This project focuses mainly on two algorithmic improvements. The first is modifying the algorithms of Krumm for points of bounded height to work over rings of integers in number fields. The second is generalizing Well's algorithm for computing the canonical heights beyond QQ to number fields where it is applicable. As time allows, cleaning up some of the open tickets in dynamics would be good too. | Create a convenient Pythonic interface to the small groups database that wraps the [[https://gap-packages.github.io/smallgrp/|SmallGrp]] GAP package. This will enable to create all small groups satisfying certain properties (e.g. abelian, solvable, non-nilpotent, given order) in an easy way, and to provide information about them. This project should also aim to improve the connection between the implementations of permutation, matrix and finitely presented groups in Sage``Math. This can also include programmable access to information about each group, like the subgroup lattice, as in [[http://groupnames.org|GroupNames]]. As an example, the interface might be {{{SmallGroups(60, nilpotent=True, type="permutation")}}} for an iterator that return Sage's !PermutationGroup objects of all nilpotent groups of order 60, say sorted by GAP ID. For the implementation, the !SmallGroups class might inherit from [[https://doc.sagemath.org/html/en/reference/sets/sage/sets/condition_set.html#sage.sets.condition_set.ConditionSet|ConditionSet]], and add methods for the information the !SmallGrp GAP package provides such as cardinality and short summary as in !SmallGroupsInformation. |
| Line 188: | Line 174: |
| == Plane partitions and alternating sign matrices == | == Implement matrix spaces over commutative semirings == |
| Line 190: | Line 176: |
| || Mentor || Jessica Striker || || Area || Combinatorics || || Skills || Read mathematical papers in combinatorics || || Length || 175 to 350 hours || || Difficulty || Medium || There are several things to implement related to plane partitions and alternating sign matrices (ASMs)that are used in current research. Some of these examples include: * Write iterators for the five or so remaining symmetry classes of plane partitions and ASMs. * Map from ASM to order ideal in tetrahedral poset. * Implement pipe dreams and bumpless pipe dreams – this would also be related to the project implementing Schubert and Grothendieck polynomials == Computational invariant theory == || Mentor || Dima Pasechnik || || Area || Algebra || || Skills || Understanding of group actions, knowledge of representation theory preferred || || Length || 175 to 350 hours || |
|| Mentor || TBD || || Area || Mainly algebra, linear algebra and Sage basic data structures || || Skills || At least an intermediate knowledge in Python. Knowing Cython or the Sage category framework is a big advantage || || Length || 350 hours || |
| Line 211: | Line 182: |
| The study of invariants under, e.g., a group action is an active research topic with broad applications. This project would develop the ability within Sage to compute invariants under certain finitely-generated actions, such as the invariants for linear groups acting on polynomials. In particular, we aim to not restrict ourselves to the characteristic 0 case, but also look at the prime characteristic case. For the latter we will implement Dickson invariants, extenstions of the Molien formula to this case, etc. == Enhancements in linear algebra == || Mentor || Vincent Neiger and Clément Pernet || || Area || Linear Algebra || || Skills || Efficient algorithms in exact linear algebra, high-performance linear algebra libraries || || Length || 350 hours || || Difficulty || Medium || Sage incorporates state-of-the-art libraries for exact linear algebra computations, such as matrix multiplication, reduced echelon form, linear system solving, when the coefficients are in an exact domain such as the integers or finite fields. However, several aspects make the integration of these libraries not yet fully satisfactory. For example, working over a prime field with a prime below about 20 bits, the mere creation of a zero matrix in SageMath takes roughly as long as the call of the underlying fast reduced echelon form procedure (performed by LinBox / FFLAS-FFPACK in this case). Still about FFLAS-FFPACK: several available tools in this library are not offered through the Sage interface, constraining the user experience; for example, some pivoting strategies are not available, despite their usefulness in some situations e.g. when one is interested in the preservation of some rank profile properties. Finally, the integration of linear algebra implementations from Flint has been initiated, with a good amount of work already done, but is not fully finalized and has not been merged into Sage. This project aims to make this kind of enhancements, which would lead to more efficient and more versatile finite field linear algebra operations in Sage. |
The natural numbers with the standard addition and multiplication, and the min-plus [[https://doc.sagemath.org/html/en/reference/semirings/sage/rings/semirings/tropical_semiring.html|tropical algebra]] over a commutative ring, are examples of well-known commutative semirings. The aim of this project is to implement matrix spaces and matrices over such semirings. They have many uses in combinatorics, optimization and other mathematical areas. The mathematical background needed is not advanced. The main difficulty will be to understand the current implementation of matrix spaces over rings, and how to add support for semirings that plays well with it. If time permits, an implementation of polynomial (semi)rings over semirings can be implemented. |
GSoC 2024: Ideas Page
Introduction
Welcome to SageMath's Ideas Page for GSoC 2024! (Last year 2023)
The Timeline for GSoC 2024.
Make sure you have gone through the information regarding application procedures, requirements and general advice. The Application Template is also available on that wiki page. Also, please subscribe to the sage-gsoc mailing list and the Sage developer list. Archives of past GSoC project ideas can be found here.
We also require you to show us that you are able to execute actual development by submitting a relevant Pull Request and/or reviewing a Pull Request of the project you are interested in applying to. The developer guide is a great comprehensive resource that can guide you through your first steps in contributing to SageMath.
Apart from the project ideas listed below, there is also a wishlist for new features in our open GitHub Issues. They might contain or inspire the perfect project idea for you that we didn't even think about! Note that projects can be one of three lengths:
- Small: 90 hours
- Medium: 175 hours
- Large: 350 hours
Contents
- GSoC 2024: Ideas Page
-
Project Ideas
- Improve (free) module implementations
- Coordinate the graded commutative algebra and exterior algebra implementations and Gröbner bases
- Direct implementation of Chow rings of matroids
- Improve combinatorial species
- Tensor operations in Sage using Python libraries as backends
- Integration of Sage with proof assistants / theorem provers / SMT systems / constraint programming systems
- Enhanced optimization solver interfaces for Sage
- Connecting manifolds and optimization
- Poincare normal form of Riemann matrices
- Create an interface to the SmallGrp database
- Implement matrix spaces over commutative semirings
Project Ideas
Here is a list of project proposals with identified mentors. Other well-motivated proposals from prospective contributors involving SageMath in a substantial way will be gladly considered, as well.
Improve (free) module implementations
Mentor |
Travis Scrimshaw |
Area |
Linear Algebra, Performance, Refactoring |
Skills |
Understanding of linear algebra and object-oriented programming. Cython experience is highly recommended. |
Length |
175 hours |
Difficulty |
Medium-easy |
SageMath has multiple implementations of free modules:
1. Finite dimensional coordinate representations in the "standard" basis using FreeModule that provides both a dense and sparse implementation. 2. Using CombinatorialFreeModule (CFM) as (possibly infinite dimensional) sparse vectors.
There are various benefits to each implementation. However, they are largely disjoint and would mutually benefit from having a common base classes. In particular, having a dense implementation for CFM elements for applications that require heavier use of (dense) linear algebra. The goal of this project is to refactor these classes to bring them closer together (although they will likely remain separate as they are likely not fully compatible implementations for the parents).
Coordinate the graded commutative algebra and exterior algebra implementations and Gröbner bases
Mentor |
Travis Scrimshaw |
Area |
Algebra, Performance |
Skills |
Understanding of abstract algebra and Cython. Knowledge of Gröbner basis is strongly recommended. |
Length |
175 hour and 350 hour variants |
Difficulty |
Medium-hard |
A graded commutative algebra (GCA) is an algebra where the even generators commute and the odd generators skew-commute. The implementation currently relies on singular's library plural as a quotient ring of a g-algebra. SageMath has a native implementation of the exterior algebra, but it does not interface well with the GCA implementation. The primary goal of this project would be to improve the interaction between the two implementations; likely with a native implementation of GCAs. A second goal would be to improve the implementation of SageMath's implementation of Gröbner bases for the exterior algebra, which is currently quite slow (see, e.g., #34437). For the ambitious, these computations would be extracted to an independent C++ library for many common rings (implemented using other libraries).
Direct implementation of Chow rings of matroids
Mentor |
Travis Scrimshaw |
Area |
Algebra, Combinatorics |
Skills |
Foundations in algebra and combinatorics, experience reading research papers recommended. |
Length |
175 hours |
Difficulty |
Medium-hard |
SageMath currently has an implementation of the Chow ring of a matroid, but it is based on constructing the explicit ideal and taking the corresponding quotient ring. However, explicit an Gröbner basis is known and could be used to implement the multiplication directly. This would require a custom class for the Chow rings, which is the main goal of this project. This would significantly speed up the construction and computations, as well as give more features that are not currently implemented from the generic quotients. See #36479.
Improve combinatorial species
Mentor |
Martin Rubey |
Area |
Combinatorics |
Skills |
Knowledge of combinatorial species or group actions |
Length |
350 hours |
Difficulty |
Medium-hard |
SageMath has a working implementation of combinatorial species. However, this should be improved in many ways. Some of the most important missing features are:
- support for multivariate species and exhaustive generation of isomorphism types for compositions of species
implementation of the Burnside ring
a clever interface to Usain-Boltz
It may be necessary to focus on one of these points. Realizing any of the above would count as a success.
See also Metaticket for combinatorial species
Tensor operations in Sage using Python libraries as backends
Mentor |
|
Area |
Linear/multilinear algebra |
Skills |
Solid knowledge of linear algebra, Python experience, ideally experience with numpy, PyTorch, JAX, or TensorFlow |
Length |
350 hours |
Difficulty |
Hard |
In this project, we develop new backends for the tensor modules from the SageManifolds project. Amongst the goals of the project are such elements as a fast implementation of tensor operations using numpy and using TensorFlow Core and PyTorch.
Other relevant reading:
- https://data-apis.org/array-api/latest/API_specification/array_object.html - https://dmlc.github.io/dlpack/latest/python_spec.html
(Remark: It might be worth looking at the TensorSpace project for Magma.)
Integration of Sage with proof assistants / theorem provers / SMT systems / constraint programming systems
Mentor |
|
Area |
Various |
Skills |
Solid knowledge of a system such as LEAN, Isabelle, CVC5, MiniZinc; Python experience |
Length |
350 hours |
Difficulty |
Hard |
Enhanced optimization solver interfaces for Sage
Mentor |
|
Area |
Optimization |
Skills |
Solid knowledge of linear optimization, Python experience, ideally experience with Python optimization interfaces |
Length |
350 hours |
Difficulty |
Hard |
See Meta-ticket #26511: Use Python optimization interfaces: SCIP, cvxpy, PuLP, Pyomo, cylp...
Connecting manifolds and optimization
Mentor |
|
Area |
Optimization, Differential Geometry |
Skills |
Solid knowledge of nonlinear optimization, basic knowledge of differential geometry, Python experience, ideally experience with Python optimization interfaces |
Length |
350 hours |
Difficulty |
Hard |
See Meta-ticket #26511, Meta-ticket #30525
Poincare normal form of Riemann matrices
Mentor |
|
Area |
Algebra, Algebraic Geometry |
Skills |
Knowledge of abstract algebra and Riemann surfaces desirable |
Length |
350 hours |
Difficulty |
Medium-Easy, becoming harder if desired by tackling the research questions |
Riemann surfaces are key objects in many areas of maths, from mathematical physics to algebraic and arithmetic geometry, with modern usage of Sage typically focusing around computing the Riemann matrix and calculating the associated theta function. The project would involve an implementation of Poincare reduction of the Riemann matrix which allows the theta function to be factorised, following the paper of Martens (http://www.jstor.org/stable/43737152), which in turn will require some matrix methods to be implemented. There is scope for an enterprising applicant to make this into a research paper in two directions, either by analysing the improvement to complexity from computing with factorised theta functions, or by developing an algorithm to go from one reduction to a complete reduction.
Create an interface to the SmallGrp database
Mentor |
TBD |
Area |
Group Theory |
Skills |
Group Theory, GAP and Python experience |
Length |
350 hours |
Difficulty |
Medium-hard |
Create a convenient Pythonic interface to the small groups database that wraps the SmallGrp GAP package. This will enable to create all small groups satisfying certain properties (e.g. abelian, solvable, non-nilpotent, given order) in an easy way, and to provide information about them. This project should also aim to improve the connection between the implementations of permutation, matrix and finitely presented groups in SageMath. This can also include programmable access to information about each group, like the subgroup lattice, as in GroupNames.
As an example, the interface might be SmallGroups(60, nilpotent=True, type="permutation") for an iterator that return Sage's PermutationGroup objects of all nilpotent groups of order 60, say sorted by GAP ID. For the implementation, the SmallGroups class might inherit from ConditionSet, and add methods for the information the SmallGrp GAP package provides such as cardinality and short summary as in SmallGroupsInformation.
Implement matrix spaces over commutative semirings
Mentor |
TBD |
Area |
Mainly algebra, linear algebra and Sage basic data structures |
Skills |
At least an intermediate knowledge in Python. Knowing Cython or the Sage category framework is a big advantage |
Length |
350 hours |
Difficulty |
Medium-hard |
The natural numbers with the standard addition and multiplication, and the min-plus tropical algebra over a commutative ring, are examples of well-known commutative semirings. The aim of this project is to implement matrix spaces and matrices over such semirings. They have many uses in combinatorics, optimization and other mathematical areas. The mathematical background needed is not advanced. The main difficulty will be to understand the current implementation of matrix spaces over rings, and how to add support for semirings that plays well with it. If time permits, an implementation of polynomial (semi)rings over semirings can be implemented.