diff git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000000000000000000000000000000000000..916f497e6cadf6d6a2b8c78e90a416eaa284c0bf
 /dev/null
+++ b/AUTHORS
@@ 0,0 +1,9 @@
+PierreJean Spaenlehauer (pierrejean.spaenlehauer@inria.fr)
+
+This software implements the BrillNoether algorithm for computing RiemannRoch
+spaces and is based on the work done by Aude Le Gluher in her Master's thesis.
+
+The files ZZ_pXResultant.cc and ZZ_pXResultant.h have been written by Pierrick
+Gaudry and are based on the NTL code for computing resultants. We thank
+Pierrick Gaudry for allowing us to use these functions and to include them in
+this software.
diff git a/EXAMPLE b/EXAMPLE
new file mode 100644
index 0000000000000000000000000000000000000000..172195b03e21e698680cc24a60e4aaa73282ec79
 /dev/null
+++ b/EXAMPLE
@@ 0,0 +1,3 @@
+make rrspace class_grp_arith
+./rrspace < example_rrspace_input
+./class_grp_arith < example_class_grp_div_input
diff git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..4362b49151d7b34ef83b3067a8f9c9f877d72a0e
 /dev/null
+++ b/LICENSE
@@ 0,0 +1,502 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free softwareto make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packagestypically librariesof the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a twostep method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into nonfree programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing nonfree programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a defacto standard. To achieve this, nonfree programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used nonfree libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in nonfree
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+nonfree programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely welldefined independent of the
+ application. Therefore, Subsection 2d requires that any
+ applicationsupplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machinereadable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machinereadable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machinereadable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interfacecompatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library sidebyside in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royaltyfree redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+
+ Copyright (C)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ , 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
diff git a/Makefile b/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..3e632870bd267df9fb21e7ab87b90f864ac3f7df
 /dev/null
+++ b/Makefile
@@ 0,0 +1,26 @@
+CPPFLAGS=pedantic Wall std=c++11 O3
+LDLIBS=lntl lgmpxx lgmp lm
+
+all: rrspace class_grp_arith tests
+
+clean:
+ rm *.o rrspace class_grp_arith tests
+
+algos.o: bivpol.h divisor.h curve.h algos.h algos.cc
+
+bivpol.o: bivpol.h bivpol.cc
+
+divisor.o: divisor.h curve.h bivpol.h divisor.cc
+
+divisor_class_group.o: divisor.h curve.h bivpol.h divisor.h divisor_class_group.h divisor_class_group.cc
+
+ZZ_pXResultant.o: ZZ_pXResultant.h ZZ_pXResultant.cc
+
+rrspace: rrspace.cc algos.o bivpol.o ZZ_pXResultant.o divisor.o
+
+class_grp_arith: class_grp_arith.cc algos.o bivpol.o ZZ_pXResultant.o divisor.o divisor_class_group.o
+
+tests: tests.cc algos.o bivpol.o ZZ_pXResultant.o divisor.o divisor_class_group.o
+ $(CXX) $(CPPFLAGS) $^ $(LDLIBS) lcppunit o $@
+
+.PHONY: all clean cleanall
diff git a/README b/README
new file mode 100644
index 0000000000000000000000000000000000000000..e60967ab56a43b0189b38e0915887740cab2f4dd
 /dev/null
+++ b/README
@@ 0,0 +1,137 @@
+This software is distributed under LGPL2.1+ (i.e., LGPL version 2.1 or later).
+
+Please report bugs to .
+
+I  Installation
+
+
+This software can be compiled using GNU make with g++.
+Running the command
+ make
+in the directory containing the source files builds three executable files:
+rrspace, class_grp_arith and tests.
+
+In order to build only one of these programs, use the command
+ make
+where is rrspace, class_grp_arith or tests
+
+Compiling this software requires the NTL library (https://www.shoup.net/ntl/).
+In order to compile the program "tests", the library cppunit is also required
+(https://freedesktop.org/wiki/Software/cppunit/).
+
+After compiling, the three following commands should succeed without any error:
+ ./tests
+ ./rrspace < example_rrspace_input
+ ./class_grp_arith < example_class_grp_div_input
+
+II  Usage
+
+
+Examples of inputs for rr_space and class_grp_arith are provided in the files
+example_rrspace_input and example_class_grp_div_input. The formats for the
+mathematical objects are detailed in the next section.
+
+Disclaimer: The algorithms implemented in this software are probabilistic, and
+they have a probability of failure. Also, they rely on some genericity
+assumptions (such as generic coordinates). Finally, some problems may arise in
+small characteristic, for instance if the characteristic divides the degree of
+the curve.
+In case of failure, the most probable situation is that just starting again the
+software with the same input will work. In the unlikely situation that it still
+fails, changing the system of coordinates by doing a random linear change of
+projective coordinates and by computing the curve equation and the divisors in
+this new coordinate system may work. Finally, if none of this works, this means
+that we are in the very unlikely case where all the possible denominators which
+could be returned by the interpolation function vanish at singular points of
+the curve (this case cannot occur if the curve is smooth). In this case, please
+use another model of the curve.
+
+1) rrspace: the program rrspace computes the RiemannRoch space associated to a
+given divisor D on a curve q. It reads its input on the standard input, and it
+returns a basis of the RiemannRoch space on the standard output.
+
+The format for its input (see next section for more details) is
+
+
+
+
+
+where represents a divisor whose support does not contain any
+singular point of the curve.
+
+It outputs the following data:
+  the dimension D of the RiemannRoch space;
+  a denominator h, which is a bivariate polynomial;
+  a list of D bivariate polynomials g_1, ..., g_D
+
+The set of rational functions {g_1/h, ..., g_D/h} is a basis of the
+RiemannRoch space.
+
+2) class_grp_arith: this program takes as input two elements of the divisor
+class group of a curve C of genus g and it returns a representation of the sum. Here, we
+are given a curve, together with a degree 1 divisor on C. A class of divisors
+(modulo principal divisors) is represented by an effective divisor D1 of degree
+g: it represents the class of divisors equivalent to the degree0 divisor D1 
+g*O.
+
+class_grp_arith reads its input on the standard input, and it returns an
+effective divisor of degree at most g on the standard output.
+
+The format for its input (see next section for more details) is
+
+
+
+
+
+
+
+
+The divisor provided on the 4th line must have degree 1. The two effective
+divisors D1 and D2 provided on the last two lines must have degree .
+The supports of all the divisors must not contain any singular point of the
+curve.
+
+The program returns a representation of a degreeg effective divisor D3 such that
+(D1g*O) + (D2g*O) = (D3g*O)
+in the divisor class group of C.
+
+3) tests: this software does not take any input. It just runs two tests: one
+for the computation of RiemannRoch spaces, and one for the arithmetic in the
+divisor class group of a smooth quartic curve. It should output the string
+"OK".
+
+III  Data structures
+
+
+This section details the data structures for the input of the programs
+described in Section II.
+
+: a prime number p
+
+: a bivariate polynomial q = sum_{i=0}^d q_i(x)*y^i, where for all i,
+q_i is a polynomial of degree at most di. The program requires that q_d(x) = 1.
+The polynomial q is encoded as follows
+ [ [ ... ] ]
+where is the degree of the curve and is the list of coefficients
+of the polynomial q_i. For instance if q_i(x) = sum_{j=0}^{r} q_{i,j} x^j,
+then should be
+ [ q_{i,0} q_{i,1} ... q_{i,r} ]
+
+: the genus of the curve C described by the polynomial q. We decline all
+responsability on the behavior of the programs if g is not the genus of the
+curve.
+
+: an effective divisor on C represented by two univariate
+polynomials
+ < >
+Each polynomial is described by the list of its coefficients
+ [ f_0 f_1 ... f_l ]
+These two polynomials (referred to as f(X), g(X)) should satisfy the following
+equality: q(X, g(X)) mod f(X) = 0.
+They represent the effective divisor which is the sum of points (\alpha, \beta)
+with multiplicity \gamma where \alpha is a root of multiplicity \gamma of f(X)
+and \beta = g(\alpha).
+
+: a divisor D on the curve C represented by two effective divisors D_+
+and D_ such that D = D_+  D_.
+ { }
diff git a/README.md b/README.md
deleted file mode 100644
index ca665501690fa38b174966ec1824bb26b6daf8ff..0000000000000000000000000000000000000000
 a/README.md
+++ /dev/null
@@ 1,4 +0,0 @@
# rrspace

The rrspace software computes bases of RiemannRoch spaces for curves defined over Z/pZ.
It also provides functions to compute the group law on the Jacobain of such curves.
\ No newline at end of file
diff git a/ZZ_pXResultant.cc b/ZZ_pXResultant.cc
new file mode 100644
index 0000000000000000000000000000000000000000..08c51db5e9df24af90a8fcf7133997cb4aba684d
 /dev/null
+++ b/ZZ_pXResultant.cc
@@ 0,0 +1,313 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+/* This file has been written by Pierrick Gaudry
+ * */
+
+#include
+
+#include
+#include
+
+using namespace std;
+
+// include code from NTL's official ZZ_pX.c
+NTL_OPEN_NNS
+ void mul(ZZ_pX& U, ZZ_pX& V, const ZZ_pXMatrix& M);
+ void mul(ZZ_pXMatrix& A, ZZ_pXMatrix& B, ZZ_pXMatrix& C);
+ void PlainResultant(ZZ_p& rres, const ZZ_pX& a, const ZZ_pX& b);
+ void ResIterHalfGCD(ZZ_pXMatrix& M_out, ZZ_pX& U, ZZ_pX& V, long d_red,
+ vec_ZZ_p& cvec, vec_long& dvec);
+ void ResHalfGCD(ZZ_pXMatrix& M_out, const ZZ_pX& U, const ZZ_pX& V,
+ long d_red, vec_ZZ_p& cvec, vec_long& dvec);
+ void ResHalfGCD(ZZ_pX& U, ZZ_pX& V, vec_ZZ_p& cvec, vec_long& dvec);
+NTL_CLOSE_NNS
+
+
+NTL_START_IMPL
+
+// Euclidian algorithm between U and V
+// Fill in cvec and dvec with degrees and LeadCoeffs of all the
+// polynomials, starting with V and finishing with the last nonzero
+// poly.
+// U and V are modified: at the end, V is 0 and U is the previous poly
+// (usually a constant). UU is filled with the anteprevious poly
+// (usually of degree 1: the last subresultant up to a mult. factor)
+void PlainResultant(ZZ_pX& UU, ZZ_pX& U, ZZ_pX& V, vec_ZZ_p& cvec,
+ vec_long& dvec) {
+ ZZ_pX Q;
+ ZZVec tmp(deg(U)+1, ZZ_pInfo>ExtendedModulusSize);
+
+ while (deg(V) >= 0) {
+ append(cvec, LeadCoeff(V));
+ append(dvec, deg(V));
+ UU = U;
+ PlainDivRem(Q, U, U, V, tmp);
+ swap(U, V);
+ }
+}
+
+
+
+// returns the resultant and the last nontrivial subresultant
+// rres is the resultant
+// subres1 is the last subresultant (of degree <= 1)
+// subres2 is filled if the subres1 is degenerated (of degree 0). Then
+// subres2 is the last nontrivial subresultant.
+// All of this might fail, in the sense that subres1 and subres2 could
+// be 0 instead of having meaningful values. In particular, if rres = 0,
+// no further information is obtained. However, if a subres is <> 0, then
+// it is (should be?) exact.
+//
+// Warning: subres1 and subres2 are not allowed to be aliases of the
+// input parameters.
+void PlainResultantWithSubRes(ZZ_p& rres, ZZ_pX& subres1, ZZ_pX& subres2,
+ const ZZ_pX& a, const ZZ_pX& b)
+{
+ ZZ_p res, saved_res;
+
+ clear(subres1);
+ clear(subres2);
+
+ if (IsZero(a)  IsZero(b))
+ clear(res);
+ else if (deg(a) == 0 && deg(b) == 0)
+ set(res);
+ else {
+ long d0, d1, d2;
+ long sg = 1;
+ ZZ_p lc;
+ set(res);
+
+ long n = max(deg(a),deg(b)) + 1;
+ ZZ_pX u(INIT_SIZE, n), v(INIT_SIZE, n), saved_u(INIT_SIZE, n);
+ ZZVec tmp(n, ZZ_pInfo>ExtendedModulusSize);
+
+ u = a;
+ v = b;
+
+ for (;;) {
+ d0 = deg(u);
+ d1 = deg(v);
+ lc = LeadCoeff(v);
+
+ saved_u = u;
+ PlainRem(u, u, v, tmp);
+ swap(u, v);
+
+ d2 = deg(v);
+ if (d2 >= 0) {
+ power(lc, lc, d0d2);
+ saved_res = res;
+ mul(res, res, lc);
+ if (d0 & d1 & 1) negate(res, res);
+ if (!((d0d1) & 1)) {
+ sg = sg;
+ cerr << "sg = " << sg << endl;
+ }
+// cerr << saved_res*u << endl;
+ }
+ else {
+ if (d1 == 0) {
+ cerr << "d0 = " << d0 << endl;
+ subres1 = sg*saved_res*saved_u;
+ if (deg(subres1) > 1) { // degenerated case
+ subres2 = subres1;
+ if (deg(subres1) > 2)
+ clear(subres1);
+ else
+ subres1 = saved_res*lc*power(LeadCoeff(saved_u),d0);
+ }
+ power(lc, lc, d0);
+ mul(res, res, lc);
+ }
+ else {
+ subres1 = sg*res*u;
+ if (deg(subres1) > 1) { // *very* degenerated case
+ cerr << "WARNING: This case is not fully implemented!!!\n";
+ subres2 = subres1;
+ if (deg(subres1) > 2)
+ clear(subres1);
+ else
+ subres1 = res*lc*power(LeadCoeff(u),d0);
+ }
+ clear(res);
+ }
+ break;
+ }
+ }
+
+ rres = res;
+ }
+}
+
+static void Coef(ZZ_p& Coe, vec_ZZ_p& cvec, vec_long& dvec) {
+ int r = cvec.length();
+ ZZ_p t;
+
+ set(Coe);
+ for (int l = 3; l <= r1; ++l) {
+ power(t, cvec[l2], dvec[l3]dvec[l1]);
+ mul(Coe, Coe, t);
+ }
+}
+
+static void Signs(long& sig1, long& sig2, vec_long& dvec) {
+ int r = dvec.length();
+ sig1 = 0; sig2 = 0;
+
+ for (int l = 3; l <= r1; ++l) {
+ sig1 = (sig1 + dvec[l3]*(dvec[l2] & 1L)) & 1L;
+ sig2 = (sig2 + 1L + dvec[l3] + dvec[l2]) & 1L;
+ }
+}
+
+
+// For the moment, I assume that deg(u) > deg(v) and v1 <> 0
+void resultantWithSubRes(ZZ_p& rres, ZZ_pX& subres,
+ const ZZ_pX& u, const ZZ_pX& v)
+{
+#if 0
+ if (deg(u) <= NTL_ZZ_pX_GCD_CROSSOVER  deg(v) <= NTL_ZZ_pX_GCD_CROSSOVER) {
+ PlainResultantWithSubRes(rres, subres1, subres2, u, v);
+ return;
+ }
+#endif
+ ZZ_pX u1, v1;
+
+ u1 = u;
+ v1 = v;
+
+ ZZ_p t;
+ ZZ_pX res;
+#if 0
+ clear(subres1);
+ clear(subres2);
+
+ if (deg(u1) == deg(v1)) {
+ rem(u1, u1, v1);
+ swap(u1, v1);
+
+ if (IsZero(v1)) {
+ clear(rres);
+ return;
+ }
+
+ power(t, LeadCoeff(u1), deg(u1)  deg(v1));
+ mul(res, res, t);
+ if (deg(u1) & 1)
+ negate(res, res);
+ }
+ else if (deg(u1) < deg(v1)) {
+ swap(u1, v1);
+ if (deg(u1) & deg(v1) & 1)
+ negate(res, res);
+ }
+#endif
+ assert ((deg(u1) >= deg(v1)) && (v1 != 0));
+
+ vec_ZZ_p cvec;
+ vec_long dvec;
+
+ cvec.SetMaxLength(deg(v1)+2);
+ dvec.SetMaxLength(deg(v1)+2);
+
+ append(cvec, LeadCoeff(u1));
+ append(dvec, deg(u1));
+
+
+ while (deg(u1) > NTL_ZZ_pX_GCD_CROSSOVER && !IsZero(v1)) {
+ ResHalfGCD(u1, v1, cvec, dvec);
+
+ if (!IsZero(v1)) {
+ append(cvec, LeadCoeff(v1));
+ append(dvec, deg(v1));
+ rem(u1, u1, v1);
+ swap(u1, v1);
+ }
+ }
+
+ if (IsZero(v1) && deg(u1) > 0) {
+ clear(rres);
+ return;
+ }
+
+
+ if (deg(u1) <= 1) {
+ // we went all the way...
+ // Too Bad!!! we have skipped the interesting subresultant.
+ // ==> in this rare case, we go back to the naive algorithm
+ // (in principle we should detect exactly which step of the
+ // recursive call went too fast and to redo just that one... but
+ // this is too much work for something that nether (?) happens.)
+ u1 = u; v1 = v;
+ cvec.SetLength(0);
+ dvec.SetLength(0);
+ append(cvec, LeadCoeff(u1));
+ append(dvec, deg(u1));
+ }
+
+ ZZ_pX UU;
+ ZZ_p Coe;
+ long sig1, sig2;
+ PlainResultant(UU, u1, v1, cvec, dvec);
+
+ long r = dvec.length();
+ assert (cvec.length() == dvec.length());
+
+ Coef(Coe, cvec, dvec);
+ Signs(sig1, sig2, dvec);
+ power(t, cvec[r2], dvec[r3]  dvec[r2]  1);
+ mul(Coe, Coe, t);
+
+ mul(subres, Coe, UU);
+ if ((sig1 + dvec[r2]*sig2) & 1UL)
+ negate(subres, subres);
+
+ sig1 = (sig1 + dvec[r3]*(dvec[r2] & 1L)) & 1L;
+ sig2 = (sig2 + 1L + dvec[r3] + dvec[r2]) & 1L;
+ power(t, cvec[r2], dvec[r2]  dvec[r1] + 1);
+ mul(Coe, Coe, t);
+
+ mul(res, u1, Coe);
+ power(t, cvec[r1], dvec[r2]  dvec[r1]  1);
+ mul(res, res, t);
+ if ((sig1 + dvec[r1]*sig2) & 1L)
+ negate(res, res);
+
+ if (deg(res) >= 1) {
+ subres = res;
+ res = 0;
+ if (deg(subres) >= 2)
+ subres = 0;
+ } else if (deg(subres) > 2) {
+ subres = 0;
+ } else if (deg(subres) == 2) {
+ mul(subres, Coe, u1);
+ power(t, cvec[r2], 1(dvec[r2]  dvec[r1]));
+ mul(subres, subres, t);
+ if ((sig1 + (dvec[r2]+1)*sig2) & 1L)
+ negate(subres, subres);
+ }
+
+ rres = coeff(res,0);
+}
+
+NTL_END_IMPL
diff git a/ZZ_pXResultant.h b/ZZ_pXResultant.h
new file mode 100644
index 0000000000000000000000000000000000000000..c93f1b0635f982110a9b462576605bb65e35fb48
 /dev/null
