Merge pull request #31 from kalmarek/mk/update_to_PG_0.6

Update to PermutationGroups-0.6

Project.toml

@@ -1,7 +1,7 @@
 name = "Groups"
 uuid = "5d8bd718-bd84-11e8-3b40-ad14f4a32557"
 authors = ["Marek Kaluba <[email protected]>"]
-version = "0.7.8"
+version = "0.8"
 
 [deps]
 GroupsCore = "d5909c97-4eac-4ecc-a3dc-fdd0858a4120"
@@ -14,10 +14,10 @@ Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
-GroupsCore = "0.4"
+GroupsCore = "0.5"
 KnuthBendix = "0.4"
 OrderedCollections = "1"
-PermutationGroups = "0.4"
+PermutationGroups = "0.6"
 StaticArrays = "1"
 julia = "1.6"
 

src/Groups.jl

@@ -27,6 +27,7 @@ include(joinpath("constructions", "constructions.jl"))
 import .Constructions
 
 include("types.jl")
+include("rand.jl")
 include("hashing.jl")
 include("normalform.jl")
 include("autgroups.jl")

src/autgroups.jl

@@ -36,8 +36,8 @@ function Base.:(==)(
         hash(g) != hash(h) && return false
     end
 
-    length(word(g)) > 8 && normalform!(g)
-    length(word(h)) > 8 && normalform!(h)
+    normalform!(g)
+    normalform!(h)
 
     word(g) == word(h) && return true
 
@@ -138,43 +138,47 @@ end
 
 # forward evaluate by substitution
 
-struct LettersMap{T,A}
-    indices_map::Dict{Int,T}
+struct LettersMap{W<:AbstractWord,A}
+    indices_map::Dict{Int,W}
     A::A
 end
 
 function LettersMap(a::FPGroupElement{<:AutomorphismGroup})
     dom = domain(a)
-    @assert all(isone ∘ length ∘ word, dom)
-    A = alphabet(first(dom))
-    first_letters = first.(word.(dom))
-    img = evaluate!(dom, a)
-
-    # (dom[i] → img[i] is a map from domain to images)
-    # we need a map from alphabet indices → (gens, gens⁻¹) → images
-    # here we do it for elements of the domain
-    # (trusting it's a set of generators that define a)
-    @assert length(dom) == length(img)
-
-    indices_map =
-        Dict(A[A[fl]] => word(im) for (fl, im) in zip(first_letters, img))
-    # inverses of generators are dealt lazily in getindex
+    if all(isone ∘ length ∘ word, dom)
+        A = alphabet(first(dom))
+        first_letters = first.(word.(dom))
+        img = evaluate!(dom, a)
+
+        # (dom[i] → img[i] is a map from domain to images)
+        # we need a map from alphabet indices → (gens, gens⁻¹) → images
+        # here we do it for elements of the domain
+        # (trusting it's a set of generators that define a)
+        @assert length(dom) == length(img)
+
+        indices_map =
+            Dict(Int(fl) => word(im) for (fl, im) in zip(first_letters, img))
+        # inverses of generators are dealt lazily in getindex
+    else
+        throw("LettersMap is not implemented for non-generators in domain")
+    end
 
     return LettersMap(indices_map, A)
 end
 
-function Base.getindex(lm::LettersMap, i::Integer)
+function Base.getindex(lm::LettersMap{W}, i::Integer) where {W}
     # here i is an index of an alphabet
     @boundscheck 1 ≤ i ≤ length(lm.A)
 
     if !haskey(lm.indices_map, i)
-        img = if haskey(lm.indices_map, inv(i, lm.A))
-            inv(lm.indices_map[inv(i, lm.A)], lm.A)
+        I = inv(i, lm.A)
+        if haskey(lm.indices_map, I)
+            img = inv(lm.indices_map[I], lm.A)
+            lm.indices_map[i] = img
         else
-            @warn "LetterMap: neither $i nor its inverse has assigned value"
-            one(valtype(lm.indices_map))
+            lm.indices_map[i] = W([i])
+            lm.indices_map[I] = W([I])
         end
-        lm.indices_map[i] = img
     end
     return lm.indices_map[i]
 end
@@ -185,9 +189,10 @@ function (a::FPGroupElement{<:AutomorphismGroup})(g::FPGroupElement)
     return parent(g)(img_w)
 end
 
-evaluate(w::AbstractWord, lm::LettersMap) = evaluate!(one(w), w, lm)
+evaluate(w::AbstractWord, lm::LettersMap) = evaluate!(similar(w), w, lm)
 
 function evaluate!(res::AbstractWord, w::AbstractWord, lm::LettersMap)
+    resize!(res, 0)
     for i in w
         append!(res, lm[i])
     end

src/constructions/direct_power.jl

@@ -59,15 +59,6 @@ end
 
 GroupsCore.ngens(G::DirectPower) = _nfold(G) * ngens(G.group)
 
-function GroupsCore.gens(G::DirectPower, i::Integer)
-    k = ngens(G.group)
-    ci = CartesianIndices((k, _nfold(G)))
-    @boundscheck checkbounds(ci, i)
-    r, c = Tuple(ci[i])
-    tup = ntuple(j -> j == c ? gens(G.group, r) : one(G.group), _nfold(G))
-    return DirectPowerElement(tup, G)
-end
-
 function GroupsCore.gens(G::DirectPower)
     N = _nfold(G)
     S = gens(G.group)
@@ -78,14 +69,6 @@ end
 
 Base.isfinite(G::DirectPower) = isfinite(G.group)
 
-function Base.rand(
-    rng::Random.AbstractRNG,
-    rs::Random.SamplerTrivial{<:DirectPower},
-)
-    G = rs[]
-    return DirectPowerElement(rand(rng, G.group, _nfold(G)), G)
-end
-
 GroupsCore.parent(g::DirectPowerElement) = g.parent
 
 function Base.:(==)(g::DirectPowerElement, h::DirectPowerElement)
@@ -94,20 +77,46 @@ end
 
 Base.hash(g::DirectPowerElement, h::UInt) = hash(g.elts, hash(parent(g), h))
 
-function Base.deepcopy_internal(g::DirectPowerElement, stackdict::IdDict)
-    return DirectPowerElement(
-        Base.deepcopy_internal(g.elts, stackdict),
-        parent(g),
-    )
-end
-
 Base.inv(g::DirectPowerElement) = DirectPowerElement(inv.(g.elts), parent(g))
 
 function Base.:(*)(g::DirectPowerElement, h::DirectPowerElement)
     @assert parent(g) === parent(h)
     return DirectPowerElement(g.elts .* h.elts, parent(g))
 end
 
+# to make sure that parents are never copied i.e.
+# g and deepcopy(g) share their parent
+Base.deepcopy_internal(G::DirectPower, ::IdDict) = G
+
+################## Implementing Group Interface Done!
+
+function GroupsCore.gens(G::DirectPower, i::Integer)
+    k = ngens(G.group)
+    ci = CartesianIndices((k, _nfold(G)))
+    @boundscheck checkbounds(ci, i)
+    r, c = Tuple(ci[i])
+    tup = ntuple(j -> j == c ? gens(G.group, r) : one(G.group), _nfold(G))
+    return DirectPowerElement(tup, G)
+end
+
+# Overloading rand: the PRA of GroupsCore is known for not performing
+# well on direct sums
+function Random.Sampler(
+    RNG::Type{<:Random.AbstractRNG},
+    G::DirectPower,
+    repetition::Random.Repetition = Val(Inf),
+)
+    return Random.SamplerTrivial(G)
+end
+
+function Base.rand(
+    rng::Random.AbstractRNG,
+    rs::Random.SamplerTrivial{<:DirectPower},
+)
+    G = rs[]
+    return DirectPowerElement(rand(rng, G.group, _nfold(G)), G)
+end
+
 function GroupsCore.order(::Type{I}, g::DirectPowerElement) where {I<:Integer}
     return convert(I, reduce(lcm, (order(I, h) for h in g.elts); init = one(I)))
 end
@@ -117,10 +126,13 @@ Base.isone(g::DirectPowerElement) = all(isone, g.elts)
 function Base.show(io::IO, G::DirectPower)
     n = _nfold(G)
     nn = n == 1 ? "1-st" : n == 2 ? "2-nd" : n == 3 ? "3-rd" : "$n-th"
-    return print(io, "Direct $(nn) power of $(G.group)")
+    return print(io, "Direct $(nn) power of ", G.group)
 end
+
 function Base.show(io::IO, g::DirectPowerElement)
-    return print(io, "( ", join(g.elts, ", "), " )")
+    print(io, "( ")
+    join(io, g.elts, ", ")
+    return print(" )")
 end
 
 # convienience:

src/constructions/direct_product.jl

@@ -72,14 +72,6 @@ end
 
 Base.isfinite(G::DirectProduct) = isfinite(G.first) && isfinite(G.last)
 
-function Base.rand(
-    rng::Random.AbstractRNG,
-    rs::Random.SamplerTrivial{<:DirectProduct},
-)
-    G = rs[]
-    return DirectProductElement((rand(rng, G.first), rand(rng, G.last)), G)
-end
-
 GroupsCore.parent(g::DirectProductElement) = g.parent
 
 function Base.:(==)(g::DirectProductElement, h::DirectProductElement)
@@ -88,13 +80,6 @@ end
 
 Base.hash(g::DirectProductElement, h::UInt) = hash(g.elts, hash(parent(g), h))
 
-function Base.deepcopy_internal(g::DirectProductElement, stackdict::IdDict)
-    return DirectProductElement(
-        Base.deepcopy_internal(g.elts, stackdict),
-        parent(g),
-    )
-end
-
 function Base.inv(g::DirectProductElement)
     return DirectProductElement(inv.(g.elts), parent(g))
 end
@@ -104,17 +89,44 @@ function Base.:(*)(g::DirectProductElement, h::DirectProductElement)
     return DirectProductElement(g.elts .* h.elts, parent(g))
 end
 
+# to make sure that parents are never copied i.e.
+# g and deepcopy(g) share their parent
+Base.deepcopy_internal(G::DirectProduct, ::IdDict) = G
+
+################## Implementing Group Interface Done!
+
+# Overloading rand: the PRA of GroupsCore is known for not performing
+# well on direct sums
+function Random.Sampler(
+    RNG::Type{<:Random.AbstractRNG},
+    G::DirectProduct,
+    repetition::Random.Repetition = Val(Inf),
+)
+    return Random.SamplerTrivial(G)
+end
+
+function Base.rand(
+    rng::Random.AbstractRNG,
+    rs::Random.SamplerTrivial{<:DirectProduct},
+)
+    G = rs[]
+    return DirectProductElement((rand(rng, G.first), rand(rng, G.last)), G)
+end
+
 function GroupsCore.order(::Type{I}, g::DirectProductElement) where {I<:Integer}
     return convert(I, lcm(order(I, first(g.elts)), order(I, last(g.elts))))
 end
 
 Base.isone(g::DirectProductElement) = all(isone, g.elts)
 
 function Base.show(io::IO, G::DirectProduct)
-    return print(io, "Direct product of $(G.first) and $(G.last)")
+    return print(io, "Direct product of ", G.first, " and ", G.last)
 end
+
 function Base.show(io::IO, g::DirectProductElement)
-    return print(io, "( $(join(g.elts, ",")) )")
+    print(io, "( ")
+    join(io, g.elts, ", ")
+    return print(io, " )")
 end
 
 # convienience: