Integrating JuLie into Oscar

docs/doc.main

@@ -212,6 +212,9 @@
       "Combinatorics/graphs.md",
       "Combinatorics/matroids.md",
       "Combinatorics/simplicialcomplexes.md",
+      "Combinatorics/partitions.md",
+      "Combinatorics/tableaux.md",
+      "Combinatorics/schur_polynomials.md",
   ],
 
   "Straight Line Programs" => [

docs/oscar_references.bib

@@ -879,6 +879,13 @@ @InProceedings{KLT20
   url           = {https://doi.org/10.1007/978-3-030-52200-1_37}
 }
 
+@Misc{KO14,
+  author        = {Kelleher, J. and O'Sullivan, B.},
+  title         = {Generating All Partitions: A Comparison Of Two Encodings},
+  year          = {2014},
+  url           = {https://arxiv.org/abs/0909.2331}
+}
+
 @Book{KR05,
   author        = {Kreuzer, Martin and Robbiano, Lorenzo},
   title         = {Computational commutative algebra. II},
@@ -1066,6 +1073,17 @@ @Book{Mar18
   url           = {https://doi.org/10.1007/978-3-319-90233-3}
 }
 
+@Article{Mer12,
+  author        = {Merca, M},
+  title         = {Fast algorithm for generating ascending compositions},
+  journal       = {J. Math. Model. Algorithms},
+  volume        = {11},
+  number        = {(1)},
+  pages         = {89--104},
+  year          = {2012},
+  url           = {https://doi.org/10.1007/s10852-011-9168-y}
+}
+
 @Article{Nik79,
   author        = {Nikulin, V. V.},
   title         = {Integer symmetric bilinear forms and some of their
@@ -1154,6 +1172,17 @@ @Article{Pos18
   doi           = {10.1007/s00013-018-1183-z}
 }
 
+@Article{RJ76,
+  author        = {Riha, W. and James, K. R.},
+  title         = {Algorithm 29 efficient algorithms for doubly and multiply
+                  restricted partitions},
+  journal       = {Computing},
+  volume        = {16},
+  pages         = {163--168},
+  year          = {1976},
+  url           = {https://link.springer.com/article/10.1007/BF02241987}
+}
+
 @Article{RR10,
   author        = {Roschy, Helmut and Rahn, Thorsten},
   title         = {Cohomology of line bundles: Proof of the algorithm},
@@ -1345,6 +1374,17 @@ @Article{Wit88
   reportnumber  = {IASSNS-HEP-88/7}
 }
 
+@Article{ZS98,
+  author        = {Zoghbi, A. and Stojmenovic, I.},
+  title         = {Fast algorithms for generating integer partitions},
+  journal       = {Int. J. Comput. Math.},
+  volume        = {70},
+  number        = {(2)},
+  pages         = {319--332},
+  year          = {1998},
+  url           = {https://doi.org/10.1080/00207169808804755}
+}
+
 @Book{Zie95,
   author        = {Ziegler, Günter M.},
   title         = {Lectures on polytopes},

docs/src/Combinatorics/partitions.md

@@ -0,0 +1,36 @@
+# Partitions
+
+```@docs
+    Partition
+```
+
+## Unrestricted partitions
+
+```@docs
+    partitions(::Integer)
+    num_partitions(::Integer)
+    ascending_partitions
+```
+
+## Restricted partitions
+
+```@docs
+    partitions(::Integer, ::Integer, ::Integer, ::Integer)
+    partitions(::Integer, ::Integer)
+    num_partitions(::Integer, ::Integer)
+    partitions(::Array{Integer,1}, ::Integer, ::Array{Integer,1}, ::Integer)
+```
+
+## Operations
+
+```@docs
+    conjugate
+    getindex_safe
+```
+
+## Relations
+
+```@docs
+    dominates
+```
+

docs/src/Combinatorics/schur_polynomials.md

@@ -0,0 +1,5 @@
+# Schur polynomials
+
+```@docs
+    schur_polynomial(lambda::Partition{T}, n=sum(lambda)::Int) where T<:Integer
+```

docs/src/Combinatorics/tableaux.md

@@ -0,0 +1,33 @@
+# Tableaux
+
+```@docs
+    Tableau
+```
+
+## Operations
+
+```@docs
+    hook_length
+    hook_lengths
+    shape
+    weight
+    reading_word
+```
+
+## Semistandard tableaux
+
+```@docs
+    is_semistandard
+    semistandard_tableaux
+```
+
+## Standard tableaux
+
+```@docs
+    is_standard
+    standard_tableaux
+    num_standard_tableaux
+    schensted
+    bump!
+```
+

docs/src/DeveloperDocumentation/styleguide.md

@@ -184,6 +184,53 @@ end
 
 However, as always, rules sometimes should be broken.
 
+## Optional arguments for parents of return values
+
+Several objects in Oscar have `parent`s, e.g. polynomials, group elements, ... 
+Whenever a function creates such objects from an input which does not involve 
+the output's parent, the user should have the possibility to pass on this 
+parent as an optional argument. 
+
+Let's see an example. Say, you want to implement the characteristic 
+polynomial of a matrix. You could do it as follows:
+```julia
+  function characteristic_polynomial(A::MatrixElem)
+    kk = base_ring(A)
+    P, x = kk["x"]
+    AP = change_base_ring(P, A)
+    return det(AP - x*one(AP))
+  end
+```
+You can see that the polynomial ring `P`, i.e. the parent of the output, 
+is newly created in the body of the function. In particular, calling this 
+function two times on two different matrices `A` and `B` might produce 
+incompatible polynomials `p = det(A - x*one(A))` and `q = det(B - x*one(B))` 
+with different parents. Then `p + q` will produce an error. 
+
+To solve this, we should have implemented the function differently:
+```julia
+  function characteristic_polynomial(
+      A::MatrixElem;
+      ring::AbstractAlgebra.Ring=(base_ring(A)["t"])[1]
+    )
+    AP = change_base_ring(ring, A)
+    x = first(gens(ring))
+    return det(AP - x*one(AP))
+  end
+
+  function characteristic_polynomial(
+      P::AbstractAlgebra.Ring,
+      A::MatrixElem
+    )
+    coefficient_ring(P) === base_ring(A) || error("coefficient rings incompatible")
+    return characteristic_polynomial(A, ring=P)
+  end
+```
+This allows for two different entry points for the ring `P` of the output: 
+Once as the first argument of a method of `characteristic_polynomial` with 
+an extended signature, and second as an optional keyword argument for `ring` in 
+the original method. This should be the general rule for such implementations 
+within Oscar. 
 
 ## Deprecating functions
 

experimental/Experimental.jl

@@ -25,3 +25,5 @@ include("Schemes/CoherentSheaves.jl")
 include("Schemes/LazyGlueing.jl")
 include("Schemes/CartierDivisor.jl")
 include("Schemes/Auxiliary.jl")
+
+include("JuLie.jl")

experimental/JuLie.jl

@@ -0,0 +1,14 @@
+module JuLie
+
+using ..Oscar
+using Markdown
+import Nemo:libflint
+
+include("JuLie/partitions.jl")
+include("JuLie/schur_polynomials.jl")
+include("JuLie/tableaux.jl")
+
+end
+
+using .JuLie
+export Partition, partitions, ascending_partitions, dominates, conjugate, getindex_safe, num_partitions, schur_polynomial, Tableau, shape, semistandard_tableaux, is_standard, is_semistandard, standard_tableaux, schensted, hook_length, hook_lengths, num_standard_tableaux, reading_word, weight, bump!