+++ b/ZZ_pXResultant.h
@@ 0,0 +1,40 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+/* This file has been written by Pierrick Gaudry
+ * */
+
+#ifndef NTL_ZZ_pXResultant__H
+#define NTL_ZZ_pXResultant__H
+
+#include
+#include
+#include
+
+NTL_OPEN_NNS
+
+void resultantWithSubRes(ZZ_p& rres, ZZ_pX& subres,
+ const ZZ_pX& u, const ZZ_pX& v);
+
+NTL_CLOSE_NNS
+
+#endif
+
+
diff git a/algos.cc b/algos.cc
new file mode 100644
index 0000000000000000000000000000000000000000..26aa1d91eea08db603256ef0edabd024e939ca5d
 /dev/null
+++ b/algos.cc
@@ 0,0 +1,242 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+#include "algos.h"
+#include
+#include
+#include "ZZ_pXResultant.h"
+
+using namespace NTL;
+using namespace std;
+
+size_t
+GetInterpolationDegree(size_t deg_curve, size_t deg_div) {
+ if ((deg_curve + 1)*deg_curve > 2*deg_div)
+ return floor((1+sqrt(1+8*deg_div)1)/2);
+ return floor((double)deg_div/(double)deg_curve+((double)deg_curve1)/2);
+}
+
+// Returns a vector such that the indth element is the pair (i, j) which
+// corresponds to the indth monomial X^i Y^j such that j < deg_curve
+vector >
+BuildMonomialVector(size_t deg_curve, size_t deg_max) {
+ vector > res;
+ for (size_t d = 0; d <= deg_max; ++d)
+ for (size_t i = 0; i <= min(d, deg_curve  1); ++i)
+ res.push_back(pair(di, i));
+ return res;
+}
+
+mat_ZZ_p
+BuildInterpolationMatrixInDegree(const EffectiveDivisor& D, size_t deg) {
+ vector powers_of_g;
+ vector powers_of_x;
+
+ powers_of_g.push_back(ZZ_pX(1));
+ powers_of_x.push_back(ZZ_pX(1));
+
+ ZZ_pXModulus modf(D.get_f());
+
+ ZZ_pX x_pol(1);
+ x_pol <<= 1;
+
+ for (size_t i = 0; i <= min(deg, D.curve().degree()1); ++i) {
+ ZZ_pX tmp;
+ MulMod(tmp, powers_of_g.back(), D.get_g(), modf);
+ powers_of_g.push_back(tmp);
+ }
+
+ for (size_t i = 0; i <= deg; ++i) {
+ ZZ_pX tmp;
+ MulMod(tmp, powers_of_x.back(), x_pol % modf, modf);
+ powers_of_x.push_back(tmp);
+ }
+
+ auto vec_mons = BuildMonomialVector(D.curve().degree(), deg);
+ Vec > vec_vec_res;
+ Vec tmp_row;
+ ZZ_pX tmp_pol;
+
+ for (const auto& p : vec_mons) {
+ tmp_row.SetLength(0);
+ MulMod(tmp_pol, powers_of_x[p.first], powers_of_g[p.second], modf);
+ for (size_t i = 0; i < D.degree(); ++i)
+ tmp_row.append(coeff(tmp_pol, i));
+ vec_vec_res.append(tmp_row);
+ }
+
+ mat_ZZ_p res;
+ res.SetDims(vec_mons.size(), D.degree());
+ MakeMatrix(res, vec_vec_res);
+
+ return res;
+}
+
+BivPol
+Interpolate(const EffectiveDivisor& D) {
+ size_t deg_res = GetInterpolationDegree(D.curve().degree(), D.degree());
+ mat_ZZ_p M = BuildInterpolationMatrixInDegree(D, deg_res);
+ mat_ZZ_p kerM;
+ kernel(kerM, M);
+ mat_ZZ_p randmat;
+ randmat.SetDims(1, kerM.NumRows());
+ for (size_t i = 0; i < (size_t)kerM.NumRows(); ++i)
+ randmat.put(0, i, random_ZZ_p());
+ mul(kerM, randmat, kerM);
+ vector interp_pol;
+ auto vec_mons = BuildMonomialVector(D.curve().degree(), deg_res);
+ interp_pol.insert(interp_pol.begin(),
+ min(D.curve().degree(), deg_res + 1),
+ ZZ_pX(0));
+ for (size_t i = 0; i < vec_mons.size(); ++i) {
+ pair p = vec_mons[i];
+ interp_pol[p.second] += kerM.get(0, i)* (ZZ_pX(1) << p.first);
+ }
+ while (IsZero(interp_pol.back()))
+ interp_pol.pop_back();
+ interp_pol.shrink_to_fit();
+ BivPol res(interp_pol);
+ assert(!res.IsZero());
+ return res;
+}
+
+EffectiveDivisor
+PrincipalDivisor(const Curve& C, const BivPol& h) {
+ size_t deg_res = h.degree() * C.degree(); // Bézout bound
+ vec_ZZ_p eval_pts;
+ for (long i = 0; i <= (long)deg_res; ++i)
+ eval_pts.append(ZZ_p(i));
+ vec_vec_ZZ_p eval_C, eval_h;
+ vec_ZZ_p eval_res, eval_subres0, eval_subres1;
+ for (size_t i = 0; i <= C.degree(); ++i)
+ eval_C.append(eval(C.coeff(i), eval_pts));
+ for (size_t i = 0; i <= h.degree_y(); ++i)
+ eval_h.append(eval(h.coeff(i), eval_pts));
+
+ for (size_t i = 0; i <= deg_res; ++i) {
+ ZZ_pX C_tmp, h_tmp, subres_tmp;
+ ZZ_p res_tmp;
+
+ for (size_t j = 0; j <= C.degree(); ++j)
+ C_tmp += eval_C[j][i] * (ZZ_pX(1) << j);
+ for (size_t j = 0; j <= h.degree_y(); ++j)
+ h_tmp += eval_h[j][i] * (ZZ_pX(1) << j);
+
+ resultantWithSubRes(res_tmp, subres_tmp, C_tmp, h_tmp);
+ assert(deg(subres_tmp) == 1);
+ eval_res.append(res_tmp);
+ eval_subres0.append(ConstTerm(subres_tmp));
+ eval_subres1.append(LeadCoeff(subres_tmp));
+ }
+
+ ZZ_pX res = interpolate(eval_pts, eval_res);
+ ZZ_pX subres0 = interpolate(eval_pts, eval_subres0);
+ ZZ_pX subres1 = interpolate(eval_pts, eval_subres1);
+
+ return EffectiveDivisor(C, res, MulMod(InvMod(subres1, res), subres0, res));
+}
+
+EffectiveDivisor
+PositiveDifference(const EffectiveDivisor& D1, const EffectiveDivisor& D2) {
+ assert(D1.curve() == D2.curve());
+ ZZ_pX f;
+ divide(f, D1.get_f(), GCD(D1.get_f(), D2.get_f()));
+ return EffectiveDivisor(D1.curve(), f/LeadCoeff(f), D1.get_g() % f);
+}
+
+EffectiveDivisor
+Sum(const EffectiveDivisor& D1, const EffectiveDivisor& D2) {
+ assert(D1.curve() == D2.curve());
+ assert(deg(GCD(D1.get_f(), D2.get_f())) == 0);
+ if (deg(D1.get_f()) == 0)
+ return D2;
+ if (deg(D2.get_f()) == 0)
+ return D1;
+ ZZ_pX new_f = D1.get_f()*D2.get_f();
+ ZZ_pX new_g = (D1.get_g()*D2.get_f()*InvMod(D2.get_f() % D1.get_f(), D1.get_f()) +
+ D2.get_g()*D1.get_f()*InvMod(D1.get_f() % D2.get_f(), D2.get_f())) %
+ (D1.get_f()*D2.get_f());
+ assert(new_g % D1.get_f() == D1.get_g());
+ assert(new_g % D2.get_f() == D2.get_g());
+ return EffectiveDivisor(D1.curve(), new_f, new_g);
+}
+
+EffectiveDivisor
+MultiplyByInt(const EffectiveDivisor& D, unsigned int k) {
+ ZZ_pX _f = D.get_f();
+ ZZ_pX _g = D.get_g();
+
+ assert(IsZero(D.curve().get_pdefpol()>mod_eval(_g, _f)));
+
+ // Case where D is the zero divisor
+ if (deg(_f) == 0)
+ return D;
+
+ int nbsteps;
+ frexp((double)k, &nbsteps);
+ // TODO: do all computations mod _f
+ _g = NewtonHensel(*D.curve().get_pdefpol(), _g, _f, nbsteps);
+ power(_f, _f, k);
+ return EffectiveDivisor(D.curve(), _f, _g % _f);
+}
+
+Divisor
+Sum(const Divisor& D1, const Divisor& D2) {
+ return Divisor(Sum(D1.get_pos(), D2.get_pos()),
+ Sum(D1.get_neg(), D2.get_neg()));
+}
+
+Divisor
+MultiplyByInt(const Divisor& D, unsigned int k) {
+ return Divisor(MultiplyByInt(D.get_pos(), k), MultiplyByInt(D.get_neg(), k));
+}
+
+vector
+EffectiveBasisRRinDegree(const EffectiveDivisor& D, size_t deg) {
+ vector res;
+ mat_ZZ_p M = BuildInterpolationMatrixInDegree(D, deg);
+ mat_ZZ_p kerM;
+ kernel(kerM, M);
+ for (long k = 0; k < kerM.NumRows(); ++k) {
+ vector interp_pol;
+ auto vec_mons = BuildMonomialVector(D.curve().degree(), deg);
+ interp_pol.insert(interp_pol.begin(),
+ min(D.curve().degree(), deg + 1),
+ ZZ_pX(0));
+ for (size_t i = 0; i < vec_mons.size(); ++i) {
+ pair p = vec_mons[i];
+ interp_pol[p.second] += kerM.get(k, i)* (ZZ_pX(1) << p.first);
+ }
+ while (IsZero(interp_pol.back()))
+ interp_pol.pop_back();
+ interp_pol.shrink_to_fit();
+ res.push_back(BivPol(interp_pol));
+ }
+ return res;
+}
+
+RRspace
+RiemannRochBasis(const Divisor& D) {
+ BivPol h = Interpolate(D.get_pos());
+ EffectiveDivisor Dp = PrincipalDivisor(D.curve(), h);
+ EffectiveDivisor Dp2 = PositiveDifference(Dp, D.get_pos());
+ EffectiveDivisor newDneg = Sum(Dp2, D.get_neg());
+ return RRspace(h, EffectiveBasisRRinDegree(newDneg, h.degree()), newDneg);
+}
diff git a/algos.h b/algos.h
new file mode 100644
index 0000000000000000000000000000000000000000..89123659bb9f2959346ee216917640a50746cf64
 /dev/null
