Import Multipartition functionality from JuLie

docs/doc.main

@@ -281,6 +281,7 @@
     "Combinatorics/phylogenetic_trees.md",
     "Enumerative combinatorics" => [
       "Combinatorics/EnumerativeCombinatorics/partitions.md",
+			"Combinatorics/EnumerativeCombinatorics/multipartitions.md",
       "Combinatorics/EnumerativeCombinatorics/tableaux.md",
       "Combinatorics/EnumerativeCombinatorics/schur_polynomials.md",
       "Combinatorics/EnumerativeCombinatorics/compositions.md",

docs/oscar_references.bib

@@ -103,6 +103,19 @@ @Article{AZ99
   url           = {https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=6eaea4b5c868c84295a0977ed9fce92d7c960a39}
 }
 
+@InCollection{And08,
+  author        = {Andrews, George E.},
+  title         = {A survey of multipartitions congruences and identities},
+  editor        = {Alladi, Krishnaswarmi},
+  booktitle     = {Surveys in Number Theory},
+  series        = {Developments in Mathematics},
+  volume        = {17},
+  publisher     = {Springer New York},
+  pages         = {1--19},
+  year          = {2008},
+  doi           = {10.1007/978-0-387-78510-3_1}
+}
+
 @Article{BBS02,
   author        = {Bayer, M. and Bruening, A. and Stewart, J.},
   title         = {A Combinatorial Study of Multiplexes and Ordinary Polytopes},
@@ -742,6 +755,14 @@ @Article{Cor21
   doi           = {10.1007/s00029-021-00679-6}
 }
 
+@Article{Cra06,
+  author        = {Craven, D.},
+  title         = {The number of $t$-cores of size $n$},
+  journal       = {unpublished},
+  year          = {2006},
+  url           = {http://web.mat.bham.ac.uk/D.A.Craven/docs/papers/tcores0608.pdf}
+}
+
 @Book{Cut04,
   author        = {Cutkosky, Steven Dale},
   title         = {Resolution of singularities},

docs/src/Combinatorics/EnumerativeCombinatorics/multipartitions.md

@@ -0,0 +1,51 @@
+```@meta
+CurrentModule = Oscar
+DocTestSetup = Oscar.doctestsetup()
+```
+
+# Multipartitions
+
+
+Multipartitions are generalizations of partitions.
+An $r$-component **multipartition** of an integer ``n``
+is an $r$-tuple of partitions $\lambda = (\lambda_1, \lambda_2, \ldots, \lambda_r)$
+where each $\lambda_i$ is a partition of some integer $n_i \geq 0$
+and the $n_i$ sum to $n$.
+For an overview of multipartitions, see [And08](@cite).
+
+A multipartition can be encoded as a 1-dimensional array whose elements are partitions.
+In OSCAR, we provide the parametric type `Multipartition{T}` which is a subtype of `AbstractVector{T}`,
+where `T` can by any subtype of `IntegerUnion`.
+By using smaller integer types when appropriate, this allows performance to be improved.
+
+```@docs
+multipartition
+```
+Because `Multipartition` is a subtype of `AbstractVector`, all functions that can be used for vectors (1-dimensional arrays) can be used for multipartitions as well.
+```jldoctest
+julia> MP = multipartition([[3, 2], [1, 1], [3, 1]])
+Partition{Int64}[[3, 2], [1, 1], [3, 1]]
+
+julia> length(MP)
+3
+
+julia> MP[1]
+[3, 2]
+```
+However, usually, $|\lambda| := n$ is called the **size** of a multipartition $\lambda$.
+In Julia, the function `size` for arrays already exists and returns the *dimension* of an array.
+Instead, one can use the Julia function `sum` to get the sum of the parts.
+```jldoctest
+julia> MP = multipartition([[3, 2], [1, 1], [3, 1]])
+Partition{Int64}[[3, 2], [1, 1], [3, 1]]
+
+julia> sum(MP)
+11
+```
+
+## Generating and counting
+
+```@docs
+multipartitions(::Oscar.IntegerUnion, ::Oscar.IntegerUnion)
+number_of_multipartitions(::Oscar.IntegerUnion, ::Oscar.IntegerUnion)
+```

src/Combinatorics/EnumerativeCombinatorics/EnumerativeCombinatorics.jl

@@ -1,5 +1,6 @@
 include("types.jl")
 include("partitions.jl")
+include("multipartitions.jl")
 include("schur_polynomials.jl")
 include("tableaux.jl")
 include("weak_compositions.jl")

src/Combinatorics/EnumerativeCombinatorics/multipartitions.jl

@@ -0,0 +1,177 @@
+################################################################################
+# Multipartitions.
+#
+# Copyright (C) 2020 Ulrich Thiel, ulthiel.com/math
+#
+# Originally taken from the JuLie [repository](https://github.com/ulthiel/JuLie)
+# by Ulrich Thiel and OSCAR-ified by Morgan Rodgers.
+################################################################################
+
+
+
+
+"""
+    multipartition(mp::Vector{Partition{T}}) where T <: IntegerUnion
+    multipartition(mp::Vector{Vector{T}}) where T <: IntegerUnion
+
+Return the multipartition given by the vector `mp` of integer sequences `mp`
+(which are interpreted as integer partitions) as an object of type
+`Multipartition{T}`.
+Note that a partition must be given by a weakly descending integer sequence.
+
+The element type `T` may be optionally specified, see also the examples below.
+
+# Examples
+```jldoctest
+julia> P = multipartition([[2,1], [], [3,2,1]])
+Partition{Int64}[[2, 1], [], [3, 2, 1]]
+
+julia> sum(P)
+9
+
+julia> P[2]
+Empty partition
+
+julia> P = multipartition(Vector{Int8}[[2,1], [], [3,2,1]])
+Partition{Int8}[[2, 1], [], [3, 2, 1]]
+```
+"""
+function multipartition(mp::Vector{Partition{T}}) where T <: IntegerUnion
+  return Multipartition(mp)
+end
+
+function multipartition(mp::Vector{Vector{T}}) where T <: IntegerUnion
+  return Multipartition([partition(p) for p in mp])
+end
+
+# This is only called when the empty array is part of mp (because then it's
+# "Any" type and not of Integer type).
+function multipartition(mp::Vector{Vector{Any}})
+  return Multipartition([partition(p) for p in mp])
+end
+
+# This is only called when mp is itself an empty array.
+function multipartition(mp::Vector{Any})
+  return Multipartition(Vector{Partition{Int}}(mp))
+end
+
+function Base.show(io::IO, ::MIME"text/plain", MP::Multipartition)
+  print(io, MP.mp)
+end
+
+function Base.size(MP::Multipartition)
+  return size(MP.mp)
+end
+
+function Base.length(MP::Multipartition)
+  return length(MP.mp)
+end
+
+function Base.getindex(MP::Multipartition, i::Int)
+  return getindex(MP.mp,i)
+end
+
+
+"""
+    sum(P::Multipartition{T}) where T<:IntegerUnion
+
+If `P` is a multipartition of the integer n, this function returns n.
+"""
+function Base.sum(MP::Multipartition{T}) where T<:IntegerUnion
+  return sum(sum, MP.mp; init=zero(T))
+end
+
+
+"""
+    multipartitions(n::T, r::IntegerUnion)  where T<:IntegerUnion
+
+A list of all `r`-component multipartitions of `n`, as elements of type Multipartitoon{T}.
+The algorithm is recursive and  based on [`partitions(::IntegerUnion)`](@ref).
+
+# Example
+```jldoctest
+julia> MP = multipartitions(2,2);
+
+julia> first(MP)
+Partition{Int64}[[], [2]]
+
+julia> collect(multipartitions(2,2))
+5-element Vector{Multipartition{Int64}}:
+ Partition{Int64}[[], [2]]
+ Partition{Int64}[[], [1, 1]]
+ Partition{Int64}[[1], [1]]
+ Partition{Int64}[[2], []]
+ Partition{Int64}[[1, 1], []]
+```
+"""
+function multipartitions(n::T, r::IntegerUnion) where T<:IntegerUnion
+  #Argument checking
+  @req n >= 0 "n >= 0 required"
+  @req r >= 0 "r >= 0 required"
+  @req n == 0 || r >= 1 "impossible with r == 0 and n >= 1"
+
+  #This will be the list of multipartitions
+  MP = Multipartition{T}[]
+  n == r == 0 && return MP
+
+  #We will go through all compositions of n into r parts, and for each such #composition, we collect all the partitions for each of the components of
+  #the composition.
+  #We create the compositions here in place for efficiency.
+
+  #recursively produces all Integer Vectors p of length r such that the sum of all the Elements equals n. Then calls recMultipartitions!
+  function recP!(p::Vector{T}, i::T, n::T) #where T<:IntegerUnion
+    if i==length(p) || n==0
+      p[Int(i)] = n
+      recMultipartitions!(fill(Partition(T[]),r), p, T(1))
+    else
+      for j=0:n
+        p[Int(i)] = T(j)
+        recP!(copy(p), T(i+1), T(n-j))
+      end
+    end
+  end
+
+  #recursively produces all multipartitions such that the i-th partition sums up to p[i]
+  function recMultipartitions!(mp::Vector{Partition{T}}, p::Vector{T}, i::T) #where T<:IntegerUnion
+    if i == length(p)
+      for q in partitions(p[Int(i)])
+        mp[Int(i)] = q
+        push!(MP, Multipartition{T}(copy(mp)))
+      end
+    else
+      for q in partitions(p[Int(i)])
+        mp[Int(i)] = q
+        recMultipartitions!(copy(mp), p, T(i+1))
+      end
+    end
+  end
+
+  recP!(zeros(T,r), T(1), n)
+  return (x for x in MP)
+  # return MP
+end
+
+
+@doc raw"""
+    number_of_multipartitions(n::IntegerUnion, k::IntegerUnion)
+
+The number of multipartitions of ``n`` into ``k`` parts is equal to
+```math
+\sum_{a=1}^k {k \choose a} \sum_{\lambda} p(\lambda_1) p(\lambda_2) \cdots p(\lambda_a) \;,
+```
+where the second sum is over all [compositions](@ref Compositions) ``\lambda`` of ``n`` into ``a`` parts. This formula is due to [Cra06; Proof of Lemma 2.4](@cite).
+"""
+function number_of_multipartitions(n::IntegerUnion, k::IntegerUnion)
+
+  # Special cases
+  n == 0 && return ZZ(k)
+
+  z = ZZ(0)
+  for a in 1:k
+    w = sum(lambda -> prod(number_of_partitions, lambda), compositions(n, a), init=ZZ(0))
+    z += binomial(k,a)*w
+  end
+
+  return z
+
+end

src/Combinatorics/EnumerativeCombinatorics/types.jl

@@ -281,6 +281,23 @@ struct PartitionsFixedValues{T<:IntegerUnion}
   end
 end
 
+################################################################################
+#
+#  Multipartition
+#
+################################################################################
+
+@doc raw"""
+    Multipartition{T<:IntegerUnion} <: AbstractVector{Partition{T}}
+
+Multipartitions are implemented as a subtype of 1-dimensional arrays of partitions. You can use smaller integer types to increase performance.
+
+See [`multipartition`](@ref) for the user-facing constructor and an example.
+"""
+struct Multipartition{T<:IntegerUnion} <: AbstractVector{Partition{T}}
+    mp::Vector{Partition{T}}
+end
+
 ################################################################################
 #
 #  Young Tableaux

src/exports.jl

@@ -125,6 +125,7 @@ export ModuleFPElem
 export ModuleFPHom
 export ModuleOrdering
 export MonomialOrdering
+export Multipartition
 export Nemo
 export NormalToricVariety
 export OO
@@ -1170,6 +1171,8 @@ export mul!
 export multi_hilbert_function
 export multi_hilbert_series
 export multi_hilbert_series_reduced
+export multipartition
+export multipartitions
 export multiplication_induced_morphism
 export multiplication_morphism
 export multiplicative_jordan_decomposition
@@ -1241,6 +1244,7 @@ export number_of_factors
 export number_of_generators
 export number_of_groups_with_class_number, has_number_of_groups_with_class_number
 export number_of_moved_points, has_number_of_moved_points, set_number_of_moved_points
+export number_of_multipartitions
 export number_of_partitions
 export number_of_patches
 export number_of_perfect_groups, has_number_of_perfect_groups

test/Combinatorics/EnumerativeCombinatorics/multipartitions.jl

@@ -0,0 +1,22 @@
+@testset "Multipartitions for integer type $T" for T in [Int, ZZRingElem]
+  #constructors
+  @test multipartition([T[3,2], T[1]]) == multipartition([Partition(T[3,2]), Partition(T[1])])
+  @test multipartition([T[3,2], T[]]) == multipartition([Partition(T[3,2]),Partition(T[])])
+
+  # multi-partitions
+  @testset "multipartitions($n, $r)" for n in 0:10, r in 1:5
+    MP = multipartitions(T(n),r)
+
+    @test allunique(MP)
+    @test all(mp -> length(mp) == r, MP)
+    for mp in MP
+      @test sum(mp) == n
+    end
+  end
+
+  #counting
+  @testset "Counting multipartitions($n, $r)" for n in 0:5, r in 1:n+1
+      @test length(multipartitions(T(n),r)) == number_of_multipartitions(T(n),r)
+  end
+
+end