Giter VIP home page Giter VIP logo

oscar.jl's Introduction

Oscar.jl

Documentation Build Status

Welcome to the OSCAR project, a visionary new computer algebra system which combines the capabilities of four cornerstone systems: GAP, Polymake, Antic and Singular.

Installation

OSCAR requires Julia 1.6 or newer. In principle it can be installed and used like any other Julia package; doing so will take a couple of minutes:

julia> using Pkg
julia> Pkg.add("Oscar")
julia> using Oscar

However, some of OSCAR's components have additional requirements. For more detailed information, please consult the installation instructions on our website.

Contributing to OSCAR

Please read the introduction for new developers in the OSCAR manual to learn more on how to contribute to OSCAR.

Examples of usage

julia> using Oscar
  ___   ____   ____    _    ____
 / _ \ / ___| / ___|  / \  |  _ \   |  Combining ANTIC, GAP, Polymake, Singular
| | | |\___ \| |     / _ \ | |_) |  |  Type "?Oscar" for more information
| |_| | ___) | |___ / ___ \|  _ <   |  Manual: https://docs.oscar-system.org
 \___/ |____/ \____/_/   \_\_| \_\  |  Version 1.2.0-DEV
julia> k, a = quadratic_field(-5)
(Imaginary quadratic field defined by x^2 + 5, sqrt(-5))

julia> zk = maximal_order(k)
Maximal order of Imaginary quadratic field defined by x^2 + 5
with basis AbsSimpleNumFieldElem[1, sqrt(-5)]

julia> factorizations(zk(6))
2-element Vector{Fac{AbsSimpleNumFieldOrderElem}}:
 -1 * -3 * 2
 -1 * (-sqrt(-5) - 1) * (-sqrt(-5) + 1)

julia> Qx, x = polynomial_ring(QQ, [:x1,:x2])
(Multivariate polynomial ring in 2 variables over QQ, QQMPolyRingElem[x1, x2])

julia> R = grade(Qx, [1,2])[1]
Multivariate polynomial ring in 2 variables over QQ graded by
  x1 -> [1]
  x2 -> [2]

julia> f = R(x[1]^2+x[2])
x1^2 + x2

julia> degree(f)
[2]

julia> F = free_module(R, 1)
Free module of rank 1 over R

julia> s = sub(F, [f*F[1]])[1]
Submodule with 1 generator
1 -> (x1^2 + x2)*e[1]
represented as subquotient with no relations.

julia> H, mH = hom(s, quo(F, s)[1])
(hom of (s, Subquotient of
1 -> e[1]
by
1 -> (x1^2 + x2)*e[1]), Map: H -> set of all homomorphisms from s to subquotient of Submodule with 1 generator
1 -> e[1]
by Submodule with 1 generator
1 -> (x1^2 + x2)*e[1])

julia> mH(H[1])
Map with following data
Domain:
=======
Submodule with 1 generator
1 -> (x1^2 + x2)*e[1]
represented as subquotient with no relations.
Codomain:
=========
Subquotient of Submodule with 1 generator
1 -> e[1]
by Submodule with 1 generator
1 -> (x1^2 + x2)*e[1]

Of course, the cornerstones are also available directly:

julia> C = Polymake.polytope.cube(3);

julia> C.F_VECTOR
pm::Vector<pm::Integer>
8 12 6

julia> RP2 = Polymake.topaz.real_projective_plane();

julia> RP2.HOMOLOGY
pm::Array<topaz::HomologyGroup<pm::Integer> >
({} 0)
({(2 1)} 0)
({} 0)

Citing OSCAR

If you have used OSCAR in the preparation of a paper please cite it as described below:

[OSCAR]
    OSCAR -- Open Source Computer Algebra Research system, Version 1.2.0-DEV,
    The OSCAR Team, 2024. (https://www.oscar-system.org)
[OSCAR-book]
    Wolfram Decker, Christian Eder, Claus Fieker, Max Horn, Michael Joswig, eds.
    The Computer Algebra System OSCAR: Algorithms and Examples,
    Algorithms and Computation in Mathematics, Springer, 2024.

If you are using BibTeX, you can use the following BibTeX entries:

@misc{OSCAR,
  key          = {OSCAR},
  organization = {The OSCAR Team},
  title        = {OSCAR -- Open Source Computer Algebra Research system,
                  Version 1.2.0-DEV},
  year         = {2024},
  url          = {https://www.oscar-system.org},
  }

@book{OSCAR-book,
  editor = {Decker, Wolfram and Eder, Christian and Fieker, Claus and Horn, Max and Joswig, Michael},
  title = {The {C}omputer {A}lgebra {S}ystem {OSCAR}: {A}lgorithms and {E}xamples},
  year = {2024},
  publisher = {Springer},
  series = {Algorithms and {C}omputation in {M}athematics},
  volume = {32},
  edition = {1},
  url = {https://link.springer.com/book/9783031621260},
  month = {8},
  issn = {1431-1550},
}

Funding

The development of this Julia package is supported by the Deutsche Forschungsgemeinschaft DFG within the Collaborative Research Center TRR 195.

oscar.jl's People

Contributors

alexd97 avatar alexej-jordan avatar antonydellavecchia avatar apturner avatar benlorenz avatar delphinepol avatar ederc avatar fieker avatar fingolfin avatar hechtiderlachs avatar herearound avatar jankoboehm avatar johnaabbott avatar joschmitt avatar lgoettgens avatar lkastner avatar lukaskuehne avatar micjoswig avatar rfourquet avatar sequenzer avatar simonbrandhorst avatar stevellm avatar tbrysiewicz avatar thofma avatar thomasbreuer avatar tthsqe12 avatar wbhart avatar wdecker avatar yueren avatar zkgeiselmann avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

oscar.jl's Issues

Vector spaces complement.

Can a complement function be added to Vector Space functionalities? It's a function that computes the complement vector subspace in V of a given subspace W. The following code is an example of how it could be: it computes U such that U and W are orthogonal with respect to the usual scalar product.

function complement(V::AbstractAlgebra.Generic.FreeModule{T}, W::AbstractAlgebra.Generic.Submodule{T}) where T <: FieldElem
@Assert issubmodule(V,W) "The second argument is not a subspace of the first one"

e = W.map
H = zero_matrix(base_ring(V), dim(W), dim(V))
for i in 1:dim(W)
v = e(gen(W,i))
for j in 1:dim(V) H[i,j] = v[j] end
end
d, K = kernel(H)
_gens = [ sum([K[j,i]*gen(V,j) for j in 1:dim(V)]) for i in 1:d ]
return sub(V,_gens)
end

Migrate all Oscar related Julia packages to use JLLs

This brings several advantages.

  • it is the way forward from the Julia community
  • as such, we benefit from work others put into building standard libraries like GMP, readline, MPFR, etc., and others benefit from the work we invest into packaging things like Flint, normaliz, NTL, etc.
  • precompiled binaries are only downloaded once and cached as "artifacts"
  • it ensures that we only have one copy of each used library (right now, we install e.g. Singular twice, once inside Singular.jl, once inside Polymake.jl)
  • a uniform way to override these binary artifacts so that we can use e.g. a development version of Flint or Singular or GAP or ... while working on our Julia packages

The only real drawback seems to be that JLLs require Julia >= 1.3 but that's already the case for e.g. GAP.jl so not a major loss (with perhaps the exception of LoadFlint.jl, see below). Once the next Julia LTS (1.6?) is out, I hope we can just move to that and all will be well.

Here is a list of components that might benefit from this and what needs to be / what the status is:

In addition, we should carefully document somewhere (possibly separately in each of the packages listed above) how to setup those artifact overrides so that people who work on GAP/Singular/Flint/Polymake/etc. can use dev versions of those.

SLPolyRing not a ring?

julia> S = slpoly_ring(QQ, 2)
SLP Multivariate Polynomial Ring in x_1, x_2 over Rational Field

julia> St, t = PolynomialRing(S)
ERROR: MethodError: no method matching elem_type(::Type{Oscar.StraightLinePrograms.SLPolyRing{fmpq,FlintRationalField}})

actually it is a bit more complicated, but this is the summary. Key problem is that typeing of SLPoly(Ring) is different from all other rings. Thus it is not just a question of adding this one function.

Cache `symmetric_group(n)`?

Perhaps we ought to cache the output of symmetric_group(n) somehow, seeing as we call it so often. Alternatively, perhaps we can avoid creating it in more cases, resp. make its creation lazy (so we only create it if the user really requests the parent explicitly)

Oscar tests crash on Julia 1.4.2 on Ubuntu

I am getting type inference and other crashes in Julia-1.4.2 when running the Oscar tests.

julia> Pkg.test("Oscar")
    Testing Oscar
Status `/tmp/jl_DaghMs/Manifest.toml`
  [c3fe647b] AbstractAlgebra v0.9.2
  [9e28174c] BinDeps v1.0.1
  [b99e7846] BinaryProvider v0.5.10
  [631607c0] CMake v1.2.0
  [1f15a43c] CxxWrap v0.10.2
  [c863536a] GAP v0.4.1
  [3e1990a7] Hecke v0.8.3
  [682c06a0] JSON v0.21.0
  [472f376f] LoadFlint v0.1.3
  [1914dd2f] MacroTools v0.5.5
  [2edaba10] Nemo v0.17.5
  [f1435218] Oscar v0.3.0 [`~/.julia/dev/Oscar`]
  [69de0a69] Parsers v1.0.5
  [d720cf60] Polymake v0.4.2
  [ae029012] Requires v1.0.1
  [bcd08a7b] Singular v0.3.1
  [30578b45] URIParser v0.4.1
  [3eaa8342] libcxxwrap_julia_jll v0.7.1+1
  [2a0f44e3] Base64
  [ade2ca70] Dates
  [8ba89e20] Distributed
  [b77e0a4c] InteractiveUtils
  [76f85450] LibGit2
  [8f399da3] Libdl
  [37e2e46d] LinearAlgebra
  [56ddb016] Logging
  [d6f4376e] Markdown
  [a63ad114] Mmap
  [44cfe95a] Pkg
  [de0858da] Printf
  [9abbd945] Profile
  [3fa0cd96] REPL
  [9a3f8284] Random
  [ea8e919c] SHA
  [9e88b42a] Serialization
  [6462fe0b] Sockets
  [2f01184e] SparseArrays
  [10745b16] Statistics
  [8dfed614] Test
  [cf7118a7] UUIDs
  [4ec0a83e] Unicode
Test Summary:         | Pass  Total
Rings.ZZ.constructors |   14     14
Test Summary:       | Pass  Total
Rings.ZZ.properties |   41     41
Test Summary:       | Pass  Total
Rings.ZZ.arithmetic |   23     23
Test Summary:       | Pass  Total
Rings.ZZ.comparison |   50     50
Test Summary:     | Pass  Total
Rings.ZZ.divexact |   25     25
Test Summary:     | Pass  Total
Rings.ZZ.powering |   34     34
Test Summary:               | Pass  Total
Rings.ZZ.euclidean_division |   96     96
Test Summary:       | Pass  Total
Rings.ZZ.conversion |   17     17
Test Summary: | Pass  Total
Rings.ZZ.gcd  | 1205   1205
Test Summary:  | Pass  Total
Rings.ZZ.roots |   27     27
Test Summary:          | Pass  Total
Rings.ZZ.factorisation |   18     18
Test Summary:          | Pass  Total
Rings.ZZ.combinatorial |   91     91
Test Summary:               | Pass  Total
Rings.ZZ.number_theoretical |  103    103
Test Summary:         | Pass  Total
Rings.QQ.constructors |   68     68
Test Summary:       | Pass  Total
Rings.QQ.properties |   70     70
Test Summary:       | Pass  Total
Rings.QQ.arithmetic |   66     66
Test Summary:       | Pass  Total
Rings.QQ.comparison |   23     23
Test Summary:     | Pass  Total
Rings.QQ.divexact |   22     22
Test Summary:     | Pass  Total
Rings.QQ.powering |   23     23
Test Summary:        | Pass  Total
Polynomial Orderings |   18     18
Test Summary:           | Pass  Total
Polymake.factorisations |    2      2
Internal error: encountered unexpected error in runtime:
MethodError(f=typeof(Base.string)(), args=(Expr(:<:, :t, :r),), world=0x0000000000000f21)
jl_method_error_bare at /buildworker/worker/package_linux64/build/src/gf.c:1719
jl_method_error at /buildworker/worker/package_linux64/build/src/gf.c:1737
jl_lookup_generic_ at /buildworker/worker/package_linux64/build/src/gf.c:2298 [inlined]
jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2319
macro expansion at ./error.jl:223 [inlined]
limit_type_size at ./compiler/typelimits.jl:23
jfptr_limit_type_size_4439.clone_1 at /home/wbhart/julia-1.4.2/lib/julia/sys.so (unknown line)
_jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2145 [inlined]
jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2323
abstract_call_method at ./compiler/abstractinterpretation.jl:359
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1213
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1295
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1213
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1295
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1213
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1213
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1213
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1213
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1213
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_edge at ./compiler/typeinfer.jl:488
abstract_call_method at ./compiler/abstractinterpretation.jl:404
abstract_call_gf_by_type at ./compiler/abstractinterpretation.jl:101
abstract_call_known at ./compiler/abstractinterpretation.jl:873
abstract_call at ./compiler/abstractinterpretation.jl:895
abstract_call at ./compiler/abstractinterpretation.jl:880
abstract_eval at ./compiler/abstractinterpretation.jl:974
typeinf_local at ./compiler/abstractinterpretation.jl:1227
typeinf_nocycle at ./compiler/abstractinterpretation.jl:1283
typeinf at ./compiler/typeinfer.jl:12
typeinf_ext at ./compiler/typeinfer.jl:574
typeinf_ext at ./compiler/typeinfer.jl:605
jfptr_typeinf_ext_1.clone_1 at /home/wbhart/julia-1.4.2/lib/julia/sys.so (unknown line)
_jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2145 [inlined]
jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2323
jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1700 [inlined]
jl_type_infer at /buildworker/worker/package_linux64/build/src/gf.c:213
jl_compile_method_internal at /buildworker/worker/package_linux64/build/src/gf.c:1888
_jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2154 [inlined]
jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2323
jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1700 [inlined]
do_call at /buildworker/worker/package_linux64/build/src/interpreter.c:369
eval_value at /buildworker/worker/package_linux64/build/src/interpreter.c:458
eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:680
eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:744
eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:744
jl_interpret_toplevel_thunk at /buildworker/worker/package_linux64/build/src/interpreter.c:911
macro expansion at /home/wbhart/.julia/dev/Oscar/test/Polymake/nmbthy-test.jl:16 [inlined]
macro expansion at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Test/src/Test.jl:1113 [inlined]
top-level scope at /home/wbhart/.julia/dev/Oscar/test/Polymake/nmbthy-test.jl:13
jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:819
jl_parse_eval_all at /buildworker/worker/package_linux64/build/src/ast.c:872
jl_load at /buildworker/worker/package_linux64/build/src/toplevel.c:877
include at ./client.jl:439
_jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2145 [inlined]
jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2323
jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1700 [inlined]
do_call at /buildworker/worker/package_linux64/build/src/interpreter.c:369
eval_value at /buildworker/worker/package_linux64/build/src/interpreter.c:458
eval_stmt_value at /buildworker/worker/package_linux64/build/src/interpreter.c:409 [inlined]
eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:817
jl_interpret_toplevel_thunk at /buildworker/worker/package_linux64/build/src/interpreter.c:911
top-level scope at none:7
jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:819
jl_parse_eval_all at /buildworker/worker/package_linux64/build/src/ast.c:872
jl_load at /buildworker/worker/package_linux64/build/src/toplevel.c:877
include at ./client.jl:439
_jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2145 [inlined]
jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2323
jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1700 [inlined]
do_call at /buildworker/worker/package_linux64/build/src/interpreter.c:369
eval_value at /buildworker/worker/package_linux64/build/src/interpreter.c:458
eval_stmt_value at /buildworker/worker/package_linux64/build/src/interpreter.c:409 [inlined]
eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:817
jl_interpret_toplevel_thunk at /buildworker/worker/package_linux64/build/src/interpreter.c:911
top-level scope at none:6
jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:819
jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:769
jl_toplevel_eval_in at /buildworker/worker/package_linux64/build/src/toplevel.c:848
eval at ./boot.jl:331
_jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2145 [inlined]
jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2323
exec_options at ./client.jl:264
_start at ./client.jl:484
jfptr__start_2075.clone_1 at /home/wbhart/julia-1.4.2/lib/julia/sys.so (unknown line)
_jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2145 [inlined]
jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2323
jl_apply at /buildworker/worker/package_linux64/build/ui/../src/julia.h:1700 [inlined]
true_main at /buildworker/worker/package_linux64/build/ui/repl.c:96
main at /buildworker/worker/package_linux64/build/ui/repl.c:217
__libc_start_main at /lib/x86_64-linux-gnu/libc.so.6 (unknown line)
_start at /home/wbhart/julia-1.4.2/bin/julia (unknown line)
Test Summary:          | Pass  Total
Polymake.norm_equation |    1      1
Test Summary:                   | Pass  Total
GAPGroups_interface_conformance |  183    183
Iteration: Error During Test at /home/wbhart/.julia/dev/Oscar/test/Groups/testing.jl:178
  Got exception outside of a @test
  failed to convert GapObj to any known type:
   GAP: ()
  Stacktrace:
   [1] gap_to_julia(::Main.ForeignGAP.MPtr; recursive::Bool) at /home/wbhart/.julia/packages/GAP/7sFvk/src/gap_to_julia.jl:311
   [2] #gap_to_julia#9 at /home/wbhart/.julia/packages/GAP/7sFvk/src/gap_to_julia.jl:57 [inlined]
   [3] #gap_to_julia#7 at /home/wbhart/.julia/packages/GAP/7sFvk/src/gap_to_julia.jl:53 [inlined]
   [4] #13 at /home/wbhart/.julia/packages/GAP/7sFvk/src/gap_to_julia.jl:163 [inlined]
   [5] get!(::GAP.var"#13#14"{Any,IdDict{Any,Any},Main.ForeignGAP.MPtr}, ::IdDict{Any,Any}, ::Any) at ./abstractdict.jl:663
   [6] gap_to_julia(::Type{Array{Any,1}}, ::Main.ForeignGAP.MPtr, ::IdDict{Any,Any}; recursive::Bool) at /home/wbhart/.julia/packages/GAP/7sFvk/src/gap_to_julia.jl:162
   [7] gap_to_julia(::Main.ForeignGAP.MPtr; recursive::Bool) at /home/wbhart/.julia/packages/GAP/7sFvk/src/gap_to_julia.jl:309
   [8] gap_to_julia(::Main.ForeignGAP.MPtr) at /home/wbhart/.julia/packages/GAP/7sFvk/src/gap_to_julia.jl:299
   [9] elements(::PermGroup) at /home/wbhart/.julia/dev/Oscar/src/Groups/GAPGroups.jl:67
   [10] macro expansion at /home/wbhart/.julia/dev/Oscar/test/Groups/testing.jl:181 [inlined]
   [11] macro expansion at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Test/src/Test.jl:1113 [inlined]
   [12] top-level scope at /home/wbhart/.julia/dev/Oscar/test/Groups/testing.jl:179
   [13] include(::String) at ./client.jl:439
   [14] top-level scope at /home/wbhart/.julia/dev/Oscar/test/Groups/runtests.jl:4
   [15] include(::String) at ./client.jl:439
   [16] top-level scope at none:8
   [17] include(::String) at ./client.jl:439
   [18] top-level scope at none:6
   [19] eval(::Module, ::Any) at ./boot.jl:331
   [20] exec_options(::Base.JLOptions) at ./client.jl:264
   [21] _start() at ./client.jl:484

Test Summary: | Error  Total
Iteration     |     1      1
ERROR: LoadError: LoadError: LoadError: Some tests did not pass: 0 passed, 0 failed, 1 errored, 0 broken.
in expression starting at /home/wbhart/.julia/dev/Oscar/test/Groups/testing.jl:178
in expression starting at /home/wbhart/.julia/dev/Oscar/test/Groups/runtests.jl:4
in expression starting at /home/wbhart/.julia/dev/Oscar/test/runtests.jl:8
ERROR: Package Oscar errored during testing
Stacktrace:
 [1] pkgerror(::String, ::Vararg{String,N} where N) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/Types.jl:53
 [2] test(::Pkg.Types.Context, ::Array{Pkg.Types.PackageSpec,1}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/Operations.jl:1510
 [3] test(::Pkg.Types.Context, ::Array{Pkg.Types.PackageSpec,1}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, kwargs::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/API.jl:316
 [4] test(::Pkg.Types.Context, ::Array{Pkg.Types.PackageSpec,1}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/API.jl:303
 [5] #test#68 at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/API.jl:297 [inlined]
 [6] test at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/API.jl:297 [inlined]
 [7] #test#67 at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/API.jl:296 [inlined]
 [8] test at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/API.jl:296 [inlined]
 [9] test(::String; kwargs::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/API.jl:295
 [10] test(::String) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.4/Pkg/src/API.jl:295
 [11] top-level scope at REPL[8]:1

Fraction with decorated polynomials

When trying to define a fraction with decorated polynomials, it throws an error:

julia> S, (x,y,z) = PolynomialRing(QQ, ["x", "y", "z"])
(Multivariate Polynomial Ring in x, y, z over Rational Field, fmpq_mpoly[x, y, z])

julia> T = grade(S)
Multivariate Polynomial Ring in x, y, z over Rational Field filtrated by
        x -> [1]
        y -> [1]
        z -> [1]


julia> T(x)//T(y)
Error showing value of type AbstractAlgebra.Generic.Frac{Oscar.MPolyElem_dec{fmpq}}:
ERROR: MethodError: no method matching (::FlintRationalField)(::Oscar.MPolyElem_dec{fmpq})
Closest candidates are:
  Any(::fmpq) at /home/pol/.julia/packages/Nemo/kSPAO/src/flint/fmpq.jl:906
  Any(::Int64, ::Int64) at /home/pol/.julia/packages/Nemo/kSPAO/src/flint/fmpq.jl:894
  Any(::nf_elem) at /home/pol/.julia/packages/Hecke/lQaPT/src/NumField/NfAbs/NfAbs.jl:1258
  ...
Stacktrace:
 [1] divexact(::Oscar.MPolyElem_dec{fmpq}, ::fmpq) at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/Rings.jl:88
 [2] numerator(::AbstractAlgebra.Generic.Frac{Oscar.MPolyElem_dec{fmpq}}, ::Bool) at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/generic/Fraction.jl:101
 [3] numerator at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/AbstractAlgebra.jl:79 [inlined]
 [4] expressify(::AbstractAlgebra.Generic.Frac{Oscar.MPolyElem_dec{fmpq}}; context::IOContext{REPL.Terminals.TTYTerminal}) at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/generic/Fraction.jl:185
 [5] #obj_to_string#46 at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/PrettyPrinting.jl:34 [inlined]
 [6] show(::IOContext{REPL.Terminals.TTYTerminal}, ::MIME{Symbol("text/plain")}, ::AbstractAlgebra.Generic.Frac{Oscar.MPolyElem_dec{fmpq}}) at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/generic/Fraction.jl:195
 [7] display(::REPL.REPLDisplay, ::MIME{Symbol("text/plain")}, ::Any) at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:214
 [8] display(::REPL.REPLDisplay, ::Any) at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:218
 [9] display(::Any) at ./multimedia.jl:328
 [10] #invokelatest#1 at ./essentials.jl:710 [inlined]
 [11] invokelatest at ./essentials.jl:709 [inlined]
 [12] print_response(::IO, ::Any, ::Bool, ::Bool, ::Any) at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:238
 [13] print_response(::REPL.AbstractREPL, ::Any, ::Bool, ::Bool) at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:223
 [14] (::REPL.var"#do_respond#54"{Bool,Bool,REPL.var"#64#73"{REPL.LineEditREPL,REPL.REPLHistoryProvider},REPL.LineEditREPL,REPL.LineEdit.Prompt})(::Any, ::Any, ::Any) at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:822
 [15] #invokelatest#1 at ./essentials.jl:710 [inlined]
 [16] invokelatest at ./essentials.jl:709 [inlined]
 [17] run_interface(::REPL.Terminals.TextTerminal, ::REPL.LineEdit.ModalInterface, ::REPL.LineEdit.MIState) at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/LineEdit.jl:2355
 [18] run_frontend(::REPL.LineEditREPL, ::REPL.REPLBackendRef) at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:1144
 [19] (::REPL.var"#38#42"{REPL.LineEditREPL,REPL.REPLBackendRef})() at ./task.jl:356

Loading `Oscar` is very slow

So of course @fieker is long aware of this and even is working on a solution in the form of a a custom sysimg for Oscar; but I thought I should record this explicitly:

Right now, on a "big" machine in Siegen, I get this:

julia> @time using Oscar
 -----    -----    -----      -      -----
|     |  |     |  |     |    | |    |     |
|     |  |        |         |   |   |     |
|     |   -----   |        |     |  |-----
|     |        |  |        |-----|  |   |
|     |  |     |  |     |  |     |  |    |
 -----    -----    -----   -     -  -     -

...combining (and extending) GAP, Hecke, Nemo, Polymake and Singular
Version 0.3.0 ...
 ... which comes with absolutely no warranty whatsoever
Type: '?Oscar' for more information
(c) 2019-2020 by The Oscar Development Team
 34.237648 seconds (63.28 M allocations: 3.259 GiB, 4.12% gc time)

Oops. My .julia contains 4.4 GB data (this is essentially a fresh Oscar install, nothing else), which is why I couldn't test this in Kaiserslautern yet (my quota is only 2 GB there; I asked @hannes14 to increase it; he also told me about scratch space I could use instead for now, but I don't expect fundamentally different results anyway).

I found it interesting to break down these numbers a bit, to see which component contributes what. So I added all components of Oscar to my environment, and then did a @time using FOO for all, each time in a fresh session (of course the numbers fluctuate a bit, but the order of magnitude is right)

  • AbstractAlgebra: 0.4 seconds
  • CxxWrap: 10.2 seconds
  • GAP: 1.8 seconds
  • Hecke: 2.4 seconds
  • Nemo: 1.0 seconds
  • Polymake 21.2 seconds (reduced to 12 seconds if CxxWrap is loaded first)
  • Singular: 15.3 seconds (reduced to 5.6 seconds if CxxWrap is loaded first)

So it seems to me as if CxxWrap and code using it contributes substantially to the performance issue. Or perhaps this is a red herring, and the problem is caused by those three packages (CxxWrap, Polymake, Singular) just instantiating a lot of code during load time, cause a lot of work to Julia... Whatever, it might be worthwhile investigating this closer with a profiler.

But no matter what, we really need to look into this "compile Oscar" approach.

SLPoly (in Oscar) does not print

julia> S = slpoly_ring(QQ, 2)
SLP Multivariate Polynomial Ring in x_1, x_2 over Rational Field

julia> gens(S)
2-element Array{Oscar.StraightLinePrograms.SLPoly{fmpq,Oscar.StraightLinePrograms.SLPolyRing{fmpq,FlintRationalField}},1}:
Error showing value of type Array{Oscar.StraightLinePrograms.SLPoly{fmpq,Oscar.StraightLinePrograms.SLPolyRing{fmpq,FlintRationalField}},1}:
ERROR: MethodError: no method matching length(::Oscar.StraightLinePrograms.SLPoly{fmpq,Oscar.StraightLinePrograms.SLPolyRing{fmpq,FlintRationalField}})

why the Oscar.show is chosen over the SLP one, I don't know

matrix groups not necessarily over finite fields

Currently MatrixGroup claims to cover only subgroups of the groups GL(n,q), that is, matrix groups over finite fields.
This means that we cannot create for example a matrix group over the Integers, the Rationals, or a number field.

Are there already ideas to implement other matrix groups than subgroups of GL(n,q)?

We can write down matrices on the Julia side, with type fmpq_mat or AbstractAlgebra.Generic.MatSpaceElem{nf_elem}.
It would be useful to use these matrices for the action on relevant Julia objects, and to wrap them into GAP objects in case that there are interesting GAP functions which one wants to use.
(Converting the Julia matrices to the GAP side and then wrapping these GAP objects into group element objects in Julia --as is done for the FFE matrices-- would result in converting these GAP matrices back to julia whenever one wants to use that they are matrices, for example, for multiplying them with vectors.)

Questions and concerns regarding type GroupCoset

Right now, there is a single type GroupCoset which is used to both represent right cosets (the "native" GAP way) and left cosets. I have some concerns and questions about that:

  1. given a GroupCoset there seems to be no good way to find out whether it is left or right; best I can do is directly access its side field, it seems better to have test methods like isleftcoset / isrightcoset

  2. however, perhaps it would be better to have two types for that, LeftGroupCoset and RightGroupCoset (or just LeftCoset / RightCoset but then I am not sure if people want cosets in e.g. modules, leading to a potential conflict?). As a variant, the "side" could be part of the parametric type

  3. Why is GroupCoset mutable?

  4. Once we can distinguish left/right cosets, it would be nice to be able to multiply

    1. a right coset Hx by an element y to get Hxy
    2. y * xH = yxH
    3. Hx * yK = HxyK
  5. Some internal documentation should be added, which explains what we do to "fake" left cosets, even though GAP only support right cosets

unify random generation across Oscar

Having one RNG usable in all subsystems of Oscar would be useful.

Cf. discussion started at #84 (comment).
To quote the (current) last comment of it, from @fieker:

Bottom line: for now, we cannot do anything (no manpower). Long-term, it
needs to be sorted, as, at least for debugging and development,
reproducibility is important, thus using >>1 independent sources of
random that are totally wild is difficult to support long term

I suggest to have the discussion continue here.

Meta: hook up CI into Slack for more of our projects?

Right now, the results of the Travis CI tests for GAP.jl are reported in a special channel on the oscar-system Slack. I find this quite useful because it allows me to quickly see if the build starts failing there for some reason. In addition, the tests there are run periodically every 24 hours, so I also quickly see when Julia nightly starts to cause issues.

Perhaps we can do the same for more of our subprojects, at least those using Travis. It's not that hard to set up, see

Ideally something similar would be done for GitHub actions as used by e.g. Polymake.jl. There are several tools on the GitHub market place which claim to allow this, e.g. these (found by a quick google search, there might be others and better ones):

Add facilities to streamline GAP wrappers for GAP properties/attributes; reduce overhead

We have a lot of GAP wrapper functions that looks like this:

isperfect(G::GAPGroup)::Bool = GAP.Globals.IsPerfectGroup(G.X)

or this:

function complement_system(G::GAPGroup)
   if !issolvable(G) throw(ArgumentError("The group is not solvable")) end
   return _as_subgroups(G, GAP.Globals.ComplementSystem(G.X))
end

They all follow roughly this pattern:

  1. test some preconditions
  2. call a GAP function via GAP.Globals.FOOBAR
  3. possibly convert or wrap the output

But both GAP functions called above are GAP attributes (the first one is a special case, a GAP property, which is an attribute that can only take on the values true or false). For GAP attributes, one really also should expose their corresponding testers (HasIsPerfectGroup -> hasisperfect or knowsisperfect or so; and HasComplementSystem -> hascomplement_system or has_complement_system or whatever), and possibly also setters (SetIsPerfect(group, bool) can be useful when building new group objects about which extra information is known, as is SetComplementSystem)). Right now, that means one should actually add three functions for each (and of course keep consistent naming in mind); e.g.

isperfect(G::GAPGroup)::Bool = GAP.Globals.IsPerfectGroup(G.X)
hasisperfect(G::GAPGroup)::Bool = GAP.Globals.HasIsPerfectGroup(G.X)
setisperfect(G::GAPGroup, val::Bool) = GAP.Globals.SetIsPerfectGroup(G.X, val)

Moreover, in GAP one can actually query any attribute for its tester or setter: Tester(IsPerfectGroup) returns HasIsPerfectGroup. We could offer a similar feature, e.g. tester(isperfect) would return hasisperfect.

And then there is another thing: using GAP.Globals.FOOBAR currently has quite some overhead (see oscar-system/GAP.jl#485 for some more information). While I hope to reduce this overhead in general, it will never be zero. We could mitigate this by fetching this value once and storing it in a Julia const var, like so:

const _cached_GAP_IsPerfectGroup = GAP.Globals.IsPerfectGroup
isperfect(G::GAPGroup)::Bool = _cached_GAP_IsPerfectGroup(G.X)

(This has one drawback: in GAP one can change almost everything; a user could with some effort replace IsPerfectGroup by something else, and then our "cache" wouldn't refer to that. However, this is a very nasty hack and I'd be happy to explicitly not support it; no GAP code or package I know does such a thing (well, some do something similar to a few functions, but nothing I am aware of does it to properties or attributes like that).

Anyway:

Implementing all this in a consistent way is somewhat tedious. Also, if decide to change some naming conventions, or add/remove/improve the caching method I sketched, we'd have to do it lots of places. So I think it would make sense to introduce some facilities that help doing this, and in a consistent way. This could e.g. be a macro (or a set of macros) which in their simples form, might take the name of a GAP function, the desired Julia name and information about the arguments and their types. Something like this pseudo code

@gap_wrapper isperfect IsPerfectGroup (G::GAPGroup, )

which could then emit code for the getter, tester and setter. A more powerful version of the macro could also let you specify a pre- and post-condition.

Another idea which is perhaps a bit more advanced but also more difficult to implement, would be to write a macro which takes a whole function as argument, which contains exactly one instances of GAP.Globals.FOOBAR; then the macro could extract everything it needs from that. I.e. you'd write

@gapwrap function complement_system(G::GAPGroup)
   if !issolvable(G) throw(ArgumentError("The group is not solvable")) end
   return _as_subgroups(G, GAP.Globals.ComplementSystem(G.X))
end

which might get turned into something like this by the macro:

const _cached_GAP_ComplementSystem = GAP.Globals.ComplementSystem
const _cached_GAP_HasComplementSystem = GAP.Globals.HasComplementSystem
const _cached_GAP_SetComplementSystem = GAP.Globals.SetComplementSystem
function complement_system(G::GAPGroup)
   if !issolvable(G) throw(ArgumentError("The group is not solvable")) end
   return _as_subgroups(G, _cached_GAP_ComplementSystem(G.X))
end
hascomplement_system(G::GAPGroup)::Bool = _cached_GAP_HasComplementSystem(G.X)
setcomplement_system(G::GAPGroup, val::GapObj) = _cached_GAP_SetComplementSystem(G.X, val)

That setter is of course not great (except for properties, I guess); but my idea would that one then could easily add a custom "better" setter in terms of that, by just adding this after the @gapwrap function ... end bit:

function setcomplement_system(G::T, val::Vector{T}) where T <: GAPGroup
  # option: verify here that all elements of val have G as parent, resp. are subgroups
  gaplist = ... turn val into a GAP list of subgroups ...
  setcomplement_system(G, gaplist)
end

release 0.1.1

Currently there is no way of installing Oscar other than from master. It is not registered (probably due to failing tests), hence the description in README needs to be changed.

I tried:

Pkg.add(PackageSpec(url="https://github.com/oscar-system/Oscar.jl.git", rev="v0.1.0"))

  Updating git-repo `https://github.com/oscar-system/Oscar.jl.git`
ERROR: Compat `Julia` not listed in `deps` or `extras` section.

Since this is only fixed in master you need to get it via:

Pkg.add(PackageSpec(url="https://github.com/oscar-system/Oscar.jl.git"))

Note: now Pkg.update() will git pull Oscar each time!. this is not what we want our users to experience, hence the need for v0.1.1. Before v0.1.1 the following need to be resolved though.


upon using Oscar You get (among the barrage of banners ;)

WARNING: could not import Hecke.change_uniformizer into Oscar
WARNING: could not import Hecke.genus_symbol into Oscar
WARNING: could not import Hecke.isdefintie into Oscar
WARNING: could not import Hecke.narrow_class_group into Oscar

Probably Hecke doesn't export those anymore


It is not possible to test Oscar locally as it's missing Test in its deps:

(tmp) pkg> test Oscar
   Testing Oscar
    Status `/tmp/jl_sQLuE4/Manifest.toml`
  [c3fe647b] AbstractAlgebra v0.8.0
  [9e28174c] BinDeps v1.0.0
  [b99e7846] BinaryProvider v0.5.8
  [631607c0] CMake v1.1.2
  [1f15a43c] CxxWrap v0.8.2
  [3e1990a7] Hecke v0.7.1
  [682c06a0] JSON v0.20.0
  [2edaba10] Nemo v0.16.1
  [f1435218] Oscar v0.1.0 #master (https://github.com/oscar-system/Oscar.jl.git)
  [d720cf60] Polymake v0.2.2
  [ae029012] Requires v0.5.2
  [30578b45] URIParser v0.4.0
  [2a0f44e3] Base64  [`@stdlib/Base64`]
  [ade2ca70] Dates  [`@stdlib/Dates`]
  [8ba89e20] Distributed  [`@stdlib/Distributed`]
  [b77e0a4c] InteractiveUtils  [`@stdlib/InteractiveUtils`]
  [76f85450] LibGit2  [`@stdlib/LibGit2`]
  [8f399da3] Libdl  [`@stdlib/Libdl`]
  [37e2e46d] LinearAlgebra  [`@stdlib/LinearAlgebra`]
  [56ddb016] Logging  [`@stdlib/Logging`]
  [d6f4376e] Markdown  [`@stdlib/Markdown`]
  [a63ad114] Mmap  [`@stdlib/Mmap`]
  [44cfe95a] Pkg  [`@stdlib/Pkg`]
  [de0858da] Printf  [`@stdlib/Printf`]
  [9abbd945] Profile  [`@stdlib/Profile`]
  [3fa0cd96] REPL  [`@stdlib/REPL`]
  [9a3f8284] Random  [`@stdlib/Random`]
  [ea8e919c] SHA  [`@stdlib/SHA`]
  [9e88b42a] Serialization  [`@stdlib/Serialization`]
  [6462fe0b] Sockets  [`@stdlib/Sockets`]
  [2f01184e] SparseArrays  [`@stdlib/SparseArrays`]
  [8dfed614] Test  [`@stdlib/Test`]
  [cf7118a7] UUIDs  [`@stdlib/UUIDs`]
  [4ec0a83e] Unicode  [`@stdlib/Unicode`]

Welcome to Nemo version 0.16.1

Nemo comes with absolutely no warranty whatsoever


Welcome to 

    _    _           _
   | |  | |         | |
   | |__| | ___  ___| | _____
   |  __  |/ _ \/ __| |/ / _ \
   | |  | |  __/ (__|   <  __/
   |_|  |_|\___|\___|_|\_\___|
    
Version 0.7.1 ... 
 ... which comes with absolutely no warranty whatsoever
(c) 2015-2019 by Claus Fieker, Tommy Hofmann and Carlo Sircana

ERROR: LoadError: ArgumentError: Package Test not found in current path:
- Run `import Pkg; Pkg.add("Test")` to install the Test package.

Stacktrace:
 [1] require(::Module, ::Symbol) at ./loading.jl:887
 [2] include at ./boot.jl:328 [inlined]
 [3] include_relative(::Module, ::String) at ./loading.jl:1105
 [4] include(::Module, ::String) at ./Base.jl:31
 [5] include(::String) at ./client.jl:424
 [6] top-level scope at none:6
in expression starting at /home/kalmar/.julia/packages/Oscar/LcnCP/test/runtests.jl:2
ERROR: Package Oscar errored during testing

Missing Functions

Consider f in R = QQ(x)[y], then

  • factor(f) does not work
  • quo(R, f) does not work, ResidueRing does
  • for elems in the quotient, charpoly, minpoly does not work (via rep-mat?)

Just to note this down somewhere, possibly to be done in AA, or partially in Nemo

Detect whether build dependencies are present, error out with helpful message if not

[ This issue should potentially be replicated to Singular.jl, Polymake.jl, GAP.jl etc.; but perhaps we can also first implement a solution and then copy&paste code, or something like that? ]

Right now, several of our packages require a new enough C/C++ compiler (must support C++17, it seems...), a new enough cmake (must support C++17, too... etc.). Problem is that nothing tests for these things explicitly, and so builds can fail with more or (usually) less helpful error messages. In fact, the original cause of issues (e.g. "cmake is too old") may be lost because several packages of errors caused by this are printed.

The root issue here seems to be that if Pkg.jl is asked to install a package "A" which depends on another package "B", and package "B" has a build.jl, and that build.jl fails with an error, then Pkg.jl still happily proceeds to install "A"; and that then may have its own build.jl, which now also fails with an error, because it relies on the output of the build.jl from package "A"... now the user sees the errors from A which are gibberish, an the real error in B is only visible after scrolling up a lot.

This is IMHO a sever deficiency in Pkg.jl, and we should report it there, but in the meantime, we need to deal with this, as people interested in Oscar may very easily get bitten by this and give up in frustration.

I propose that we add code to each of our packages which checks, among other things...

  1. if cmake is used, then...
  • whether cmake is available
  • whether cmake is "new enough" (what that means exactly remains to be determined)
  1. if C/C++ is used
  • whether the C/C++ compiler is "new enough"
  1. if there is a build.jl, that should "mark" the package to indicate whether it was built successfully or not. E.g.: at the end of a successful build, create an empty file BUILD_COMPLETE (and at the start of a build, delete that file if present, so that if a package was built successfully, then a rebuild is started but unsuccessful, the file is not present)
  2. most importantly, each of our package should check whether all of "our" other packages were built successfully, and if not, print a suitable big WARNING message -- big, with an ASCII art box around it, in red and blinking, whatever it takes to make it stand out. And that message should be helpful like, "ERROR: Foo.jl depends on Singular.jl which was not built successfully" or "ERROR: Singular.jl failed to built successfully because your cmake is too old (is version X.Y, need version >= A.B). Please go to URL for information"

I guess the Julia perspective is that nobody should have a build.jl other than one that installs binary builders. But that is unrealistic, and even for those you can run into trouble (e.g. if a download failed).

Error in factoring polynomials over QQ

I wanted to factor the following polynomial:

julia> S, (x,y,z) = PolynomialRing(QQ, ["x", "y", "z"])

julia> f = (x*y^4+y*z^4+x*z^4)*(x^2*y^3+x^2*z^3+y^2*z^3)

and obtained this error:

julia> factor(f)
ERROR: Element not invertible
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] inv(::fmpq) at /home/epure/.julia/packages/Nemo/oOtel/src/flint/fmpq.jl:464
 [3] make_monic(::fmpq_poly) at /home/epure/.julia/packages/Hecke/SNive/src/Misc/MPolyFactor.jl:158
 [4] lcc_kaltofen_step!(::Array{fmpq_mpoly,1}, ::Fac{fmpq_mpoly}, ::Array{fmpq_mpoly,1}, ::Int64, ::Array{Int64,1}, ::Array{fmpq,1}) at /home/epure/.julia/packages/Hecke/SNive/src/Misc/MPolyFactor.jl:997
 [5] lcc_kaltofen(::Fac{fmpq_mpoly}, ::fmpq_mpoly, ::Int64, ::Int64, ::Array{Int64,1}, ::Array{fmpq,1}, ::Array{fmpq_mpoly,1}) at /home/epure/.julia/packages/Hecke/SNive/src/Misc/MPolyFactor.jl:1089
 [6] mfactor_irred_mvar_char_zero(::fmpq_mpoly, ::Int64, ::Array{Int64,1}) at /home/epure/.julia/packages/Hecke/SNive/src/Misc/MPolyFactor.jl:1144
 [7] mfactor_irred_char_zero(::fmpq_mpoly) at /home/epure/.julia/packages/Hecke/SNive/src/Misc/MPolyFactor.jl:1250
 [8] mfactor_char_zero(::fmpq_mpoly) at /home/epure/.julia/packages/Hecke/SNive/src/Misc/MPolyFactor.jl:1317
 [9] factor(::fmpq_mpoly) at /home/epure/.julia/packages/Hecke/SNive/src/Misc/MPolyFactor.jl:1326
 [10] top-level scope at REPL[9]:1
´´´

Ideals in Z

For teaching (and simple test), ideals in Z would be nice to have. I guess something like ideal(ring, gens) would be the default patterns, so ideal(ZZ, [ ZZ(7) ]); and perhaps as a special case, also allow producing principal ideals via ideal(ring, gen) (so ideal(ZZ, ZZ(7))) or even gen*ring (so 7*ZZ) ?

And then have some basic features: intersection, sums, containment test, subset test, computing ZZ/I, ... but I guess also properties of the ideals (maximal / prime / ...). All of this is of course "easy", and for my own code, I don't need this, as I can just invoke gcd etc. directly. But as I said: it's very useful for teaching; but also to set an easy example for people who need to implement new, more complicated rings. (Of course if it'd be easy to piggy back all of this into e.g. existing Hecke or Nemo code, that'd be also fine, I absolutely do not insist on a separate implementation just for ZZ ideals).

I am not sure what the "ideal" (haha) place for this would be; personally I'd just start it in experiments here in Oscar, and we can move it to another place later shrug.

is_dev tests are not run in CI

Probably should carefully check the code which computes is_dev. While at it, I think we can simplify the part which determines the version of Oscar and make it work the same in old and new Julia versions (not sure if we can do the same for the git_revision, though, but IMHO it's sensible for us to change the version in Project.toml to 0.5.0-dev anyway).

I'll try to dig out the code for this (I used it for a time in GAP.jl for the JLL stuff, but ultimately didn't need it and so removed it again). But I am juggling too many things in my small brain right now and don't want to forget about this, hence filing this as an issue for now.

Nemo bug?

The last line of the following causes an error, I think this must be a bug::

using Nemo
R, (a, b) = PolynomialRing(ZZ, ["a", "b"])
T, x = PolynomialRing(R, "x")
divexact(x, one(T))
U, (y,) = PolynomialRing(R, ["y"])
divexact(y, one(U))

I believe I used the latest version of Nemo (installed with ]dev Nemo).

Anders

Groups: G-sets

In order to properly support thing like stabilizer, orbit, orbit_stabilizer, all_blocks, maximal_blocks, isregular, istransitive etc. for arbitrary group actions (see also Chapter 41 "Group Actions in the GAP reference manual). To this end, I suggest introduce an abstraction somewhat similar to Magma's G-sets resp. GAP's external sets.

Unlike Magma GSet, I do not think we should restrict this to permutation groups either.

Also, I explicitly do not want use GAP's ExternalSet to implement this, as it has too much overhead (and perhaps also other baggage). Rather, I'd implement this as a Julia type with ideally little overhead in the general situation.

That is, a type GSet which represents a set together with an action by a group G, and multiple constructors for it. The functions listed above can then be applied to such G-sets. The code could be in src/Groups/GSets.jl.

I'd imagine that we'd use (subtypes of) GSet to represent all kinds of things, potentially including conjugacy classes, cosets (xH is the orbit of x under H), and more...

I need to fill in more details later but I keep not getting to this, so I'd rather file this as an incomplete issue than forget it.

Ping @GDeFranceschi

Documentation for updating the cornerstones

I would like to document the process for updating Singular.jl, but I do not know where to put such a thing. The process is at the end of the message, and I hope @thofma can fix any mistakes. This took five days to get one line of code into the official Singular.jl, so I hope there is another method that developers can use in real time.


Instructions for updating Singular.jl

Here is a record of how we solved
oscar-system/Singular.jl#261
by getting the commit
Singular/Singular@48c4ba6
into Singular.jl.

Singular.jl depends on two binary artifacts:
Singular_jll for the actual binaries of Singular, and
libsingular_julia_jll for the cxx-wrapped portion.

First, the pull request
JuliaPackaging/Yggdrasil#1622
bumps the SHA to an appropriate version of the Singular sources
and the version 4.1.3p4 in the comment is actually 4.1.3+3 (the 4 is off by one).
After the changes are merged, the repo
https://github.com/JuliaBinaryWrappers/Singular_jll.jl
is automagically updated and Singular_jll version 4.1.3+3 is usable from julia.

Next, since the bug fix in Singular is in a header file which also happens
to be included by the cxx wrappers, libsingular_julia_jll needs to be updated
as well. This involves making a new release of the repo
https://github.com/oscar-system/libsingular-julia
Since this is now version 0.2.0, the version and the SHA needs to be updated by
JuliaPackaging/Yggdrasil#1643
After this is merged, the repo
https://github.com/JuliaBinaryWrappers/libsingular_julia_jll.jl
is automagically updated and libsingular_julia_jll version 0.2.0 is usable.

Finally, an updated Singular.jl is make by bumping the versions in
oscar-system/Singular.jl@56ebe7b
It is important to ping the JuliaRegistrator so that version 0.4.1 is usable.


new for libsingular_julia process as of a few months ago:
update libsingular_julia/common.jl and version 1.3
JuliaPackaging/Yggdrasil#2535
once this is merged in the registry (i.e. JuliaRegistries/General#29881), a dummy commit for version 1.4
JuliaPackaging/Yggdrasil#2536
once this is merged in the registry, another dummy commit for version 1.5
JuliaPackaging/Yggdrasil#2537

Oscar fails to precompile on Ubuntu

I had a previous unsuccessful build of Oscar due to g++ being missing on my machine. So I removed Oscar (Pkg.rm) then the following happened:

(v1.3) pkg> add Oscar
 Resolving package versions...
  Updating `~/.julia/environments/v1.3/Project.toml`
  [f1435218] + Oscar v0.2.0
  Updating `~/.julia/environments/v1.3/Manifest.toml`
  [9e28174c] + BinDeps v1.0.1
  [631607c0] + CMake v1.2.0
  [1f15a43c] + CxxWrap v0.9.1
  [3e1990a7] + Hecke v0.8.4
  [682c06a0] + JSON v0.21.0
  [1914dd2f] + MacroTools v0.5.5
  [f1435218] + Oscar v0.2.0
  [69de0a69] + Parsers v1.0.7
  [d720cf60] + Polymake v0.3.0
  [ae029012] + Requires v1.0.1
  [bcd08a7b] + Singular v0.2.2
  [30578b45] + URIParser v0.4.1
  [a63ad114] + Mmap
  [9abbd945] + Profile
  [10745b16] + Statistics

(v1.3) pkg> build Oscar
  Building CxxWrap ──→ `~/.julia/packages/CxxWrap/hEmjg/deps/build.log`
  Building CMake ────→ `~/.julia/packages/CMake/ULbyn/deps/build.log`
  Building Polymake ─→ `~/.julia/packages/Polymake/MuMBQ/deps/build.log`
  Building LoadFlint → `~/.julia/packages/LoadFlint/jHlQx/deps/build.log`
  Building Nemo ─────→ `~/.julia/dev/Nemo/deps/build.log`
 Resolving package versions...
  Building Singular ─→ `~/.julia/packages/Singular/GsN0h/deps/build.log`
 Resolving package versions...

julia> using Oscar
[ Info: Precompiling Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13]
ERROR: LoadError: could not load library "/home/wbhart/.julia/packages/Polymake/MuMBQ/src/../deps/src/libpolymake.so"
/home/wbhart/julia-1.3.1/bin/../lib/julia/libstdc++.so.6: version `GLIBCXX_3.4.26' not found (required by /home/wbhart/.julia/packages/Polymake/MuMBQ/src/../deps/src/libpolymake.so)
Stacktrace:
 [1] #dlopen#3(::Bool, ::typeof(Libdl.dlopen), ::String, ::UInt32) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.3/Libdl/src/Libdl.jl:109
 [2] dlopen at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.3/Libdl/src/Libdl.jl:109 [inlined]
 [3] readmodule(::String, ::Symbol, ::Module, ::Nothing) at /home/wbhart/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:669
 [4] wrapmodule(::String, ::Symbol, ::Module, ::Nothing) at /home/wbhart/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:676
 [5] top-level scope at /home/wbhart/.julia/packages/Polymake/MuMBQ/src/Polymake.jl:37
 [6] include at ./boot.jl:328 [inlined]
 [7] include_relative(::Module, ::String) at ./loading.jl:1105
 [8] include(::Module, ::String) at ./Base.jl:31
 [9] top-level scope at none:2
 [10] eval at ./boot.jl:330 [inlined]
 [11] eval(::Expr) at ./client.jl:425
 [12] top-level scope at ./none:3
in expression starting at /home/wbhart/.julia/packages/Polymake/MuMBQ/src/Polymake.jl:37
ERROR: LoadError: Failed to precompile Polymake [d720cf60-89b5-51f5-aff5-213f193123e7] to /home/wbhart/.julia/compiled/v1.3/Polymake/QizyK_e1zOn.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1283
 [3] _require(::Base.PkgId) at ./loading.jl:1024
 [4] require(::Base.PkgId) at ./loading.jl:922
 [5] require(::Module, ::Symbol) at ./loading.jl:917
 [6] include at ./boot.jl:328 [inlined]
 [7] include_relative(::Module, ::String) at ./loading.jl:1105
 [8] include(::Module, ::String) at ./Base.jl:31
 [9] top-level scope at none:2
 [10] eval at ./boot.jl:330 [inlined]
 [11] eval(::Expr) at ./client.jl:425
 [12] top-level scope at ./none:3
in expression starting at /home/wbhart/.julia/packages/Oscar/kRdEf/src/Oscar.jl:33
ERROR: Failed to precompile Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13] to /home/wbhart/.julia/compiled/v1.3/Oscar/aJ3Pg_e1zOn.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1283
 [3] _require(::Base.PkgId) at ./loading.jl:1024
 [4] require(::Base.PkgId) at ./loading.jl:922
 [5] require(::Module, ::Symbol) at ./loading.jl:917

GCC is version 9.3.0
Ubuntu is 20.04 LTS (the standard on Windows Subsystem for Linux)
CMake is 3.16.3
Julia is 1.3.1

installing Oscar is broken

$ JULIA_DEPOT_PATH=/tmp/oscar julia --project=/tmp/oscar
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.5.1 (2020-08-25)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

(oscar) pkg> add Oscar
 Installing known registries into `/tmp/oscar`
######################################################################## 100.0%
      Added registry `General` to `/tmp/oscar/registries/General`
  Resolving package versions...
  Installed FLINT_jll ──────────── v0.0.2+0
  Installed MPFR_jll ───────────── v4.0.2+2
  Installed URIParser ──────────── v0.4.1
  Installed GMP_jll ────────────── v6.1.2+5
  Installed lib4ti2_jll ────────── v1.6.9+1
  Installed Oscar ──────────────── v0.4.0
  Installed Arb_jll ────────────── v2.17.0+1
  Installed Nemo ───────────────── v0.17.6
  Installed CxxWrap ────────────── v0.11.0
  Installed LoadFlint ──────────── v0.2.1
  Installed BinaryProvider ─────── v0.5.10
  Installed Parsers ────────────── v1.0.10
  Installed MacroTools ─────────── v0.5.5
  Installed GLPK_jll ───────────── v4.65.0+0
  Installed Requires ───────────── v1.0.2
  Installed CMake ──────────────── v1.2.0
  Installed libcxxwrap_julia_jll ─ v0.8.0+0
  Installed BinDeps ────────────── v1.0.1
  Installed Hecke ──────────────── v0.8.4
  Installed AbstractAlgebra ────── v0.9.2
  Installed Polymake ───────────── v0.4.3
  Installed Antic_jll ──────────── v0.1.0+2
  Installed Singular ───────────── v0.3.2
  Installed JSON ───────────────── v0.21.0
  Installed GAP ────────────────── v0.4.3
Downloading artifact: FLINT
Downloading artifact: MPFR
Downloading artifact: GMP
Downloading artifact: lib4ti2
Downloading artifact: Arb
Downloading artifact: GLPK
Downloading artifact: libcxxwrap_julia
Downloading artifact: gap
curl: (22) The requested URL returned error: 404 Not Found                    
Downloading artifact: gap
Downloading artifact: Antic
Updating `/tmp/oscar/Project.toml`
  [f1435218] + Oscar v0.4.0
Updating `/tmp/oscar/Manifest.toml`
  [c3fe647b] + AbstractAlgebra v0.9.2
  [e21ec000] + Antic_jll v0.1.0+2
  [d9960996] + Arb_jll v2.17.0+1
  [9e28174c] + BinDeps v1.0.1
  [b99e7846] + BinaryProvider v0.5.10
  [631607c0] + CMake v1.2.0
  [1f15a43c] + CxxWrap v0.11.0
  [e134572f] + FLINT_jll v0.0.2+0
  [c863536a] + GAP v0.4.3
  [e8aa6df9] + GLPK_jll v4.65.0+0
  [781609d7] + GMP_jll v6.1.2+5
  [3e1990a7] + Hecke v0.8.4
  [682c06a0] + JSON v0.21.0
  [472f376f] + LoadFlint v0.2.1
  [3a97d323] + MPFR_jll v4.0.2+2
  [1914dd2f] + MacroTools v0.5.5
  [2edaba10] + Nemo v0.17.6
  [f1435218] + Oscar v0.4.0
  [69de0a69] + Parsers v1.0.10
  [d720cf60] + Polymake v0.4.3
  [ae029012] + Requires v1.0.2
  [bcd08a7b] + Singular v0.3.2
  [30578b45] + URIParser v0.4.1
  [1493ae25] + lib4ti2_jll v1.6.9+1
  [3eaa8342] + libcxxwrap_julia_jll v0.8.0+0
  [2a0f44e3] + Base64
  [ade2ca70] + Dates
  [8ba89e20] + Distributed
  [b77e0a4c] + InteractiveUtils
  [76f85450] + LibGit2
  [8f399da3] + Libdl
  [37e2e46d] + LinearAlgebra
  [56ddb016] + Logging
  [d6f4376e] + Markdown
  [a63ad114] + Mmap
  [44cfe95a] + Pkg
  [de0858da] + Printf
  [9abbd945] + Profile
  [3fa0cd96] + REPL
  [9a3f8284] + Random
  [ea8e919c] + SHA
  [9e88b42a] + Serialization
  [6462fe0b] + Sockets
  [2f01184e] + SparseArrays
  [10745b16] + Statistics
  [8dfed614] + Test
  [cf7118a7] + UUIDs
  [4ec0a83e] + Unicode
   Building LoadFlint → `/tmp/oscar/packages/LoadFlint/jHlQx/deps/build.log`
   Building Nemo ─────→ `/tmp/oscar/packages/Nemo/vCIJx/deps/build.log`
   Building CMake ────→ `/tmp/oscar/packages/CMake/ULbyn/deps/build.log`
   Building Polymake ─→ `/tmp/oscar/packages/Polymake/qn5DS/deps/build.log`
   Building Singular ─→ `/tmp/oscar/packages/Singular/5YqNQ/deps/build.log`
┌ Error: Error building `Singular`: 
│ ┌ Error: Download failed: curl: (22) The requested URL returned error: 404 Not Found
│ └ @ Base download.jl:43
│ ERROR: LoadError: failed process: Process(`curl -s -S -g -L -f -o /tmp/oscar/packages/Singular/5YqNQ/deps/build_libflint.v0.0.0-ba0ceed35136a2a43441ab9a9b2e7764e38548ea.jl https://github.com/thofma/Flint2Builder/releases/download/ba0cee/build_libflint.v0.0.0-ba0ceed35136a2a43441ab9a9b2e7764e38548ea.jl`, ProcessExited(22)) [22]
│ 
│ Stacktrace:
│  [1] pipeline_error at ./process.jl:525 [inlined]
│  [2] download_curl(::String, ::String, ::String) at ./download.jl:44
│  [3] download(::String, ::String) at ./download.jl:62
│  [4] top-level scope at /tmp/oscar/packages/Singular/5YqNQ/deps/build.jl:37
│  [5] include(::String) at ./client.jl:457
│  [6] top-level scope at none:5
│ in expression starting at /tmp/oscar/packages/Singular/5YqNQ/deps/build.jl:19
└ @ Pkg.Operations /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/Pkg/src/Operations.jl:949
   Building GAP ──────→ `/tmp/oscar/packages/GAP/tkivN/deps/build.log`

julia> using Oscar
[ Info: Precompiling Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13]
ERROR: LoadError: Singular.jl needs to be compiled; please run `using Pkg; Pkg.build("Singular")`
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] top-level scope at /tmp/oscar/packages/Singular/5YqNQ/src/Singular.jl:63
 [3] include(::Function, ::Module, ::String) at ./Base.jl:380
 [4] include(::Module, ::String) at ./Base.jl:368
 [5] top-level scope at none:2
 [6] eval at ./boot.jl:331 [inlined]
 [7] eval(::Expr) at ./client.jl:467
 [8] top-level scope at ./none:3
in expression starting at /tmp/oscar/packages/Singular/5YqNQ/src/Singular.jl:62
ERROR: LoadError: Failed to precompile Singular [bcd08a7b-43d2-5ff7-b6d4-c458787f915c] to /tmp/oscar/compiled/v1.5/Singular/9fz0y_XHfx2.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1305
 [3] _require(::Base.PkgId) at ./loading.jl:1030
 [4] require(::Base.PkgId) at ./loading.jl:928
 [5] require(::Module, ::Symbol) at ./loading.jl:923
 [6] include(::Function, ::Module, ::String) at ./Base.jl:380
 [7] include(::Module, ::String) at ./Base.jl:368
 [8] top-level scope at none:2
 [9] eval at ./boot.jl:331 [inlined]
 [10] eval(::Expr) at ./client.jl:467
 [11] top-level scope at ./none:3
in expression starting at /tmp/oscar/packages/Oscar/W12Al/src/Oscar.jl:32
ERROR: Failed to precompile Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13] to /tmp/oscar/compiled/v1.5/Oscar/aJ3Pg_XHfx2.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1305
 [3] _require(::Base.PkgId) at ./loading.jl:1030
 [4] require(::Base.PkgId) at ./loading.jl:928
 [5] require(::Module, ::Symbol) at ./loading.jl:923

@thofma you owned the missing repo, what happened to it?

Factoring polynomials over finite fields does not work.

I ran the the following example and Oscar crashed:

julia> K = GF(2)
Galois field with characteristic 2

julia> ZS, (a,b,c) = PolynomialRing(K, ["a", "b", "c"])
(Multivariate Polynomial Ring in a, b, c over Galois field with characteristic 2, AbstractAlgebra.Generic.MPoly{Nemo.gfp_elem}[1*a, 1*b, 1*c])

julia> F = a*b^4+b*c^4+a*c^4
1*a*b^4 + 1*a*c^4 + 1*b*c^4

julia> factor(F)
   ? multivariate factorization depends on NTL(missing)
   ? not implemented

signal (11): Segmentation fault
in expression starting at REPL[5]:1
length at /workspace/destdir/include/singular/misc/intvec.h:94 [inlined]
operator() at /workspace/srcdir/libsingular-julia-0.2.0/rings.cpp:269 [inlined]
_M_invoke at /opt/x86_64-linux-gnu/x86_64-linux-gnu/include/c++/7.1.0/bits/std_function.h:302
operator() at /opt/x86_64-linux-gnu/x86_64-linux-gnu/include/c++/7.1.0/bits/std_function.h:706 [inlined]
operator() at /opt/x86_64-linux-gnu/x86_64-linux-gnu/sys-root/usr/local/include/jlcxx/module.hpp:47 [inlined]
apply at /opt/x86_64-linux-gnu/x86_64-linux-gnu/sys-root/usr/local/include/jlcxx/module.hpp:72
singclap_factorize at /home/pol/.julia/packages/CxxWrap/ZOkSN/src/CxxWrap.jl:590 [inlined]
factor at /home/pol/.julia/packages/Singular/cuKCT/src/poly/poly.jl:734
factor at /home/pol/.julia/dev/Oscar/src/Rings/mpoly.jl:1105
jl_apply at /home/pol/julia/src/julia.h:1690 [inlined]
do_call at /home/pol/julia/src/interpreter.c:117
eval_value at /home/pol/julia/src/interpreter.c:206
eval_stmt_value at /home/pol/julia/src/interpreter.c:157 [inlined]
eval_body at /home/pol/julia/src/interpreter.c:548
jl_interpret_toplevel_thunk at /home/pol/julia/src/interpreter.c:660
jl_toplevel_eval_flex at /home/pol/julia/src/toplevel.c:840
jl_toplevel_eval_flex at /home/pol/julia/src/toplevel.c:790
jl_toplevel_eval_in at /home/pol/julia/src/toplevel.c:883
eval at ./boot.jl:331
eval_user_input at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:134
repl_backend_loop at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:195
start_repl_backend at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:180
#run_repl#37 at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:292
run_repl at /home/pol/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:288
#806 at ./client.jl:399
jfptr_YY.806_37718 at /home/pol/julia/usr/lib/julia/sys.so (unknown line)
jl_apply at /home/pol/julia/src/julia.h:1690 [inlined]
do_apply at /home/pol/julia/src/builtins.c:655
jl_f__apply_latest at /home/pol/julia/src/builtins.c:705
#invokelatest#1 at ./essentials.jl:710 [inlined]
invokelatest at ./essentials.jl:709 [inlined]
run_main_repl at ./client.jl:383
exec_options at ./client.jl:313
_start at ./client.jl:506
jfptr__start_30174 at /home/pol/julia/usr/lib/julia/sys.so (unknown line)
jl_apply at /home/pol/julia/ui/../src/julia.h:1690 [inlined]
true_main at /home/pol/julia/ui/repl.c:106
main at /home/pol/julia/ui/repl.c:227
__libc_start_main at /lib/x86_64-linux-gnu/libc.so.6 (unknown line)
_start at /home/pol/julia/./julia (unknown line)
Allocations: 50547644 (Pool: 50508299; Big: 39345); GC: 25
Segmentation fault (core dumped)

Error while compiling Oscar v0.2.0 with Xcode >= 11.4

   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.3.1 (2019-12-30)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |
(v1.3) pkg> status
    Status `~/.julia/environments/v1.3/Project.toml`
  [e30172f5] Documenter v0.24.7
  [c863536a] GAP v0.3.5
  [3e1990a7] Hecke v0.8.0
  [50bd374c] HomalgProject v0.1.8 [`~/.julia/dev/HomalgProject`]
  [7073ff75] IJulia v1.21.1
  [472f376f] LoadFlint v0.1.2
  [f1435218] Oscar v0.2.0
  [d720cf60] Polymake v0.3.2
  [bcd08a7b] Singular v0.2.1
  [42bdb5c4] Theta v0.1.0

julia> using Oscar
[ Info: Precompiling Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13]
Assertion failed: (has_julia_type<T>()), function value, file /Users/mo/.julia/packages/CxxWrap/lDNAy/deps/usr/lib/cmake/JlCxx/../../../include/jlcxx/type_conversion.hpp, line 601.

signal (6): Abort trap: 6
in expression starting at /Users/mo/.julia/packages/Polymake/kIMyn/src/Polymake.jl:41
__pthread_kill at /usr/lib/system/libsystem_kernel.dylib (unknown line)
Allocations: 1562364 (Pool: 1562120; Big: 244); GC: 1
ERROR: LoadError: Failed to precompile Polymake [d720cf60-89b5-51f5-aff5-213f193123e7] to /Users/mo/.julia/compiled/v1.3/Polymake/QizyK_VOjQ4.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1283
 [3] _require(::Base.PkgId) at ./loading.jl:1024
 [4] require(::Base.PkgId) at ./loading.jl:922
 [5] require(::Module, ::Symbol) at ./loading.jl:917
 [6] include at ./boot.jl:328 [inlined]
 [7] include_relative(::Module, ::String) at ./loading.jl:1105
 [8] include(::Module, ::String) at ./Base.jl:31
 [9] top-level scope at none:2
 [10] eval at ./boot.jl:330 [inlined]
 [11] eval(::Expr) at ./client.jl:425
 [12] top-level scope at ./none:3
in expression starting at /Users/mo/.julia/packages/Oscar/kRdEf/src/Oscar.jl:33
ERROR: Failed to precompile Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13] to /Users/mo/.julia/compiled/v1.3/Oscar/aJ3Pg_VOjQ4.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1283
 [3] _require(::Base.PkgId) at ./loading.jl:1024
 [4] require(::Base.PkgId) at ./loading.jl:922
 [5] require(::Module, ::Symbol) at ./loading.jl:917

Oscar Roadmap

This is a roadmap of all issues people consider important or of high priority across the whole of the Oscar system.
Names are attached to the issues currently being worked on. They are in no particular order.

  • Infrastructure
  • AbstractAlgebra.jl, Nemo
    • Modules over Euclidean domains - @wbhart
    • iseuclidean, isdomain, etc. predicates in AbstractAlgebra
    • clean up left/right kernel/solve interface in AbstractAlgebra @a-kulkarn
    • Groups interface - @kalmarek @fieker @fingolfin
    • Interface conformance testing
    • Wrap Flint's fq_zech modules
    • Embeddings of finite fields @wbhart @erou
    • Expansion of a rational function as a Laurent series
    • Better user documentation and test code for Nemo.jl @wbhart
    • Clean up and merge a-kulkarn's work on solve (includes making the same improvements to Nemo as he has made to AbstractAlgebra) Nemocas/AbstractAlgebra.jl#559
  • Hecke.jl
  • Singular, Singular.jl
  • GAP, GAP.jl
  • Polymake, Polymayke.jl
  • Oscar.jl
    • User documentation for Oscar.jl
    • Conversion functions between different matrix and polynomial types in Oscar.jl
    • Refresh Oscar repository - @wbhart
    • Import of chosen default functionality into Oscar.jl from other systems
      • This does not mean "using Hecke; using Nemo; using Singular", etc. It means importing only the required functionality, as the former is not expected to be possible.
  • Unsorted
    • Harmonise interface for Fin Gen Ab Gps and Fin Pres Mods over Euc Dom - @fieker @wbhart
    • Euc. domain interface, esp. for polys and matrices in AbstractAlgebra - @wbhart @fieker
    • Precompile some code for basic rings (e.g. Z, Z/pZ, Q, etc.) to avoid Jit overhead
    • Implement Julia map functionality for our types @rfourquet
    • Decorated rings/modules (gradings, etc.) @fieker

SLPs: no method matching `gens(::Type{SLProgram}, ::Int64)`

I'm trying to try Oscar's StraightLinePrograms, specifically the examples in StraightLinePrograms/README.md.

Instead of using StraightLinePrograms, which errors with ERROR: ArgumentError: Package StraightLinePrograms not found in current path:, I use using Oscar.StraightLinePrograms. However then the first example from the readme yields:

julia> x, y, z = gens(SLProgram, 3)
ERROR: MethodError: no method matching gens(::Type{SLProgram}, ::Int64)
Closest candidates are:
  gens(::Oscar.GAPGroup, ::Int64) at /home/sergio/.julia/packages/Oscar/r1Uj5/src/Groups/GAPGroups.jl:383
Stacktrace:
 [1] top-level scope at REPL[8]:1

Behaviour of div/divrem in Oscar

As a consequence of Nemocas/Nemo.jl#868 I offered to make the changes that would be necessary to support necessary changes to div/divrem that were made in Nemo in all our packages (except Hecke, which Tommy will deal with).

Unfortunately, as Oscar imports the Nemo behaviour, the current Oscar tests will break. Therefore a decision must be made as to what behaviour Oscar wants for div/divrem.

There are a number of options here:

  • Just fix the tests that will break and make a decision later
  • Remove the tests that will break and defer all decisions until later
  • Make a decision now. There are three possibilities:
    • Make Oscar behave internally and externally the same way as Nemo/AbstractAlgebra behave internally/externally respectively
    • Make Oscar behave internally and externally as Nemo/AbstractAlgebra do internally
    • Make Oscar behave internally and externally as Nemo/AbstractAlgebra/Julia do externally. Here there are two options:
      • Do postprocessing on HNF and other functions which reduce their output so that it agrees with div/divrem and lose uniqueness of HNF over Z
      • Leave functions as they are and fix bugs as they pop up over time

I don't at all care what decision is made, just let me know and I'll make a PR with the changes to be applied when the next version of Nemo is made a dependency.

Note that the external behaviour of Nemo is currently under review. It may be changed at a later date to agree with the internal behaviour, which differs from the behaviour of Julia at the REPL. The internal behaviour of Nemo is considered stable and it is considered impractical to change it (again).

Improve conversion between GAP larger integers and fmpz

Currently, converting between GAP larger integers and fmpz is done via an intermediate conversion to BigInt. That is wasteful, and we should implement a direct conversion.

In the latest Nemo.jl master branch, there is a helper _as_bigint is defined to "view" a non-small fmpz as a bigint:

# "views" a non-small fmpz as a readonly BigInt
# the caller must call GC.@preserve appropriately
function _as_bigint(z::fmpz)
   @assert !_fmpz_is_small(z)
   unsafe_load(Ptr{BigInt}(z.d << 2))
end

In Oscar.jl we could use it to provide efficient conversion from fmpz to GAP larger integers by doing something roughly like this (plus perhaps some error checking...):

fmpz(x::GapObj) = GC.@preserve x fmpz(_as_bigint(x))

Probably also julia_to_gap and convert should get corresponding methods.

inside Oscar, GAP's Browse package cannot be loaded

Currently I have problems to get a running version of Oscar.
Earlier this week I had a similar problem when I tried to update my installation, but removing my ~/.julia directory and then reinstalling everything from scratch worked.
Now even this brute force approach does not help.

This is what I tried, first for installing the released version.
Remove ~/.julia, call Julia 1.4, enter using Pkg; Pkg.add( "Oscar" ).
This works without problem. But then entering using Oscar results in the following message.

[ Info: Precompiling Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13]
ERROR: LoadError: LoadError: could not load library "/export/home/sam/.julia/packages/Singular/5YqNQ/deps/usr/lib/libsingularwrap.so"
/export/home/sam/julia/julia-1.4.0/bin/../lib/julia/libstdc++.so.6: version `GLIBCXX_3.4.26' not found (required by /export/home/sam/.julia/packages/Singular/5YqNQ/deps/usr/lib/libsingularwrap.so)

When I try the current master branch of Oscar instead of the released version, the error is different.
Again, I remove ~/.julia, call Julia 1.4, but now enter using Pkg; Pkg.develop( PackageSpec( path = ".../Oscar.jl" ) ); Pkg.build( "Oscar" ).
Then using Oscar results in

[ Info: Precompiling Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13]
[ Info: Generating module common
[ Info: Generating module ideal
[ Info: Generating module graph
[ Info: Generating module fulton
[ Info: Generating module fan
[ Info: Generating module group
[ Info: Generating module polytope
[ Info: Generating module topaz
[ Info: Generating module tropical
[ Info: Generating module matroid
Error opening terminal: xterm-256color.
ERROR: Failed to precompile Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13] to /home/sam/.julia/compiled/v1.4/Oscar/aJ3Pg_rIEfL.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1272
 [3] _require(::Base.PkgId) at ./loading.jl:1029
 [4] require(::Base.PkgId) at ./loading.jl:927
 [5] require(::Module, ::Symbol) at ./loading.jl:922

(When I set the value of the TERM variable to xterm, I run into the same error, except that Julia says Error opening terminal: xterm.)

Installation Fails

Hi, I am running Julia 1.5.2 on a server with CentOS 7.8.2003 and I encounter the following error when calling

Pkg.add("Oscar")
ERROR: LoadError: LoadError: InitError: could not load library "/home/foo/.julia/artifacts/b801935f313061d64e28d8a28c39cdc24f139920/lib/libform.so"
/home/foo/.julia/artifacts/b801935f313061d64e28d8a28c39cdc24f139920/lib/libform.so: cannot open shared object file: No such file or directory
Stacktrace:
[1] dlopen(::String, ::UInt32; throw_error::Bool) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/Libdl/src/Libdl.jl:109
[2] dlopen(::String, ::UInt32) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/Libdl/src/Libdl.jl:109
[3] macro expansion at /home/foo/.julia/packages/JLLWrappers/KuIwt/src/products/library_generators.jl:61 [inlined]
[4] __init__() at /home/foo/.julia/packages/Ncurses_jll/L4aje/src/wrappers/x86_64-linux-gnu.jl:12
[5] _include_from_serialized(::String, ::Array{Any,1}) at ./loading.jl:697
[6] _require_from_serialized(::String) at ./loading.jl:749
[7] _require(::Base.PkgId) at ./loading.jl:1040
[8] require(::Base.PkgId) at ./loading.jl:928
[9] require(::Module, ::Symbol) at ./loading.jl:923
[10] include(::Function, ::Module, ::String) at ./Base.jl:380
[11] include(::Module, ::String) at ./Base.jl:368
[12] top-level scope at /home/foo/.julia/packages/JLLWrappers/KuIwt/src/toplevel_generators.jl:170
[13] include(::Function, ::Module, ::String) at ./Base.jl:380
[14] include(::Module, ::String) at ./Base.jl:368
[15] top-level scope at none:2
[16] eval at ./boot.jl:331 [inlined]
[17] eval(::Expr) at ./client.jl:467
[18] top-level scope at ./none:3
during initialization of module Ncurses_jll
in expression starting at /home/foo/.julia/packages/Readline_jll/uSXvl/src/wrappers/x86_64-linux-gnu.jl:4
in expression starting at /home/foo/.julia/packages/Readline_jll/uSXvl/src/Readline_jll.jl:8
ERROR: LoadError: LoadError: Failed to precompile Readline_jll [05236dd9-4125-5232-aa7c-9ec0c9b2c25a] to /home/iilmer/.julia/compiled/v1.5/Readline_jll/5XnCl_K8G9v.ji.
Stacktrace:
[1] error(::String) at ./error.jl:33
[2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1305
[3] _require(::Base.PkgId) at ./loading.jl:1030
[4] require(::Base.PkgId) at ./loading.jl:928
[5] require(::Module, ::Symbol) at ./loading.jl:923
[6] include(::Function, ::Module, ::String) at ./Base.jl:380
[7] include(::Module, ::String) at ./Base.jl:368
[8] top-level scope at /home/foo/.julia/packages/JLLWrappers/KuIwt/src/toplevel_generators.jl:170
[9] include(::Function, ::Module, ::String) at ./Base.jl:380
[10] include(::Module, ::String) at ./Base.jl:368
[11] top-level scope at none:2
[12] eval at ./boot.jl:331 [inlined]
[13] eval(::Expr) at ./client.jl:467
[14] top-level scope at ./none:3
in expression starting at /home/foo/.julia/packages/Perl_jll/3dFcW/src/wrappers/x86_64-linux-gnu.jl:4
in expression starting at /home/foo/.julia/packages/Perl_jll/3dFcW/src/Perl_jll.jl:8
ERROR: LoadError: Failed to precompile Perl_jll [83958c19-0796-5285-893e-a1267f8ec499] to /home/iilmer/.julia/compiled/v1.5/Perl_jll/fYLMz_K8G9v.ji.
Stacktrace:
[1] error(::String) at ./error.jl:33
[2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1305
[3] _require(::Base.PkgId) at ./loading.jl:1030
[4] require(::Base.PkgId) at ./loading.jl:928
[5] require(::Module, ::Symbol) at ./loading.jl:923
[6] include(::Function, ::Module, ::String) at ./Base.jl:380
[7] include(::Module, ::String) at ./Base.jl:368
[8] top-level scope at none:2
[9] eval at ./boot.jl:331 [inlined]
[10] eval(::Expr) at ./client.jl:467
[11] top-level scope at ./none:3
in expression starting at /home/foo/.julia/packages/Polymake/omVjG/src/Polymake.jl:36
ERROR: LoadError: Failed to precompile Polymake [d720cf60-89b5-51f5-aff5-213f193123e7] to /home/iilmer/.julia/compiled/v1.5/Polymake/QizyK_K8G9v.ji.
Stacktrace:
[1] error(::String) at ./error.jl:33
[2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1305
[3] _require(::Base.PkgId) at ./loading.jl:1030
[4] require(::Base.PkgId) at ./loading.jl:928
[5] require(::Module, ::Symbol) at ./loading.jl:923
[6] include(::Function, ::Module, ::String) at ./Base.jl:380
[7] include(::Module, ::String) at ./Base.jl:368
[8] top-level scope at none:2
[9] eval at ./boot.jl:331 [inlined]
[10] eval(::Expr) at ./client.jl:467
[11] top-level scope at ./none:3
in expression starting at /home/foo/.julia/packages/Oscar/YX0cd/src/Oscar.jl:33
ERROR: Failed to precompile Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13] to /home/iilmer/.julia/compiled/v1.5/Oscar/aJ3Pg_K8G9v.ji.
Stacktrace:
[1] error(::String) at ./error.jl:33
[2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1305
[3] _require(::Base.PkgId) at ./loading.jl:1030
[4] require(::Base.PkgId) at ./loading.jl:928
[5] require(::Module, ::Symbol) at ./loading.jl:923

Are there any additional requirements for this package? the top line of the error suggests a libform.so is missing but how do i install it?
Let me know if any additional info is needed about the setup.

supported Julia versions

I think this is a good time to decide which platforms and which Julia versions we currently support.

Here is my suggestion:

  • we support Julia 1.3 and we try to get ready a.s.a.p. for the upcoming Julia 1.4
  • target platforms: x86_64-linux-gnu, x86_64-apple-darwin14
  • CxxWrap 0.9.0
  • travis: distribution ubuntu bionic

Some explanations:

  • Julia 1.0 is the latest LTS version, but it seems unlikely that GAP (with its garbage collection) can ever be supported
  • Julia 1.1 and 1.2 do not receive any back ports any more
  • Windows support only through WSL (i.e., this is covered by x86_64-linux-gnu)
  • The travis configuration is important for building CxxWrap; otherwise the compiler is too old.

Unless there are immediate objections, this should be posted on
https://github.com/oscar-system/Oscar.jl/blob/master/README.md

Of course, this is a moving target. So it will require frequent (?) updates.

divexact for decorated polynomials

When trying to take a fraction with decorated polynomials, it seems to run into a loop because of divexact:

julia> S, (x,y,z) = PolynomialRing(QQ, ["x", "y", "z"])
(Multivariate Polynomial Ring in x, y, z over Rational Field, fmpq_mpoly[x, y, z])

julia> T = grade(S)
Multivariate Polynomial Ring in x, y, z over Rational Field filtrated by
        x -> [1]
        y -> [1]
        z -> [1]


julia> divexact(T(x), T(1))
ERROR: StackOverflowError:
Stacktrace:
 [1] divexact(::Oscar.MPolyElem_dec{fmpq}, ::Oscar.MPolyElem_dec{fmpq}) at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/Rings.jl:84
 [2] divexact(::Oscar.MPolyElem_dec{fmpq}, ::Oscar.MPolyElem_dec{fmpq}) at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/Rings.jl:86 (repeats 79983 times)

julia> T(x)//T(y)
ERROR: StackOverflowError:
Stacktrace:
 [1] divexact(::Oscar.MPolyElem_dec{fmpq}, ::Oscar.MPolyElem_dec{fmpq}) at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/Rings.jl:84
 [2] divexact(::Oscar.MPolyElem_dec{fmpq}, ::Oscar.MPolyElem_dec{fmpq}) at /home/pol/.julia/packages/AbstractAlgebra/W7COB/src/Rings.jl:86 (repeats 79983 times)

CI test failure: no method matching (::FlintRationalField)(::Singular.n_Q)

As is visible on https://github.com/oscar-system/Oscar.jl/actions?query=workflow%3A%22Run+tests%22+branch%3Amaster the tests started failing between commits c46b63e and 27a505a with this error:

Polynomial homs: Error During Test at /home/runner/work/Oscar.jl/Oscar.jl/test/Rings/mpoly-test.jl:43
  Test threw exception
  Expression: h(gen(S, 1)) == I1
  MethodError: no method matching (::FlintRationalField)(::Singular.n_Q)
  Closest candidates are:
    Any(!Matched::nf_elem) at /home/runner/.julia/packages/Hecke/SROq0/src/NumField/NfAbs/NfAbs.jl:1243
    Any() at /home/runner/.julia/packages/Nemo/oOtel/src/flint/fmpq.jl:819
    Any(!Matched::Int64, !Matched::Int64) at /home/runner/.julia/packages/Nemo/oOtel/src/flint/fmpq.jl:832
    ...

@fieker you pushed that code, I hope you have a fix.

May I suggest this is another example why it might be helpful to do these things via a PR, so that we detect mistakes earlier, instead of breaking the test suite for all? It just cost me half an hour because I thought my PR #207 was the cause, since the message involves gen ... :-(

Banners

The issue of banners for your projects comes up about every 6 months. So we, the project leaders, discussed it and recording this here, as an issue to be able to link against this.

Computer Algebra Systems always have banners

  • Julia, Maple, Mathematica, Maple, ...
  • Gap, Singular, Polymake
    Thus our "cornerstones" have banners - which can be suppressed in non-interactive mode.

Now we added a new, interactive, user interface to our systems, so of course, we display banners on interactive use - and do not print them otherwise. In Oscar, we "accumulate" the individual banners into the Oscar one.

Hecke/ Nemo are intended also as computer algebra systems, not "only" as libraries, thus have banners - which are not shown unless we are interactive.

Updating FLINT_jll (and other JLLs) across all OSCAR packages

Yesterday I updated FLINT_jll to a snapshot of the latest git version, calling it 2.6.999 (and also update Singular_jll to use that new FLINT_jll; the motiviation for all that is to get lots of fixes and improvements made to polynomial factorization). Unfortunately this broken Nemo. @thofma quickly resolved this by getting the two new JLLs yanked from the registry.
Anyway, I am sorry for the annoyance I caused -- I was so focused on testing Singular.jl with the changes that I completely forgot that I should be testing Nemo.jl and also coordinate with LoadFlint.jl.

Still, the underlying issue is that FLINT and Singular simply don't follow semver, and pressing them into JLL semver version doesn't work well. As a matter of fact, FLINT 2.6 and 2.7 are not ABI compatible (which is the ultimate cause for the crashes in Nemo).

For FLINT_jll, I was asked why I didn't call the update 2.7.0 instead of 2.6.999 -- well the reason was that this isn't 2.7.0, and this would have been misleading. So why didn't I call it 2.7.0-dev or something? Because prerelease versions are not allowed for JLLs and more generally packages in the general registry! (Which I think is a pity, but those are the rules). That left me with the choice of using 2.6.999 or else something like 2.7.0; you already know the issues with the former; for the later, it would mean decoupling the JLL version from the upstream (Flint) version; the actual Flint 2.7.0 would then be put in a JLL with a version like 2.7.1; or in fact perhaps 2.8 because this snapshot may very well ABI (or even API) incompatible with the final 2.7.0. And if you take a step back, an ABI incompatibility in the semver model actually means that the major version should have incremented, so to follow that, I would need to call the JLL version 3.0 (and then the final 2.7.0 may end up either as 3.1 or as 4.0), etc.

In fact, this is an actual problem for many JLLs, and the BinaryBuilder team already recognized this, and formed the plan is to decouple JLL versions from upstream project versions, and keep some internal tables that tell how JLL versions map to upstream versions. (Besides not following semver rules, there are also projects which don't follow the x.y.z pattern for versions -- e.g. Singular...)

Anyway, for the time being, we need a way to deal with this, and also a plan how to roll out the FLINT_jll update. I just discussed this @thofma and here is an initial proposal how to go about this; further input is welcome (I hope that in particular @benlorenz will take a look at this):

  1. Since FLINT and Singular don't follow semver, I recommend that we change our packages to hardcode a specific FLINT_jll version via a = compat bound in Project.toml decouple the JLL version from the actual version, to give us room to maneuver; the plan is to map e.g. FLINT_jll 2.6.3 to 200.600.300, and 2.7.0 to 200.700.000; and then the 2.7 prerelease snapshot(s) can be e.g. 200.690.000, leaving enough wiggle room for future eventualities; this way a compat entry like FLINT = ~200.600.300 won't pick up the pre-release snapshot. But if e.g.e.g. Nemo were (hypothetically speaking) compatible with both 2.6.3 and 2.7.0, we could still declare this with a suitable compat entry. Another advantage of this approach is that it plays well with the current LoadFlint.jl release, which says FLINT_jll = "^2.6.0" so the new JLL won't be picked up prematurely.
  2. Ideally also change the JLLs to use say a VersionSpec to ensure useful compat bounds in those JLLs... so that a Singular_jll linked against FLINT_jll 200.600.300 won't load with FLINT_jll 200.690.000 and vice versa (yes this may mean we need to make a few more JLL updates than otherwise, e.g. even if FLINT_jll 200.690 and 200.700 end up 100% ABI compatible, we'll have to regenerate Singular_jll with a new compat bound -- but that's a tradeoff, some extra work gives us extra control and protection against certain problems
  3. Once the new JLL versions are out, update packages to be able to use them (instead or in addition to older versions)
  4. then make releases of these packages
    • LoadFlint.jl
    • Nemo.jl
    • Singular.jl
    • Polymake.jl
  5. Add a comment to the build_tarballs.jl for FLINT_jll along the lines of this:

    WARNING: whenever you update this, please consider how this may affect LoadFlint, Nemo, Polymake, Singular, and coordinate with other OSCAR projects"

Again, this is an initial proposal; feel free to point out issues, recommend improvements, etc.

Polymake and Singular don't compile when installing Oscar v0.2.0

I'm on Ubuntu 20.04.1 LTS. When I do ]add Oscar from within Julia (1.5.3) I get

               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.5.3 (2020-11-09)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

(@v1.5) pkg> add Oscar
   Updating registry at `~/.julia/registries/General`
######################################################################## 100,0%
  Resolving package versions...
  Installed CMake ─────────── v1.2.0
  Installed Requires ──────── v1.1.2
  Installed URIParser ─────── v0.4.1
  Installed CxxWrap ───────── v0.9.1
  Installed BinDeps ───────── v1.0.2
  Installed MacroTools ────── v0.5.6
  Installed AbstractAlgebra ─ v0.9.2
  Installed Oscar ─────────── v0.2.0
  Installed Nemo ──────────── v0.17.5
  Installed Polymake ──────── v0.3.3
  Installed Singular ──────── v0.2.2
  Installed Hecke ─────────── v0.8.4
  Installed LoadFlint ─────── v0.1.3
Updating `~/.julia/environments/v1.5/Project.toml`
  [f1435218] + Oscar v0.2.0
Updating `~/.julia/environments/v1.5/Manifest.toml`
  [c3fe647b] + AbstractAlgebra v0.9.2
  [9e28174c] + BinDeps v1.0.2
  [631607c0] + CMake v1.2.0
  [1f15a43c] + CxxWrap v0.9.1
  [3e1990a7] + Hecke v0.8.4
  [472f376f] + LoadFlint v0.1.3
  [1914dd2f] + MacroTools v0.5.6
  [2edaba10] + Nemo v0.17.5
  [f1435218] + Oscar v0.2.0
  [d720cf60] + Polymake v0.3.3
  [ae029012] + Requires v1.1.2
  [bcd08a7b] + Singular v0.2.2
  [30578b45] + URIParser v0.4.1
  [37e2e46d] + LinearAlgebra
  [9abbd945] + Profile
  [2f01184e] + SparseArrays
  [10745b16] + Statistics
   Building LoadFlint → `~/.julia/packages/LoadFlint/42zpR/deps/build.log`
   Building Nemo ─────→ `~/.julia/packages/Nemo/Pc5ui/deps/build.log`
   Building CMake ────→ `~/.julia/packages/CMake/ULbyn/deps/build.log`
   Building CxxWrap ──→ `~/.julia/packages/CxxWrap/hEmjg/deps/build.log`
   Building Polymake ─→ `~/.julia/packages/Polymake/asr90/deps/build.log`
┌ Error: Error building `Polymake`: 
│ 
│ signal (11): Segmentation fault
│ in expression starting at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/StdLib.jl:16
│ sig_match_simple at /buildworker/worker/package_linux64/build/src/typemap.c:128 [inlined]
│ jl_typemap_entry_assoc_exact at /buildworker/worker/package_linux64/build/src/typemap.c:662
│ jl_typemap_assoc_exact at /buildworker/worker/package_linux64/build/src/julia_internal.h:1074 [inlined]
│ jl_lookup_generic_ at /buildworker/worker/package_linux64/build/src/gf.c:2342 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2394
│ build_function_expression at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:550
│ wrap_functions at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:635
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2231 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ wrapfunctions at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:658
│ wrapmodule at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:678
│ unknown function (ip: 0x7f9407496080)
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2231 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1690 [inlined]
│ do_call at /buildworker/worker/package_linux64/build/src/interpreter.c:117
│ eval_value at /buildworker/worker/package_linux64/build/src/interpreter.c:206
│ eval_stmt_value at /buildworker/worker/package_linux64/build/src/interpreter.c:157 [inlined]
│ eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:566
│ jl_interpret_toplevel_thunk at /buildworker/worker/package_linux64/build/src/interpreter.c:660
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:840
│ jl_eval_module_expr at /buildworker/worker/package_linux64/build/src/toplevel.c:197
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:666
│ jl_parse_eval_all at /buildworker/worker/package_linux64/build/src/ast.c:913
│ jl_load_rewrite at /buildworker/worker/package_linux64/build/src/toplevel.c:914
│ include at ./Base.jl:380
│ include at ./Base.jl:368 [inlined]
│ include at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:1
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2231 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1690 [inlined]
│ do_call at /buildworker/worker/package_linux64/build/src/interpreter.c:117
│ eval_value at /buildworker/worker/package_linux64/build/src/interpreter.c:206
│ eval_stmt_value at /buildworker/worker/package_linux64/build/src/interpreter.c:157 [inlined]
│ eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:566
│ jl_interpret_toplevel_thunk at /buildworker/worker/package_linux64/build/src/interpreter.c:660
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:840
│ jl_eval_module_expr at /buildworker/worker/package_linux64/build/src/toplevel.c:197
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:666
│ jl_parse_eval_all at /buildworker/worker/package_linux64/build/src/ast.c:913
│ jl_load_rewrite at /buildworker/worker/package_linux64/build/src/toplevel.c:914
│ include at ./Base.jl:380
│ include at ./Base.jl:368
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2214 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1690 [inlined]
│ do_call at /buildworker/worker/package_linux64/build/src/interpreter.c:117
│ eval_value at /buildworker/worker/package_linux64/build/src/interpreter.c:206
│ eval_stmt_value at /buildworker/worker/package_linux64/build/src/interpreter.c:157 [inlined]
│ eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:566
│ eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:492
│ jl_interpret_toplevel_thunk at /buildworker/worker/package_linux64/build/src/interpreter.c:660
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:840
│ jl_toplevel_eval_in at /buildworker/worker/package_linux64/build/src/toplevel.c:883
│ eval at ./boot.jl:331 [inlined]
│ eval at ./client.jl:467
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2214 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ top-level scope at ./none:3
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:834
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:790
│ jl_toplevel_eval_in at /buildworker/worker/package_linux64/build/src/toplevel.c:883
│ eval at ./boot.jl:331
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2214 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ exec_options at ./client.jl:272
│ _start at ./client.jl:506
│ jfptr__start_53898.clone_1 at /home/sergio/.local/opt/julia/julia-1.5.3/lib/julia/sys.so (unknown line)
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2214 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ jl_apply at /buildworker/worker/package_linux64/build/ui/../src/julia.h:1690 [inlined]
│ true_main at /buildworker/worker/package_linux64/build/ui/repl.c:106
│ main at /buildworker/worker/package_linux64/build/ui/repl.c:227
│ __libc_start_main at /lib/x86_64-linux-gnu/libc.so.6 (unknown line)
│ _start at /home/sergio/.local/opt/julia/julia-1.5.3/bin/julia (unknown line)
│ Allocations: 14929090 (Pool: 14926189; Big: 2901); GC: 17
│ ERROR: LoadError: Failed to precompile CxxWrap [1f15a43c-97ca-5a2a-ae31-89f07a497df4] to /home/sergio/.julia/compiled/v1.5/CxxWrap/WGIJU_njQ5g.ji.
│ Stacktrace:
│  [1] error(::String) at ./error.jl:33
│  [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1305
│  [3] _require(::Base.PkgId) at ./loading.jl:1030
│  [4] require(::Base.PkgId) at ./loading.jl:928
│  [5] require(::Module, ::Symbol) at ./loading.jl:923
│  [6] include(::String) at ./client.jl:457
│  [7] top-level scope at none:5
│ in expression starting at /home/sergio/.julia/packages/Polymake/asr90/deps/build.jl:1
└ @ Pkg.Operations /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/Pkg/src/Operations.jl:949
   Building Singular ─→ `~/.julia/packages/Singular/GsN0h/deps/build.log`
┌ Error: Error building `Singular`: 
│ 
│ signal (11): Segmentation fault
│ in expression starting at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/StdLib.jl:16
│ sig_match_simple at /buildworker/worker/package_linux64/build/src/typemap.c:128 [inlined]
│ jl_typemap_entry_assoc_exact at /buildworker/worker/package_linux64/build/src/typemap.c:662
│ jl_typemap_assoc_exact at /buildworker/worker/package_linux64/build/src/julia_internal.h:1074 [inlined]
│ jl_lookup_generic_ at /buildworker/worker/package_linux64/build/src/gf.c:2342 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2394
│ build_function_expression at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:550
│ wrap_functions at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:635
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2231 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ wrapfunctions at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:658
│ wrapmodule at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:678
│ unknown function (ip: 0x7fe69b14e7c0)
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2231 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1690 [inlined]
│ do_call at /buildworker/worker/package_linux64/build/src/interpreter.c:117
│ eval_value at /buildworker/worker/package_linux64/build/src/interpreter.c:206
│ eval_stmt_value at /buildworker/worker/package_linux64/build/src/interpreter.c:157 [inlined]
│ eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:566
│ jl_interpret_toplevel_thunk at /buildworker/worker/package_linux64/build/src/interpreter.c:660
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:840
│ jl_eval_module_expr at /buildworker/worker/package_linux64/build/src/toplevel.c:197
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:666
│ jl_parse_eval_all at /buildworker/worker/package_linux64/build/src/ast.c:913
│ jl_load_rewrite at /buildworker/worker/package_linux64/build/src/toplevel.c:914
│ include at ./Base.jl:380
│ include at ./Base.jl:368 [inlined]
│ include at /home/sergio/.julia/packages/CxxWrap/hEmjg/src/CxxWrap.jl:1
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2231 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1690 [inlined]
│ do_call at /buildworker/worker/package_linux64/build/src/interpreter.c:117
│ eval_value at /buildworker/worker/package_linux64/build/src/interpreter.c:206
│ eval_stmt_value at /buildworker/worker/package_linux64/build/src/interpreter.c:157 [inlined]
│ eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:566
│ jl_interpret_toplevel_thunk at /buildworker/worker/package_linux64/build/src/interpreter.c:660
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:840
│ jl_eval_module_expr at /buildworker/worker/package_linux64/build/src/toplevel.c:197
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:666
│ jl_parse_eval_all at /buildworker/worker/package_linux64/build/src/ast.c:913
│ jl_load_rewrite at /buildworker/worker/package_linux64/build/src/toplevel.c:914
│ include at ./Base.jl:380
│ include at ./Base.jl:368
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2214 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ jl_apply at /buildworker/worker/package_linux64/build/src/julia.h:1690 [inlined]
│ do_call at /buildworker/worker/package_linux64/build/src/interpreter.c:117
│ eval_value at /buildworker/worker/package_linux64/build/src/interpreter.c:206
│ eval_stmt_value at /buildworker/worker/package_linux64/build/src/interpreter.c:157 [inlined]
│ eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:566
│ eval_body at /buildworker/worker/package_linux64/build/src/interpreter.c:492
│ jl_interpret_toplevel_thunk at /buildworker/worker/package_linux64/build/src/interpreter.c:660
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:840
│ jl_toplevel_eval_in at /buildworker/worker/package_linux64/build/src/toplevel.c:883
│ eval at ./boot.jl:331 [inlined]
│ eval at ./client.jl:467
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2214 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ top-level scope at ./none:3
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:834
│ jl_toplevel_eval_flex at /buildworker/worker/package_linux64/build/src/toplevel.c:790
│ jl_toplevel_eval_in at /buildworker/worker/package_linux64/build/src/toplevel.c:883
│ eval at ./boot.jl:331
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2214 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ exec_options at ./client.jl:272
│ _start at ./client.jl:506
│ jfptr__start_53898.clone_1 at /home/sergio/.local/opt/julia/julia-1.5.3/lib/julia/sys.so (unknown line)
│ _jl_invoke at /buildworker/worker/package_linux64/build/src/gf.c:2214 [inlined]
│ jl_apply_generic at /buildworker/worker/package_linux64/build/src/gf.c:2398
│ jl_apply at /buildworker/worker/package_linux64/build/ui/../src/julia.h:1690 [inlined]
│ true_main at /buildworker/worker/package_linux64/build/ui/repl.c:106
│ main at /buildworker/worker/package_linux64/build/ui/repl.c:227
│ __libc_start_main at /lib/x86_64-linux-gnu/libc.so.6 (unknown line)
│ _start at /home/sergio/.local/opt/julia/julia-1.5.3/bin/julia (unknown line)
│ Allocations: 14900814 (Pool: 14898126; Big: 2688); GC: 16
│ ERROR: LoadError: Failed to precompile CxxWrap [1f15a43c-97ca-5a2a-ae31-89f07a497df
│ Stacktrace:
│  [1] error(::String) at ./error.jl:33
│  [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1305
│  [3] _require(::Base.PkgId) at ./loading.jl:1030
│  [4] require(::Base.PkgId) at ./loading.jl:928
│  [5] require(::Module, ::Symbol) at ./loading.jl:923
│  [6] include(::String) at ./client.jl:457
│  [7] top-level scope at none:5
│ in expression starting at /home/sergio/.julia/packages/Singular/GsN0h/deps/build.jl
└ @ Pkg.Operations /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v

Oscar.build() fails with Oscar 0.3.0 due to a GMP issue with GAP.jl v0.3.5

Upon Claus' request to test Oscar.build():

$ julia
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.4.0 (2020-03-21)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> using Oscar
[ Info: Precompiling Oscar [f1435218-dba5-11e9-1e4d-f1a5fab5fc13]
[ Info: Generating module common
[ Info: Generating module ideal
[ Info: Generating module graph
[ Info: Generating module fulton
[ Info: Generating module fan
[ Info: Generating module group
[ Info: Generating module polytope
[ Info: Generating module topaz
[ Info: Generating module tropical
[ Info: Generating module matroid
 -----    -----    -----      -      -----
|     |  |     |  |     |    | |    |     |
|     |  |        |         |   |   |     |
|     |   -----   |        |     |  |-----
|     |        |  |        |-----|  |   |
|     |  |     |  |     |  |     |  |    |
 -----    -----    -----   -     -  -     -

...combining (and extending) GAP, Hecke, Nemo, Polymake and Singular
Version 0.3.0 ...
 ... which comes with absolutely no warranty whatsoever
Type: '?Oscar' for more information
(c) 2019-2020 by The Oscar Development Team

julia> Oscar.build()
   Updating registry at `~/.julia/registries/General`
   Updating git-repo `https://github.com/JuliaRegistries/General.git`
  Resolving package versions...
  Installed PackageCompiler ─ v1.1.1
   Updating `~/.julia/environments/v1.4/Project.toml`
  [9b87118b] + PackageCompiler v1.1.1
   Updating `~/.julia/environments/v1.4/Manifest.toml`
  [9b87118b] + PackageCompiler v1.1.1
  Resolving package versions...
   Updating `~/.julia/environments/v1.4/Project.toml`
  [8f399da3] + Libdl
   Updating `~/.julia/environments/v1.4/Manifest.toml`
 [no changes]
[ Info: Precompiling PackageCompiler [9b87118b-4619-50d2-8e1e-99f35a4d4d9d]
ERROR: InitError: could not load library "/Users/mo/.julia/packages/GAP/4od8v/gap-4.11.0/.libs/libgap"
dlopen(/Users/mo/.julia/packages/GAP/4od8v/gap-4.11.0/.libs/libgap.dylib, 9): Library not loaded: /usr/local/opt/gmp/lib/libgmp.10.dylib
  Referenced from: /Users/mo/.julia/packages/GAP/4od8v/gap-4.11.0/.libs/libgap.0.dylib
  Reason: Incompatible library version: libgap.dylib requires version 15.0.0 or later, but libgmp.dylib provides version 14.0.0
Stacktrace:
 [1] dlopen(::String, ::UInt32; throw_error::Bool) at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.4/Libdl/src/Libdl.jl:109
 [2] dlopen at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.4/Libdl/src/Libdl.jl:109 [inlined]
 [3] initialize(::String, ::Array{String,1}, ::Array{String,1}) at /Users/mo/.julia/packages/GAP/4od8v/src/GAP.jl:68
 [4] run_it(::String) at /Users/mo/.julia/packages/GAP/4od8v/src/GAP.jl:141
 [5] __init__() at /Users/mo/.julia/packages/GAP/4od8v/src/GAP.jl:159
 [6] _include_from_serialized(::String, ::Array{Any,1}) at ./loading.jl:697
 [7] _require_search_from_serialized(::Base.PkgId, ::String) at ./loading.jl:781
 [8] _tryrequire_from_serialized(::Base.PkgId, ::UInt64, ::String) at ./loading.jl:712
 [9] _require_search_from_serialized(::Base.PkgId, ::String) at ./loading.jl:770
 [10] _require(::Base.PkgId) at ./loading.jl:1006
 [11] require(::Base.PkgId) at ./loading.jl:927
 [12] require(::Module, ::Symbol) at ./loading.jl:922
during initialization of module GAP
caused by [exception 1]
could not load symbol "GAP_Initialize":
dlsym(RTLD_DEFAULT, GAP_Initialize): symbol not found
Stacktrace:
 [1] __init__() at /Users/mo/.julia/packages/GAP/4od8v/src/GAP.jl:156
 [2] _include_from_serialized(::String, ::Array{Any,1}) at ./loading.jl:697
 [3] _require_search_from_serialized(::Base.PkgId, ::String) at ./loading.jl:781
 [4] _tryrequire_from_serialized(::Base.PkgId, ::UInt64, ::String) at ./loading.jl:712
 [5] _require_search_from_serialized(::Base.PkgId, ::String) at ./loading.jl:770
 [6] _require(::Base.PkgId) at ./loading.jl:1006
 [7] require(::Base.PkgId) at ./loading.jl:927
 [8] require(::Module, ::Symbol) at ./loading.jl:922
ERROR: LoadError: failed process: Process(`/Applications/Julia-1.4.app/Contents/Resources/julia/bin/julia --color=yes --startup-file=no --sysimage=/Applications/Julia-1.4.app/Contents/Resources/julia/lib/julia/sys.dylib --project=/Users/mo/.julia/environments/v1.4 -e 'using Oscar'`, ProcessExited(1)) [1]

Stacktrace:
 [1] pipeline_error at ./process.jl:525 [inlined]
 [2] read(::Cmd) at ./process.jl:412
 [3] read(::Cmd, ::Type{String}) at ./process.jl:421
 [4] do_ensurecompiled(::String, ::Array{String,1}, ::String) at /Users/mo/.julia/packages/PackageCompiler/xtztx/src/PackageCompiler.jl:186
 [5] create_sysimg_object_file(::String, ::Array{String,1}; project::String, base_sysimage::String, precompile_execution_file::Array{String,1}, precompile_statements_file::Array{String,1}, cpu_target::String, script::Nothing, isapp::Bool) at /Users/mo/.julia/packages/PackageCompiler/xtztx/src/PackageCompiler.jl:246
 [6] create_sysimage(::Array{Symbol,1}; sysimage_path::String, project::String, precompile_execution_file::Array{String,1}, precompile_statements_file::String, incremental::Bool, filter_stdlibs::Bool, replace_default::Bool, cpu_target::String, script::Nothing, base_sysimage::Nothing, isapp::Bool) at /Users/mo/.julia/packages/PackageCompiler/xtztx/src/PackageCompiler.jl:423
 [7] top-level scope at /Users/mo/.julia/packages/Oscar/sqDwJ/system/Build.jl:15
 [8] include(::Module, ::String) at ./Base.jl:377
 [9] system(::String) at /Users/mo/.julia/packages/Oscar/sqDwJ/src/Oscar.jl:104
 [10] build() at /Users/mo/.julia/packages/Oscar/sqDwJ/src/Oscar.jl:108
 [11] top-level scope at REPL[2]:1
in expression starting at /Users/mo/.julia/packages/Oscar/sqDwJ/system/Build.jl:15

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.