+++ b/algos.h
@@ 0,0 +1,80 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+// This file contains routines for constructing a function on a curve of
+// prescribed degree having zeros at prescribed places and with prescribed
+// multiplicities.
+
+#ifndef INTERPOLATION_DIV_H_
+#define INTERPOLATION_DIV_H_
+
+#include
+#include
+#include "bivpol.h"
+#include "divisor.h"
+
+// Given an effective divisor D, compute a form h on the curve such that (h) >= D
+BivPol
+Interpolate(const EffectiveDivisor& D);
+
+NTL::mat_ZZ_p
+BuildInterpolationMatrixInDegree(const EffectiveDivisor& D, std::size_t deg);
+
+// Given a form h on the curve, compute the principal effective divisor (h)
+EffectiveDivisor
+PrincipalDivisor(const Curve& C, const BivPol& h);
+
+EffectiveDivisor
+PositiveDifference(const EffectiveDivisor& D1, const EffectiveDivisor& D2);
+
+// Add the possibility that the supports are not disjoint
+EffectiveDivisor
+Sum(const EffectiveDivisor& D1, const EffectiveDivisor& D2);
+
+EffectiveDivisor
+MultiplyByInt(const EffectiveDivisor& D, unsigned int k);
+
+// TODO: simplify obtained divisor
+Divisor
+Sum(const Divisor& D1, const Divisor& D2);
+
+Divisor
+MultiplyByInt(const Divisor& D, unsigned int k);
+
+std::vector
+EffectiveBasisRRinDegree(const EffectiveDivisor& D, std::size_t deg);
+
+struct RRspace {
+ BivPol denom;
+ std::vector num_basis;
+
+ // Residual divisor added with zeroes: (h)  D_+ + D_
+ // Useful for implementing the arithmetic in the Jacobian with reduced
+ // representations of divisors.
+ EffectiveDivisor Dnum;
+
+ RRspace(const BivPol& tdenom, const std::vector& tnum_basis, const EffectiveDivisor& tDnum)
+ : denom(tdenom), num_basis(tnum_basis), Dnum(tDnum) {}
+};
+
+RRspace
+RiemannRochBasis(const Divisor& D);
+
+#endif
diff git a/bivpol.cc b/bivpol.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6dce94542a09f84dd73b188ddec1adde2182d3e7
 /dev/null
+++ b/bivpol.cc
@@ 0,0 +1,135 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+#include "bivpol.h"
+
+using namespace std;
+using namespace NTL;
+
+size_t
+BivPol::degree() const {
+ size_t res = 0;
+ for (size_t i = 0; i < coeffs.size(); ++i)
+ res = max(res, i + max(deg(coeffs[i]), 0));
+ return res;
+}
+
+bool
+BivPol::IsZero() const {
+ for (size_t i =0; i < coeffs.size(); ++i)
+ if (!NTL::IsZero(coeffs[i]))
+ return false;
+ return true;
+}
+
+ZZ_pX
+BivPol::mod_eval(const ZZ_pX& g, const ZZ_pX& modulus) const {
+ assert(modulus != ZZ_pX(0));
+ if (deg(modulus) == 0)
+ return ZZ_pX(0);
+ ZZ_pXModulus mod(modulus);
+ ZZ_pX power_g(1);
+ ZZ_pX res(0);
+ for (size_t i = 0; i < coeffs.size(); ++i) {
+ res += MulMod(coeffs[i] % mod, power_g, mod);
+ MulMod(power_g, power_g, g, mod);
+ }
+ return res;
+}
+
+BivPol
+BivPol::diffY() const {
+ std::vector coeffs_res;
+ for (size_t i = 1; i < coeffs.size(); ++i)
+ coeffs_res.push_back(i*coeffs[i]);
+ return BivPol(coeffs_res);
+}
+
+ZZ_pX
+NewtonHenselStep(const BivPol& q, const ZZ_pX& s, const ZZ_pX& modulus) {
+ assert(deg(modulus) > 0);
+ assert(IsZero(q.mod_eval(s, modulus)));
+ ZZ_pX mod2 = sqr(modulus);
+ ZZ_pX denom = q.diffY().mod_eval(s, mod2);
+ ZZ_pX num = q.mod_eval(s, mod2);
+ assert(deg(GCD(denom, mod2)) == 0);
+ ZZ_pX invdenom = InvMod(denom, mod2);
+ ZZ_pX NH_step = MulMod(num, invdenom, mod2);
+ ZZ_pX res = s  NH_step;
+ assert(IsZero(q.mod_eval(res, mod2)));
+ return res;
+}
+
+ZZ_pX
+NewtonHensel(const BivPol& q, const ZZ_pX& s, const ZZ_pX& modulus, std::size_t k) {
+ ZZ_pX R = s;
+ ZZ_pX mod2 = modulus;
+ for (std::size_t i = 0; i < k; ++i) {
+ R = NewtonHenselStep(q, R, mod2);
+ mod2 = sqr(mod2);
+ }
+ return R;
+}
+
+ostream&
+operator<<(ostream& o, const BivPol& P) {
+ o << "[ ";
+ for (size_t i = 0; i <= P.degree_y(); ++i)
+ o << P.coeff(i) << " ";
+ o << "]";
+ return o;
+}
+
+ostream&
+PrintMagma(ostream& o, const ZZ_pX& P) {
+ o << "(";
+ for (size_t i = 0; i < (size_t)deg(P); ++i)
+ if (!IsZero(coeff(P, i)))
+ o << coeff(P, i) << "*x^" << i << " + ";
+ o << coeff(P, deg(P)) << "*x^" << deg(P);
+ o << ")";
+ return o;
+}
+
+ostream&
+PrintMagma(ostream& o, const BivPol& P) {
+ for (size_t i = 0; i < P.degree_y(); ++i)
+ if (!IsZero(P.coeff(i)))
+ PrintMagma(o, P.coeff(i)) << "*y^" << i << " + ";
+ PrintMagma(o, P.coeff(P.degree_y())) << "*y^" << P.degree_y();
+ return o;
+}
+
+
+istream&
+operator>>(istream& i, BivPol& res) {
+ string s = "";
+ size_t deg;
+ res.coeffs.clear();
+ ZZ_pX tmp;
+ i >> s;
+ i >> deg;
+ for (size_t j = 0; j <= deg; ++j) {
+ i >> tmp;
+ res.coeffs.push_back(tmp);
+ }
+ i >> s;
+ return i;
+}
diff git a/bivpol.h b/bivpol.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a28012cd59731bd7ac6fbbcf8b25de1e741a754
 /dev/null
+++ b/bivpol.h
@@ 0,0 +1,71 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+// class for bivariate polynomials over prime finite fields, written as
+// univariate polynomials with polynomial coefficients.
+// They are stored as a (d+1)uplet (g_0,...,g_d) of univariate polynomials, i.e
+// \sum_{i=0}^{d} g_i(X)*Y^i
+
+#ifndef BIVPOL_H_
+#define BIVPOL_H_
+
+#include
+#include
+#include
+#include
+
+class BivPol {
+ private:
+ std::vector coeffs;
+
+ public:
+ BivPol() {}
+ BivPol(const std::vector& _coeffs) : coeffs(_coeffs) {
+ assert(coeffs.back() != NTL::ZZ_p(0));
+ }
+
+ std::size_t degree() const;
+ std::size_t degree_y() const { return coeffs.size()  1; }
+ NTL::ZZ_pX coeff(std::size_t i) const { return coeffs[i]; }
+ NTL::ZZ_pX LeadingCoeff() const { return coeffs[coeffs.size()  1]; }
+ bool IsZero() const;
+ NTL::ZZ_pX mod_eval(const NTL::ZZ_pX& g, const NTL::ZZ_pX& modulus) const;
+ BivPol diffY() const;
+
+ friend std::istream& operator>>(std::istream&, BivPol&);
+};
+
+NTL::ZZ_pX
+NewtonHenselStep(const BivPol& q,
+ const NTL::ZZ_pX& s,
+ const NTL::ZZ_pX& modulus);
+
+// k steps of NewtonHensel lifting
+NTL::ZZ_pX
+NewtonHensel(const BivPol& q,
+ const NTL::ZZ_pX& s,
+ const NTL::ZZ_pX& modulus,
+ std::size_t k);
+
+std::ostream& operator<<(std::ostream&, const BivPol&);
+std::ostream& PrintMagma(std::ostream&, const BivPol&);
+std::istream& operator>>(std::istream&, BivPol&);
+
+#endif
diff git a/class_grp_arith.cc b/class_grp_arith.cc
new file mode 100644
index 0000000000000000000000000000000000000000..eaadf33e8a3115f85c0be4b80ae570ceb81f6505
 /dev/null
+++ b/class_grp_arith.cc
@@ 0,0 +1,50 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+#include
+#include
+#include "divisor_class_group.h"
+
+using namespace NTL;
+using namespace std;
+
+int main() {
+ long p;
+ BivPol eq_curve;
+ cin >> p;
+ ZZ_p::init(ZZ(p));
+ cin >> eq_curve;
+ Curve C(&eq_curve);
+
+ size_t g;
+ cin >> g;
+ Divisor D(C);
+ cin >> D;
+
+ EffectiveDivisor D1(C), D2(C);
+ cin >> D1;
+ cin >> D2;
+
+ EffectiveDivisor R = AddReduced(g, D, D1, D2);
+
+ cout << R << endl;
+ return 0;
+}
+
diff git a/curve.h b/curve.h
new file mode 100644
index 0000000000000000000000000000000000000000..28dfb9cc6a207233b9459a3d138f67f961d48cc1
 /dev/null
+++ b/curve.h
@@ 0,0 +1,47 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+#ifndef CURVE_H_
+#define CURVE_H_
+
+#include "bivpol.h"
+
+// We always assume that the curve is given in the following Noether form:
+// Y^d + sum_{i=0}^{d1} f_i(X)*Y^i
+
+class Curve {
+ private:
+ BivPol *pdefpol;
+
+ public:
+ Curve() = delete;
+ Curve(BivPol* const _pdefpol) : pdefpol(_pdefpol) {
+ assert(pdefpol>degree() == pdefpol>degree_y());
+ assert(NTL::IsOne(pdefpol>LeadingCoeff()));
+ }
+
+ bool operator==(const Curve& C) { return pdefpol == C.pdefpol; }
+
+ std::size_t degree() const { return pdefpol>degree_y(); }
+ NTL::ZZ_pX coeff(std::size_t i) const { return pdefpol>coeff(i); }
+ BivPol* get_pdefpol() const { return pdefpol; }
+};
+
+#endif
diff git a/divisor.cc b/divisor.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0a3abc5a44ffaf3c1ed0eab9d0f772dcbf859257
 /dev/null
+++ b/divisor.cc
@@ 0,0 +1,50 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+#include "divisor.h"
+
+using namespace std;
+using namespace NTL;
+
+ostream&
+operator<<(ostream& o, const EffectiveDivisor& D) {
+ o << "< " << D.get_f() << " " << D.get_g() << " >";
+ return o;
+}
+
+istream&
+operator>>(istream& i, EffectiveDivisor& D) {
+ string s;
+ i >> s >> D.f >> D.g >> s;
+ return i;
+}
+
+ostream&
+operator<<(ostream& o, const Divisor& D) {
+ o << "{ " << D.get_pos() << endl << D.get_neg() << " }";
+ return o;
+}
+
+istream&
+operator>>(istream& i, Divisor& D) {
+ string s;
+ i >> s >> D.Dpos >> D.Dneg >> s;
+ return i;
+}
diff git a/divisor.h b/divisor.h
new file mode 100644
index 0000000000000000000000000000000000000000..f09e8a6af4ea3b935db2dd241fc572ebb21e9c32
 /dev/null
+++ b/divisor.h
@@ 0,0 +1,87 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+// Class representing a Weil's divisor on a smooth plane curve given by a
+// bivariate polynomial which is monic (i.e. of the form Y^k + g(X,Y), with
+// deg_Y(g) < k).
+// Three further assumptions :
+//  We assume that no point in the support is at infinity
+//  The tangent at any point in the support should not be vertical
+// (i.e. X = 0)
+//  The points in the support should have distinct xcoordinates
+// All these three assumptions are satisfied in generic coordinates.
+
+#ifndef DIVISOR_H_
+#define DIVISOR_H_
+
+#include
+#include
+#include "curve.h"
+
+class EffectiveDivisor {
+ private:
+ NTL::ZZ_pX f;
+ NTL::ZZ_pX g;
+ Curve C;
+
+ public:
+ EffectiveDivisor() = delete;
+ EffectiveDivisor(const Curve& _C) : f(NTL::ZZ_pX(1)), g(NTL::ZZ_pX(0)), C(_C) {}
+ EffectiveDivisor(const Curve& _C, const NTL::ZZ_pX& _f, const NTL::ZZ_pX& _g)
+ : f(_f), g(_g), C(_C) {
+ assert(!NTL::IsZero(f));
+ assert(f == NTL::ZZ_pX(1)  NTL::IsZero(C.get_pdefpol()>mod_eval(g, f)));
+ }
+
+ Curve curve() const { return C; }
+ NTL::ZZ_pX get_f() const { return f; }
+ NTL::ZZ_pX get_g() const { return g; }
+ std::size_t degree() const { return deg(f); }
+
+ friend std::istream& operator>>(std::istream&, EffectiveDivisor&);
+};
+
+class Divisor {
+ private:
+ EffectiveDivisor Dpos;
+ EffectiveDivisor Dneg;
+
+ public:
+ Divisor() = delete;
+ Divisor(const Curve& C) : Dpos(C), Dneg(C) {}
+ Divisor(const EffectiveDivisor& _Dpos, const EffectiveDivisor& _Dneg)
+ : Dpos(_Dpos), Dneg(_Dneg) {
+ assert(Dpos.curve() == Dneg.curve());
+ }
+
+ std::size_t degree() const { return (int)Dpos.degree()  (int)Dneg.degree(); }
+ EffectiveDivisor get_pos() const { return Dpos; }
+ EffectiveDivisor get_neg() const { return Dneg; }
+ Curve curve() const { return Dpos.curve(); }
+
+ friend std::istream& operator>>(std::istream&, Divisor&);
+};
+
+std::ostream& operator<<(std::ostream&, const EffectiveDivisor&);
+std::istream& operator>>(std::istream&, EffectiveDivisor&);
+std::ostream& operator<<(std::ostream&, const Divisor&);
+std::istream& operator>>(std::istream&, Divisor&);
+
+#endif
diff git a/divisor_class_group.cc b/divisor_class_group.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e6967f88220b2e22d0b65f50c0eed5bd0b0083a6
 /dev/null
+++ b/divisor_class_group.cc
@@ 0,0 +1,50 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+#include "divisor_class_group.h"
+
+EffectiveDivisor
+DivisorReduction(const Divisor& D1, const Divisor& D2, std::size_t g) {
+ assert(D1.degree() == 0);
+ assert(D2.degree() == 1);
+ assert(D1.curve() == D2.curve());
+
+ RRspace E = RiemannRochBasis(Sum(D1, MultiplyByInt(D2, g)));
+ assert(E.num_basis.size() > 0);
+ return PositiveDifference(PrincipalDivisor(D1.curve(), E.num_basis[0]), E.Dnum);
+}
+
+// D degree 1 divisor
+EffectiveDivisor
+AddReduced(std::size_t g,
+ const Divisor& O,
+ const EffectiveDivisor& D1,
+ const EffectiveDivisor& D2) {
+ assert(O.curve() == D1.curve());
+ assert(O.curve() == D2.curve());
+ assert(O.degree() == 1);
+ assert(D1.degree() <= g);
+ assert(D2.degree() <= g);
+
+ Divisor gO = MultiplyByInt(O, g);
+ RRspace E = RiemannRochBasis(Divisor(Sum(Sum(D1, D2), gO.get_neg()), gO.get_pos()));
+ assert(E.num_basis.size() > 0);
+ return PositiveDifference(PrincipalDivisor(O.curve(), E.num_basis[0]), E.Dnum);
+}
diff git a/divisor_class_group.h b/divisor_class_group.h
new file mode 100644
index 0000000000000000000000000000000000000000..c16e12babf5e916a38073059f8cda0edaf8756a8
 /dev/null
+++ b/divisor_class_group.h
@@ 0,0 +1,47 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+// This file contains routines for computing reduced divisors with respect to a
+// degree 1 divisor. It also implements the group law in the divisor class
+// group.
+
+#ifndef DIVISOR_CLASS_GROUP_H_
+#define DIVISOR_CLASS_GROUP_H_
+
+#include "divisor.h"
+#include "algos.h"
+
+// Reduction routine: D1 must be a divisor of degree 0 and D2 must be a divisor
+// of degree 1.
+//
+// Returns an effective divisor D such that D1 = D  g*D2.
+// TODO: not yet tested.
+
+EffectiveDivisor
+DivisorReduction(const Divisor& D1, const Divisor& D2, std::size_t g);
+
+// D degree 1 divisor
+EffectiveDivisor
+AddReduced(std::size_t g,
+ const Divisor& D,
+ const EffectiveDivisor& D1,
+ const EffectiveDivisor& D2);
+
+#endif
diff git a/example_class_grp_div_input b/example_class_grp_div_input
new file mode 100644
index 0000000000000000000000000000000000000000..387e089e387d878c93792372ba33e264e9ae8a5f
 /dev/null
+++ b/example_class_grp_div_input
@@ 0,0 +1,6 @@
+1009
+[ 4 [810 944 972 589 71] [790 206 709 905] [236 969 139] [311 861] [1] ]
+3
+{ < [507 1] [832] > < [1] [] > }
+< [374 74 387 1] [78 130 82] >
+< [752 293 10 1] [17 109 43] >
diff git a/example_rrspace_input b/example_rrspace_input
new file mode 100644
index 0000000000000000000000000000000000000000..bb8fb0a91293e3509ad9b746de49db2e897f5d48
 /dev/null
+++ b/example_rrspace_input
@@ 0,0 +1,3 @@
+1009
+[ 5 [863 161 817 949 344 184] [132 747 1002 226 891] [768 119 991 128] [645 84 865] [351 37] [1] ]
+{ < [503 216 395 835 891 697 316 553 1] [773 952 513 814 518 605 87 42] > < [510 1] [928] > }
diff git a/rrspace.cc b/rrspace.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ffc2c68fa48e2dee3313dcdacca19b8d5b3ccdd9
 /dev/null
+++ b/rrspace.cc
@@ 0,0 +1,48 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+#include
+#include
+#include "algos.h"
+
+using namespace NTL;
+using namespace std;
+
+int main() {
+ long p;
+ BivPol eq_curve;
+ cin >> p;
+ ZZ_p::init(ZZ(p));
+ cin >> eq_curve;
+ Curve C(&eq_curve);
+ Divisor D(C);
+ cin >> D;
+
+ RRspace basisRR = RiemannRochBasis(D);
+
+ cout << "Dimension: " << basisRR.num_basis.size() << endl;
+ cout << "Denominator: " << endl;
+ PrintMagma(std::cout, basisRR.denom) << endl;
+ cout << "Numerators: " << endl;
+ for (size_t i = 0; i < basisRR.num_basis.size(); ++i)
+ PrintMagma(std::cout, basisRR.num_basis[i]) << endl;
+
+ return 0;
+}
diff git a/tests.cc b/tests.cc
new file mode 100644
index 0000000000000000000000000000000000000000..16a4b0ec844ca395ad5154b259444d460f7d5498
 /dev/null
+++ b/tests.cc
@@ 0,0 +1,157 @@
+/* Common header file for the rrspace software
+
+This file is part of the rrspace project.
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option) any
+later version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 021101301 USA
+
+*/
+
+#include
+#include
+#include
+#include
+#include "curve.h"
+#include "divisor.h"
+#include "divisor_class_group.h"
+#include
+
+class EllipticCurveTest : public CppUnit::TestFixture {
+ private:
+ BivPol *q;
+ Curve *C;
+
+ public:
+ void setUp() {
+ NTL::ZZ_p::init(NTL::ZZ(1009));
+ NTL::ZZ_pX q0, q1, q2;
+ // Elliptic curve
+ std::stringstream("[304 38 866 317]") >> q0;
+ std::stringstream("[483 91 912]") >> q1;
+ std::stringstream("[262 839]") >> q2;
+ q = new BivPol({q0, q1, q2, NTL::ZZ_pX(1)});
+ C = new Curve(q);
+ }
+
+ void tearDown() {
+ delete C;
+ delete q;
+ }
+
+ void testGroupLaw() {
+ NTL::ZZ_pX fO, gO, f1, g1, f2, g2;
+
+ // O = (781 : 643 : 1)
+ std::stringstream("[228 1]") >> fO;
+ std::stringstream("[643]") >> gO;
+ Divisor O(
+ EffectiveDivisor(*C, fO, gO),
+ EffectiveDivisor(*C));
+
+ // P1 = (381 : 777 : 1)
+ std::stringstream("[628 1]") >> f1;
+ std::stringstream("[777]") >> g1;
+ EffectiveDivisor P1(*C, f1, g1);
+
+ // P2 = (769 : 205 : 1)
+ std::stringstream("[240 1]") >> f2;
+ std::stringstream("[205]") >> g2;
+ EffectiveDivisor P2(*C, f2, g2);
+
+ EffectiveDivisor P3 =
+ AddReduced(1, O, P1, P2);
+
+ NTL::ZZ_pX fR, gR;
+
+ // PR = (933 : 189 : 1)
+ std::stringstream("[76 1]") >> fR;
+ std::stringstream("[189]") >> gR;
+
+ CPPUNIT_ASSERT(P3.get_f() == fR);
+ CPPUNIT_ASSERT(P3.get_g() == gR);
+ }
+};
+
+class SmoothQuarticTest : public CppUnit::TestFixture {
+ private:
+ BivPol *q;
+ Curve *C;
+
+ public:
+ void setUp() {
+ NTL::ZZ_p::init(NTL::ZZ(1009));
+ NTL::ZZ_pX q0, q1, q2, q3;
+ // Elliptic curve
+ std::stringstream("[810 944 972 589 71]") >> q0;
+ std::stringstream("[790 206 709 905]") >> q1;
+ std::stringstream("[236 969 139]") >> q2;
+ std::stringstream("[311 861]") >> q3;
+ q = new BivPol({q0, q1, q2, q3, NTL::ZZ_pX(1)});
+ C = new Curve(q);
+ }
+
+ void tearDown() {
+ delete C;
+ delete q;
+ }
+
+ void testGroupLaw() {
+ NTL::ZZ_pX fO, gO, f1, g1, f2, g2;
+
+ // O = (502 : 832 : 1)
+ std::stringstream("[507 1]") >> fO;
+ std::stringstream("[832]") >> gO;
+ Divisor O(
+ EffectiveDivisor(*C, fO, gO),
+ EffectiveDivisor(*C));
+
+ // D1
+ std::stringstream("[374 74 387 1]") >> f1;
+ std::stringstream("[78 130 82]") >> g1;
+ EffectiveDivisor D1(*C, f1, g1);
+
+ // D2
+ std::stringstream("[752 293 10 1]") >> f2;
+ std::stringstream("[17 109 43]") >> g2;
+ EffectiveDivisor D2(*C, f2, g2);
+
+ EffectiveDivisor D3 =
+ AddReduced(3, O, D1, D2);
+
+ NTL::ZZ_pX fR, gR;
+
+ // PR
+ std::stringstream("[512 804 472 1]") >> fR;
+ std::stringstream("[405 263 475]") >> gR;
+
+ CPPUNIT_ASSERT(D3.get_f() == fR);
+ CPPUNIT_ASSERT(D3.get_g() == gR);
+ }
+};
+
+int main() {
+ CppUnit::TextUi::TestRunner runner;
+ CppUnit::TestCaller* test1 =
+ new CppUnit::TestCaller(
+ "testRiemannRoch",
+ &EllipticCurveTest::testGroupLaw);
+ CppUnit::TestCaller* test2 =
+ new CppUnit::TestCaller(
+ "testRiemannRoch",
+ &SmoothQuarticTest::testGroupLaw);
+ runner.addTest(test1);
+ runner.addTest(test2);
+ runner.run();
+ return 0;
+}