Merge pull request #22 from kalmarek/enh/MatrixGroups

Enh/matrix groups

.github/workflows/runtests.yml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       matrix:
         version:
-          - '1.3'
+          - '1.6'
           - '1'
           - 'nightly'
         os:

Project.toml

@@ -1,29 +1,31 @@
 name = "Groups"
 uuid = "5d8bd718-bd84-11e8-3b40-ad14f4a32557"
 authors = ["Marek Kaluba <kalmar@amu.edu.pl>"]
-version = "0.7.2"
+version = "0.7.3"
 
 [deps]
+Folds = "41a02a25-b8f0-4f67-bc48-60067656b558"
 GroupsCore = "d5909c97-4eac-4ecc-a3dc-fdd0858a4120"
 KnuthBendix = "c2604015-7b3d-4a30-8a26-9074551ec60a"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
 OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
-Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-ThreadsX = "ac1d9e8a-700a-412c-b207-f0111f4b6c0d"
+PermutationGroups = "8bc5a954-2dfc-11e9-10e6-cd969bffa420"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
-AbstractAlgebra = "0.22"
+Folds = "0.2.7"
 GroupsCore = "0.4"
 KnuthBendix = "0.3"
 OrderedCollections = "1"
 PermutationGroups = "0.3"
-ThreadsX = "0.1"
-julia = "1.3"
+StaticArrays = "1"
+julia = "1.6"
 
 [extras]
-AbstractAlgebra = "c3fe647b-3220-5bb0-a1ea-a7954cac585d"
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 PermutationGroups = "8bc5a954-2dfc-11e9-10e6-cd969bffa420"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "BenchmarkTools", "AbstractAlgebra", "PermutationGroups"]
+test = ["Test", "BenchmarkTools"]

src/Groups.jl

@@ -1,24 +1,40 @@
 module Groups
 
+import Folds
+import Logging
+
 using GroupsCore
-using ThreadsX
-import KnuthBendix
-import KnuthBendix: AbstractWord, Alphabet, Word
-import KnuthBendix: alphabet
-import Random
+import GroupsCore.Random
 
 import OrderedCollections: OrderedSet
 
-export Alphabet, AutomorphismGroup, FreeGroup, FreeGroup, FPGroup, FPGroupElement, SpecialAutomorphismGroup
+import KnuthBendix
+import KnuthBendix: AbstractWord, Alphabet, Word
+import KnuthBendix: alphabet
+
+export MatrixGroups
+
+export Alphabet, AutomorphismGroup, FreeGroup, FreeGroup, FPGroup, FPGroupElement, SpecialAutomorphismGroup, Homomorphism
+
 export alphabet, evaluate, word, gens
 
+# general constructions
+include(joinpath("constructions", "constructions.jl"))
+import .Constructions
+
 include("types.jl")
 include("hashing.jl")
 include("normalform.jl")
 include("autgroups.jl")
+include("homomorphisms.jl")
 
-include("groups/sautFn.jl")
-include("groups/mcg.jl")
+include("aut_groups/sautFn.jl")
+include("aut_groups/mcg.jl")
+
+include("matrix_groups/MatrixGroups.jl")
+using .MatrixGroups
+
+include("abelianize.jl")
 
 include("wl_ball.jl")
 end # of module Groups

src/abelianize.jl

@@ -0,0 +1,69 @@
+function _abelianize(
+    i::Integer,
+    source::AutomorphismGroup{<:FreeGroup},
+    target::MatrixGroups.SpecialLinearGroup{N, T}) where {N, T}
+    n = ngens(object(source))
+    @assert n == N
+    aut = alphabet(source)[i]
+    if aut isa Transvection
+        # we change (i,j) to (j, i) to be consistent with the action:
+        # Automorphisms act on the right which corresponds to action on
+        # the columns in the matrix case
+        eij = MatrixGroups.ElementaryMatrix{N}(
+                aut.j,
+                aut.i,
+                ifelse(aut.inv, -one(T), one(T))
+            )
+        k = alphabet(target)[eij]
+        return word_type(target)([k])
+    else
+        throw("unexpected automorphism symbol: $(typeof(aut))")
+    end
+end
+
+function _abelianize(
+    i::Integer,
+    source::AutomorphismGroup{<:Groups.SurfaceGroup},
+    target::MatrixGroups.SpecialLinearGroup{N, T}) where {N, T}
+    n = ngens(Groups.object(source))
+    @assert n == N
+    g = alphabet(source)[i].autFn_word
+    result = one(target)
+    for l in word(g)
+        append!(word(result), _abelianize(l, parent(g), target))
+    end
+
+    return word(result)
+end
+
+function Groups._abelianize(
+    i::Integer,
+    source::AutomorphismGroup{<:Groups.SurfaceGroup},
+    target::MatrixGroups.SymplecticGroup{N, T}
+) where {N, T}
+    @assert iseven(N)
+    As = alphabet(source)
+    At = alphabet(target)
+
+    SlN = let genus = Groups.genus(Groups.object(source))
+        @assert 2genus == N
+        MatrixGroups.SpecialLinearGroup{2genus}(T)
+    end
+
+    ab = Groups.Homomorphism(Groups._abelianize, source, SlN, check=false)
+
+    matrix_spn_map = let S = gens(target)
+        Dict(MatrixGroups.matrix_repr(g)=> word(g) for g in union(S, inv.(S)))
+    end
+
+    # renumeration:
+    # (f1, f2, f3, f4, f5, f6) = (a₁, a₂, a₃, b₁, b₂, b₃) →
+    # → (b₃, a₃, b₂, a₂, b₁, a₁)
+    # hence p = [6, 4, 2, 5, 3, 1]
+    p = [reverse(2:2:N); reverse(1:2:N)]
+
+    g = source([i])
+    Mg = MatrixGroups.matrix_repr(ab(g))[p,p]
+
+    return matrix_spn_map[Mg]
+end

src/aut_groups/sautFn.jl

@@ -10,7 +10,10 @@ function SpecialAutomorphismGroup(F::FreeGroup; ordering = KnuthBendix.LenLex, k
     maxrules = 1000*n
 
     rws = KnuthBendix.RewritingSystem(rels, ordering(A))
-    KnuthBendix.knuthbendix!(rws; maxrules=maxrules, kwargs...)
+    Logging.with_logger(Logging.NullLogger()) do
+        # the rws is not confluent, let's suppress warning about it
+        KnuthBendix.knuthbendix!(rws; maxrules=maxrules, kwargs...)
+    end
     return AutomorphismGroup(F, S, rws, ntuple(i -> gens(F, i), n))
 end
 

src/constructions/constructions.jl

@@ -0,0 +1,10 @@
+module Constructions
+
+using GroupsCore
+import GroupsCore.Random
+
+include("direct_product.jl")
+include("direct_power.jl")
+include("wreath_product.jl")
+
+end # of module Constructions

src/constructions/direct_power.jl

@@ -0,0 +1,112 @@
+struct DirectPower{Gr,N,GEl<:GroupsCore.GroupElement} <: GroupsCore.Group
+    group::Gr
+
+    function DirectPower{N}(G::GroupsCore.Group) where {N}
+        @assert N > 1
+        return new{typeof(G),N,eltype(G)}(G)
+    end
+end
+
+struct DirectPowerElement{GEl,N,Gr<:GroupsCore.Group} <: GroupsCore.GroupElement
+    elts::NTuple{N,GEl}
+    parent::DirectPower{Gr,N,GEl}
+end
+
+DirectPowerElement(
+    elts::AbstractVector{<:GroupsCore.GroupElement},
+    G::DirectPower,
+) = DirectPowerElement(ntuple(i -> elts[i], _nfold(G)), G)
+
+_nfold(::DirectPower{Gr,N}) where {Gr,N} = N
+
+Base.one(G::DirectPower) =
+    DirectPowerElement(ntuple(_ -> one(G.group), _nfold(G)), G)
+
+Base.eltype(::Type{<:DirectPower{Gr,N,GEl}}) where {Gr,N,GEl} =
+    DirectPowerElement{GEl,N,Gr}
+
+function Base.iterate(G::DirectPower)
+    itr = Iterators.ProductIterator(ntuple(i -> G.group, _nfold(G)))
+    res = iterate(itr)
+    @assert res !== nothing
+    elt = DirectPowerElement(first(res), G)
+    return elt, (iterator = itr, state = last(res))
+end
+
+function Base.iterate(G::DirectPower, state)
+    itr, st = state.iterator, state.state
+    res = iterate(itr, st)
+    res === nothing && return nothing
+    elt = DirectPowerElement(first(res), G)
+    return elt, (iterator = itr, state = last(res))
+end
+
+function Base.IteratorSize(::Type{<:DirectPower{Gr,N}}) where {Gr,N}
+    Base.IteratorSize(Gr) isa Base.HasLength && return Base.HasShape{N}()
+    Base.IteratorSize(Gr) isa Base.HasShape && return Base.HasShape{N}()
+    return Base.IteratorSize(Gr)
+end
+
+Base.size(G::DirectPower) = ntuple(_ -> length(G.group), _nfold(G))
+
+GroupsCore.order(::Type{I}, G::DirectPower) where {I<:Integer} =
+    convert(I, order(I, G.group)^_nfold(G))
+
+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)
+    tups = [ntuple(j->(i == j ? s : one(s)), N) for i in 1:N for s in S]
+
+    return [DirectPowerElement(elts, G) for elts in tups]
+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
+
+Base.:(==)(g::DirectPowerElement, h::DirectPowerElement) =
+    (parent(g) === parent(h) && g.elts == h.elts)
+
+Base.hash(g::DirectPowerElement, h::UInt) = hash(g.elts, hash(parent(g), h))
+
+Base.deepcopy_internal(g::DirectPowerElement, stackdict::IdDict) =
+    DirectPowerElement(Base.deepcopy_internal(g.elts, stackdict), parent(g))
+
+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
+
+GroupsCore.order(::Type{I}, g::DirectPowerElement) where {I<:Integer} =
+    convert(I, reduce(lcm, (order(I, h) for h in g.elts), init = one(I)))
+
+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"
+    print(io, "Direct $(nn) power of $(G.group)")
+end
+Base.show(io::IO, g::DirectPowerElement) =
+    print(io, "( ", join(g.elts, ", "), " )")

src/constructions/direct_product.jl

@@ -0,0 +1,102 @@
+struct DirectProduct{Gt,Ht,GEl,HEl} <: GroupsCore.Group
+    first::Gt
+    last::Ht
+
+    function DirectProduct(G::GroupsCore.Group, H::GroupsCore.Group)
+        return new{typeof(G),typeof(H),eltype(G),eltype(H)}(G, H)
+    end
+end
+
+struct DirectProductElement{GEl,HEl,Gt,Ht} <: GroupsCore.GroupElement
+    elts::Tuple{GEl,HEl}
+    parent::DirectProduct{Gt,Ht,GEl,HEl}
+end
+
+DirectProductElement(g, h, G::DirectProduct) = DirectProduct((g, h), G)
+
+Base.one(G::DirectProduct) =
+    DirectProductElement((one(G.first), one(G.last)), G)
+
+Base.eltype(::Type{<:DirectProduct{Gt,Ht,GEl,HEl}}) where {Gt,Ht,GEl,HEl} =
+    DirectProductElement{GEl,HEl,Gt,Ht}
+
+function Base.iterate(G::DirectProduct)
+    itr = Iterators.product(G.first, G.last)
+    res = iterate(itr)
+    @assert res !== nothing
+    elt = DirectProductElement(first(res), G)
+    return elt, (iterator = itr, state = last(res))
+end
+
+function Base.iterate(G::DirectProduct, state)
+    itr, st = state.iterator, state.state
+    res = iterate(itr, st)
+    res === nothing && return nothing
+    elt = DirectProductElement(first(res), G)
+    return elt, (iterator = itr, state = last(res))
+end
+
+function Base.IteratorSize(::Type{<:DirectProduct{Gt,Ht}}) where {Gt,Ht}
+    Gi = Base.IteratorSize(Gt)
+    Hi = Base.IteratorSize(Ht)
+    if Gi isa Base.IsInfinite || Hi isa Base.IsInfinite
+        return Base.IsInfinite()
+    elseif Gi isa Base.SizeUnknown || Hi isa Base.SizeUnknown
+        return Base.SizeUnknown()
+    else
+        return Base.HasShape{2}()
+    end
+end
+
+Base.size(G::DirectProduct) = (length(G.first), length(G.last))
+
+GroupsCore.order(::Type{I}, G::DirectProduct) where {I<:Integer} =
+    convert(I, order(I, G.first) * order(I, G.last))
+
+GroupsCore.ngens(G::DirectProduct) = ngens(G.first) + ngens(G.last)
+
+function GroupsCore.gens(G::DirectProduct)
+    gens_first = [DirectProductElement((g, one(G.last)), G) for g in gens(G.first)]
+
+    gens_last = [DirectProductElement((one(G.first), g), G) for g in gens(G.last)]
+
+    return [gens_first; gens_last]
+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
+
+Base.:(==)(g::DirectProductElement, h::DirectProductElement) =
+    (parent(g) === parent(h) && g.elts == h.elts)
+
+Base.hash(g::DirectProductElement, h::UInt) = hash(g.elts, hash(parent(g), h))
+
+Base.deepcopy_internal(g::DirectProductElement, stackdict::IdDict) =
+    DirectProductElement(Base.deepcopy_internal(g.elts, stackdict), parent(g))
+
+Base.inv(g::DirectProductElement) =
+    DirectProductElement(inv.(g.elts), parent(g))
+
+function Base.:(*)(g::DirectProductElement, h::DirectProductElement)
+    @assert parent(g) === parent(h)
+    return DirectProductElement(g.elts .* h.elts, parent(g))
+end
+
+GroupsCore.order(::Type{I}, g::DirectProductElement) where {I<:Integer} =
+    convert(I, lcm(order(I, first(g.elts)), order(I, last(g.elts))))
+
+Base.isone(g::DirectProductElement) = all(isone, g.elts)
+
+Base.show(io::IO, G::DirectProduct) =
+    print(io, "Direct product of $(G.first) and $(G.last)")
+Base.show(io::IO, g::DirectProductElement) =
+    print(io, "( $(join(g.elts, ",")) )")

src/constructions/wreath_product.jl

@@ -0,0 +1,136 @@
+import PermutationGroups: AbstractPermutationGroup, AbstractPerm, degree, SymmetricGroup
+
+"""
+    WreathProduct(G::Group, P::AbstractPermutationGroup) <: Group
+Return the wreath product of a group `G` by permutation group `P`, usually
+written as `G ≀ P`.
+
+As set `G ≀ P` is the same as `Gᵈ × P` and the group can be understood as a
+semi-direct product of `P` acting on `d`-fold cartesian product of `G` by
+permuting coordinates. To be more precise, the multiplication inside wreath
+product is defined as
+>  `(n, σ) * (m, τ) = (n*(m^σ), σ*τ)`
+where `m^σ` denotes the action (from the right) of the permutation `σ` on
+`d`-tuples of elements from `G`.
+"""
+struct WreathProduct{DP<:DirectPower,PGr<:AbstractPermutationGroup} <:
+       GroupsCore.Group
+    N::DP
+    P::PGr
+
+    function WreathProduct(G::Group, P::AbstractPermutationGroup)
+        N = DirectPower{degree(P)}(G)
+        return new{typeof(N),typeof(P)}(N, P)
+    end
+end
+
+struct WreathProductElement{
+    DPEl<:DirectPowerElement,
+    PEl<:AbstractPerm,
+    Wr<:WreathProduct,
+} <: GroupsCore.GroupElement
+    n::DPEl
+    p::PEl
+    parent::Wr
+
+    function WreathProductElement(
+        n::DirectPowerElement,
+        p::AbstractPerm,
+        W::WreathProduct,
+    )
+        new{typeof(n),typeof(p),typeof(W)}(n, p, W)
+    end
+end
+
+Base.one(W::WreathProduct) = WreathProductElement(one(W.N), one(W.P), W)
+
+Base.eltype(::Type{<:WreathProduct{DP,PGr}}) where {DP,PGr} =
+    WreathProductElement{eltype(DP),eltype(PGr),WreathProduct{DP,PGr}}
+
+function Base.iterate(G::WreathProduct)
+    itr = Iterators.product(G.N, G.P)
+    res = iterate(itr)
+    @assert res !== nothing
+    elt = WreathProductElement(first(res)..., G)
+    return elt, (iterator = itr, state = last(res))
+end
+
+function Base.iterate(G::WreathProduct, state)
+    itr, st = state.iterator, state.state
+    res = iterate(itr, st)
+    res === nothing && return nothing
+    elt = WreathProductElement(first(res)..., G)
+    return elt, (iterator = itr, state = last(res))
+end
+
+function Base.IteratorSize(::Type{<:WreathProduct{DP,PGr}}) where {DP,PGr}
+    dpI = Base.IteratorSize(DP)
+    pgI = Base.IteratorSize(PGr)
+
+    if dpI isa Base.IsInfinite || pgI isa Base.IsInfinite
+        return Base.IsInfinite()
+    elseif dpI isa Base.SizeUnknown || pgI isa Base.SizeUnknown
+        return Base.SizeUnknown()
+    else
+        return Base.HasShape{2}()
+    end
+end
+
+Base.size(G::WreathProduct) = (length(G.N), length(G.P))
+
+GroupsCore.order(::Type{I}, G::WreathProduct) where {I<:Integer} =
+    convert(I, order(I, G.N) * order(I, G.P))
+
+function GroupsCore.gens(G::WreathProduct)
+    N_gens = [WreathProductElement(n, one(G.P), G) for n in gens(G.N)]
+    P_gens = [WreathProductElement(one(G.N), p, G) for p in gens(G.P)]
+    return [N_gens; P_gens]
+end
+
+Base.isfinite(G::WreathProduct) = isfinite(G.N) && isfinite(G.P)
+
+function Base.rand(
+    rng::Random.AbstractRNG,
+    rs::Random.SamplerTrivial{<:WreathProduct},
+)
+
+    G = rs[]
+    return WreathProductElement(rand(rng, G.N), rand(rng, G.P), G)
+end
+
+GroupsCore.parent(g::WreathProductElement) = g.parent
+
+Base.:(==)(g::WreathProductElement, h::WreathProductElement) =
+    parent(g) === parent(h) && g.n == h.n && g.p == h.p
+
+Base.hash(g::WreathProductElement, h::UInt) =
+    hash(g.n, hash(g.p, hash(g.parent, h)))
+
+function Base.deepcopy_internal(g::WreathProductElement, stackdict::IdDict)
+    return WreathProductElement(
+        Base.deepcopy_internal(g.n, stackdict),
+        Base.deepcopy_internal(g.p, stackdict),
+        parent(g),
+    )
+end
+
+_act(p::AbstractPerm, n::DirectPowerElement) =
+    DirectPowerElement(n.elts^p, parent(n))
+
+function Base.inv(g::WreathProductElement)
+    pinv = inv(g.p)
+    return WreathProductElement(_act(pinv, inv(g.n)), pinv, parent(g))
+end
+
+function Base.:(*)(g::WreathProductElement, h::WreathProductElement)
+    @assert parent(g) === parent(h)
+    return WreathProductElement(g.n * _act(g.p, h.n), g.p * h.p, parent(g))
+end
+
+Base.isone(g::WreathProductElement) = isone(g.n) && isone(g.p)
+
+Base.show(io::IO, G::WreathProduct) =
+    print(io, "Wreath product of $(G.N.group) by $(G.P)")
+Base.show(io::IO, g::WreathProductElement) = print(io, "( $(g.n)≀$(g.p) )")
+
+Base.copy(g::WreathProductElement) = WreathProductElement(g.n, g.p, parent(g))

src/homomorphisms.jl

@@ -0,0 +1,114 @@
+"""
+    Homomorphism(f, G::AbstractFPGroup, H::AbstractFPGroup[, check=true])
+Struct representing homomorphism map from `G` to `H` given by map `f`.
+
+To define `h = Homomorphism(f, G, H)` function (or just callable) `f` must
+implement method `f(i::Integer, source, target)::AbstractWord` with the
+following meaning. Suppose that word `w = Word([i])` consists of a single
+letter in the `alphabet` of `source` (usually it means that in `G` it
+represents a generator or its inverse). Then `f(i, G, H)` must return the
+**word** representing the image in `H` of `G(w)` under the homomorphism.
+
+In more mathematical terms it means that if `h(G(w)) == h`, then
+`f(i, G, H) == word(h)`.
+
+Images of both `AbstractWord`s and elements of `G` can be obtained by simply
+calling `h(w)`, or `h(g)`.
+
+If `check=true` then the correctness of the definition of `h` will be performed
+when creating the homomorphism.
+
+!!! note
+    `f(i, G, H)` must be implemented for all letters in the alphabet of `G`,
+    not only for those `i` which represent `gens(G)`. Function `f` will be
+    evaluated exactly once per letter of `alphabet(G)` and the results will be
+    cached.
+
+# Examples
+```julia
+julia> F₂ = FreeGroup(2)
+free group on 2 generators
+
+julia> g,h = gens(F₂)
+2-element Vector{FPGroupElement{FreeGroup{Symbol, KnuthBendix.LenLex{Symbol}}, …}}:
+ f1
+ f2
+
+julia> ℤ² = FPGroup(F₂, [g*h => h*g])
+Finitely presented group generated by:
+        { f1  f2 },
+subject to relations:
+ f1*f2 => f2*f1
+
+julia> hom = Groups.Homomorphism(
+           (i, G, H) -> Groups.word_type(H)([i]),
+           F₂,
+           ℤ²
+       )
+Homomorphism
+ from : free group on 2 generators
+ to   : ⟨ f1  f2 |
+          f1*f2 => f2*f1 ⟩
+
+julia> hom(g*h*inv(g))
+f2
+
+julia> hom(g*h*inv(g)) == hom(h)
+true
+```
+
+"""
+struct Homomorphism{Gr1, Gr2, I, W}
+    gens_images::Dict{I, W}
+    source::Gr1
+    target::Gr2
+
+    function Homomorphism(
+        f,
+        source::AbstractFPGroup,
+        target::AbstractFPGroup;
+        check=true
+    )
+        A = alphabet(source)
+        dct = Dict(i=>convert(word_type(target), f(i, source, target))
+            for i in 1:length(A))
+        I = eltype(word_type(source))
+        W = word_type(target)
+        hom = new{typeof(source), typeof(target), I, W}(dct, source, target)
+
+        if check
+            @assert hom(one(source)) == one(target)
+            for x in gens(source)
+
+                @assert hom(x^-1) == hom(x)^-1
+
+                for y in gens(source)
+                    @assert hom(x*y) == hom(x)*hom(y)
+                    @assert hom(x*y)^-1 == hom(y^-1)*hom(x^-1)
+                end
+            end
+            for (lhs, rhs) in relations(source)
+                relator = lhs*inv(alphabet(source), rhs)
+                im_r = hom.target(hom(relator))
+                @assert isone(im_r) "Map does not define a homomorphism: h($relator) = $(im_r) ≠ $(one(target))."
+            end
+        end
+        return hom
+    end
+end
+
+function (h::Homomorphism)(w::AbstractWord)
+    result = one(word_type(h.target)) # Word
+    for l in w
+        append!(result, h.gens_images[l])
+    end
+    return result
+end
+
+function (h::Homomorphism)(g::AbstractFPGroupElement)
+    @assert parent(g) === h.source
+    w = h(word(g))
+    return h.target(w)
+end
+
+Base.show(io::IO, h::Homomorphism) = print(io, "Homomorphism\n from : $(h.source)\n to   : $(h.target)")

src/matrix_groups/MatrixGroups.jl

@@ -0,0 +1,19 @@
+module MatrixGroups
+
+import LinearAlgebra # Identity matrix
+
+using StaticArrays
+
+using GroupsCore
+import GroupsCore.Random # GroupsCore rand
+using ..Groups
+using Groups.KnuthBendix
+
+export SpecialLinearGroup, SymplecticGroup
+
+include("abstract.jl")
+
+include("SLn.jl")
+include("Spn.jl")
+
+end # module

src/matrix_groups/SLn.jl

@@ -0,0 +1,42 @@
+include("eltary_matrices.jl")
+
+struct SpecialLinearGroup{N, T, R, A, S} <: MatrixGroup{N,T}
+    base_ring::R
+    alphabet::A
+    gens::S
+
+    function SpecialLinearGroup{N}(base_ring) where N
+        S = [ElementaryMatrix{N}(i,j, one(base_ring)) for i in 1:N for j in 1:N if i≠j]
+        alphabet = Alphabet(S)
+
+        return new{
+            N,
+            eltype(base_ring),
+            typeof(base_ring),
+            typeof(alphabet),
+            typeof(S)
+        }(base_ring, alphabet, S)
+    end
+end
+
+GroupsCore.ngens(SL::SpecialLinearGroup{N}) where N = N^2 - N
+
+Base.show(io::IO, SL::SpecialLinearGroup{N, T}) where {N, T} =
+    print(io, "special linear group of $N×$N matrices over $T")
+
+function Base.show(
+    io::IO,
+    ::MIME"text/plain",
+    sl::Groups.AbstractFPGroupElement{<:SpecialLinearGroup{N}}
+) where N
+
+    Groups.normalform!(sl)
+
+    print(io, "SL{$N,$(eltype(sl))} matrix: ")
+    KnuthBendix.print_repr(io, word(sl), alphabet(sl))
+    println(io)
+    Base.print_array(io, matrix_repr(sl))
+end
+
+Base.show(io::IO, sl::Groups.AbstractFPGroupElement{<:SpecialLinearGroup}) =
+    KnuthBendix.print_repr(io, word(sl), alphabet(sl))

src/matrix_groups/Spn.jl

@@ -0,0 +1,70 @@
+include("eltary_symplectic.jl")
+
+struct SymplecticGroup{N, T, R, A, S} <: MatrixGroup{N,T}
+    base_ring::R
+    alphabet::A
+    gens::S
+
+    function SymplecticGroup{N}(base_ring) where N
+        S = symplectic_gens(N, eltype(base_ring))
+        alphabet = Alphabet(S)
+
+        return new{
+            N,
+            eltype(base_ring),
+            typeof(base_ring),
+            typeof(alphabet),
+            typeof(S)
+        }(base_ring, alphabet, S)
+    end
+end
+
+GroupsCore.ngens(Sp::SymplecticGroup) = length(Sp.gens)
+
+Base.show(io::IO, ::SymplecticGroup{N}) where N = print(io, "group of $N×$N symplectic matrices")
+
+function Base.show(
+    io::IO,
+    ::MIME"text/plain",
+    sp::Groups.AbstractFPGroupElement{<:SymplecticGroup{N}}
+) where {N}
+    Groups.normalform!(sp)
+    print(io, "$N×$N symplectic matrix: ")
+    KnuthBendix.print_repr(io, word(sp), alphabet(sp))
+    println(io)
+    Base.print_array(io, matrix_repr(sp))
+end
+
+_offdiag_idcs(n) = ((i,j) for i in 1:n for j in 1:n if i ≠ j)
+
+function symplectic_gens(N, T=Int8)
+    iseven(N) || throw(ArgumentError("N needs to be even!"))
+    n = N÷2
+
+    a_ijs = [ElementarySymplectic{N}(:A, i,j, one(T)) for (i,j) in _offdiag_idcs(n)]
+    b_is =  [ElementarySymplectic{N}(:B, n+i,i, one(T)) for i in 1:n]
+    c_ijs = [ElementarySymplectic{N}(:B, n+i,j, one(T)) for (i,j) in _offdiag_idcs(n)]
+
+    S = [a_ijs; b_is; c_ijs]
+
+    S = [S; transpose.(S)]
+
+    return unique(S)
+end
+
+function _std_symplectic_form(m::AbstractMatrix)
+    r,c = size(m)
+    r == c || return false
+    iseven(r) || return false
+
+    n = r÷2
+    𝕆 = zeros(eltype(m), n, n)
+    𝕀 = one(eltype(m))*LinearAlgebra.I
+    Ω = [𝕆 -𝕀
+         𝕀  𝕆]
+    return Ω
+end
+
+function issymplectic(mat::M, Ω = _std_symplectic_form(mat)) where M <: AbstractMatrix
+    return Ω == transpose(mat) * Ω * mat
+end

src/matrix_groups/abstract.jl

@@ -0,0 +1,40 @@
+abstract type MatrixGroup{N, T} <: Groups.AbstractFPGroup end
+const MatrixGroupElement{N, T} = Groups.AbstractFPGroupElement{<:MatrixGroup{N, T}}
+
+Base.isone(g::MatrixGroupElement{N, T}) where {N, T} =
+    isone(word(g)) || matrix_repr(g) == LinearAlgebra.I
+
+function Base.:(==)(m1::M1, m2::M2) where {M1<:MatrixGroupElement, M2<:MatrixGroupElement}
+    parent(m1) === parent(m2) || return false
+    word(m1) == word(m2) && return true
+    return matrix_repr(m1) == matrix_repr(m2)
+end
+
+Base.size(m::MatrixGroupElement{N}) where N = (N, N)
+Base.eltype(m::MatrixGroupElement{N, T}) where {N, T} = T
+
+# three structural assumptions about matrix groups
+Groups.word(sl::MatrixGroupElement) = sl.word
+Base.parent(sl::MatrixGroupElement) = sl.parent
+Groups.alphabet(M::MatrixGroup) = M.alphabet
+Groups.rewriting(M::MatrixGroup) = alphabet(M)
+
+Base.hash(sl::MatrixGroupElement, h::UInt) =
+    hash(matrix_repr(sl), hash(parent(sl), h))
+
+function matrix_repr(m::MatrixGroupElement{N, T}) where {N, T}
+    if isone(word(m))
+        return StaticArrays.SMatrix{N, N, T}(LinearAlgebra.I)
+    end
+    A = alphabet(parent(m))
+    return prod(matrix_repr(A[l]) for l in word(m))
+end
+
+function Base.rand(
+    rng::Random.AbstractRNG,
+    rs::Random.SamplerTrivial{<:MatrixGroup},
+    )
+    Mgroup = rs[]
+    S = gens(Mgroup)
+    return prod(g -> rand(Bool) ? g : inv(g), rand(S, rand(1:30)))
+end

src/matrix_groups/eltary_matrices.jl

@@ -0,0 +1,28 @@
+struct ElementaryMatrix{N, T} <: Groups.GSymbol
+    i::Int
+    j::Int
+    val::T
+    ElementaryMatrix{N}(i, j, val=1) where N =
+        (@assert i≠j; new{N, typeof(val)}(i, j, val))
+end
+
+function Base.show(io::IO, e::ElementaryMatrix)
+    print(io, 'E', Groups.subscriptify(e.i), Groups.subscriptify(e.j))
+    !isone(e.val) && print(io, "^$(e.val)")
+end
+
+Base.:(==)(e::ElementaryMatrix{N}, f::ElementaryMatrix{N}) where N =
+    e.i == f.i && e.j == f.j && e.val == f.val
+
+Base.hash(e::ElementaryMatrix, h::UInt) =
+    hash(typeof(e), hash((e.i, e.j, e.val), h))
+
+Base.inv(e::ElementaryMatrix{N}) where N =
+    ElementaryMatrix{N}(e.i, e.j, -e.val)
+
+function matrix_repr(e::ElementaryMatrix{N, T}) where {N, T}
+    m = StaticArrays.MMatrix{N, N, T}(LinearAlgebra.I)
+    m[e.i, e.j] = e.val
+    x = StaticArrays.SMatrix{N, N}(m)
+    return x
+end

src/matrix_groups/eltary_symplectic.jl

@@ -0,0 +1,76 @@
+struct ElementarySymplectic{N, T} <: Groups.GSymbol
+    symbol::Symbol
+    i::Int
+    j::Int
+    val::T
+    function ElementarySymplectic{N}(s::Symbol, i::Integer, j::Integer, val=1) where N
+        @assert s ∈ (:A, :B)
+        @assert iseven(N)
+        n = N÷2
+        if s === :A
+            @assert 1 ≤ i ≤ n && 1 ≤ j ≤ n && i ≠ j
+        elseif s === :B
+            @assert xor(1 ≤ i ≤ n, 1 ≤ j ≤ n) && xor(n < i ≤ N, n < j ≤ N)
+        end
+        return new{N, typeof(val)}(s, i, j, val)
+    end
+end
+
+function Base.show(io::IO, s::ElementarySymplectic)
+    i, j = Groups.subscriptify(s.i), Groups.subscriptify(s.j)
+    print(io, s.symbol, i, j)
+    !isone(s.val) && print(io, "^$(s.val)")
+end
+
+_ind(s::ElementarySymplectic{N}) where N = (s.i, s.j)
+_local_ind(N_half::Integer, i::Integer) = ifelse(i<=N_half, i, i-N_half)
+function _dual_ind(s::ElementarySymplectic{N}) where N
+    if s.symbol === :A && return _ind(s)
+    else#if s.symbol === :B
+        return _dual_ind(N÷2, s.i, s.j)
+    end
+end
+
+function _dual_ind(N_half, i, j)
+    @assert i <= N_half < j || j <= N_half < i
+    if i <= N_half # && j > N_half
+        i, j = j - N_half, i + N_half
+    else
+        i, j = j + N_half, i - N_half
+    end
+    return i, j
+end
+
+function Base.:(==)(s::ElementarySymplectic{N}, t::ElementarySymplectic{M}) where {N, M}
+    N == M || return false
+    s.symbol == t.symbol || return false
+    s.val == t.val || return false
+    return _ind(t) == _ind(s) || _ind(t) == _dual_ind(s)
+end
+
+Base.hash(s::ElementarySymplectic, h::UInt) =
+    hash(Set([_ind(s); _dual_ind(s)]), hash(s.symbol, hash(s.val, h)))
+
+LinearAlgebra.transpose(s::ElementarySymplectic{N}) where N =
+    ElementarySymplectic{N}(s.symbol, s.j, s.i, s.val)
+
+Base.inv(s::ElementarySymplectic{N}) where N =
+    ElementarySymplectic{N}(s.symbol, s.i, s.j, -s.val)
+
+function matrix_repr(s::ElementarySymplectic{N, T}) where {N, T}
+    @assert iseven(N)
+    n = div(N, 2)
+    m = StaticArrays.MMatrix{N, N, T}(LinearAlgebra.I)
+    i,j = _ind(s)
+    m[i,j] = s.val
+    if s.symbol === :A
+        m[n+j, n+i] = -s.val
+    else#if s.symbol === :B
+        if i > n
+            m[j+n, i-n] = s.val
+        else
+            m[j-n, i+n] = s.val
+        end
+    end
+    return StaticArrays.SMatrix{N, N}(m)
+end

src/wl_ball.jl

@@ -8,14 +8,14 @@ radius and multiplication operation to be used.
 """
 function wlmetric_ball_serial(S::AbstractVector{T}, center::T=one(first(S)); radius = 2, op = *) where {T}
     @assert radius >= 1
-    old = unique!([center, [center*s for s in S]...])
+    old = union!([center], [center*s for s in S])
     return _wlmetric_ball(S, old, radius, op, collect, unique!)
 end
 
 function wlmetric_ball_thr(S::AbstractVector{T}, center::T=one(first(S)); radius = 2, op = *) where {T}
     @assert radius >= 1
-    old = unique!([center, [center*s for s in S]...])
-    return _wlmetric_ball(S, old, radius, op, ThreadsX.collect, ThreadsX.unique)
+    old = union!([center], [center*s for s in S])
+    return _wlmetric_ball(S, old, radius, op, Folds.collect, Folds.unique)
 end
 
 function _wlmetric_ball(S, old, radius, op, collect, unique)

test/AutFn.jl

@@ -96,9 +96,7 @@
         @test evaluate(g*h) == evaluate(h*g)
         @test (g*h).savedhash == zero(UInt)
 
-        if VERSION >= v"1.6.0"
-            @test sprint(show, typeof(g)) == "Automorphism{FreeGroup{Symbol, KnuthBendix.LenLex{Symbol}}, …}"
-        end
+        @test sprint(show, typeof(g)) == "Automorphism{FreeGroup{Symbol, KnuthBendix.LenLex{Symbol}}, …}"
 
         a = g*h
         b = h*g
@@ -176,12 +174,13 @@
         )
     end
 
-    @testset "GroupsCore conformance" begin
-        test_Group_interface(A)
-        g = A(rand(1:length(alphabet(A)), 10))
-        h = A(rand(1:length(alphabet(A)), 10))
+    Logging.with_logger(Logging.NullLogger()) do
+        @testset "GroupsCore conformance" begin
+            test_Group_interface(A)
+            g = A(rand(1:length(alphabet(A)), 10))
+            h = A(rand(1:length(alphabet(A)), 10))
 
-        test_GroupElement_interface(g, h)
+            test_GroupElement_interface(g, h)
+        end
     end
-
 end

test/AutSigma_41.jl

@@ -121,15 +121,22 @@ using Groups.KnuthBendix
             u = (a6 * a5)^-1 * b1 * (a6 * a5)
             x = (a6 * a5 * a4 * a3 * a2 * u * a1^-1 * a2^-1 * a3^-1 * a4^-1) # yet another auxillary
             # x = (a4^-1*a3^-1*a2^-1*a1^-1*u*a2*a3*a4*a5*a6)
-            @time evaluate(x)
+
             b3 = x * a0 * x^-1
-            b3im = @time evaluate(b3)
-            b3cim = @time let g = b3
+            b3im = evaluate(b3)
+            b3cim = let g = b3
                 f = Groups.compiled(g)
                 f(Groups.domain(g))
             end
             @test b3im == b3cim
             @test a0 * b2 * b1 == a1 * a3 * a5 * b3
+
+            @time evaluate(x)
+            let g = b3
+                f = Groups.compiled(g)
+                f(Groups.domain(g))
+                @time f(Groups.domain(g))
+            end
         end
     end
 

test/benchmarks.jl

@@ -2,7 +2,6 @@ using BenchmarkTools
 using Test
 
 using Groups
-using Groups.New
 
 function wl_ball(F; radius::Integer)
     g, state = iterate(F)
@@ -47,7 +46,7 @@ end
     @testset "iteration: SAut(F_n)" begin
         R = 4
         FN = FreeGroup(N)
-        SAutFN = New.SpecialAutomorphismGroup(FN)
+        SAutFN = SpecialAutomorphismGroup(FN)
 
         let G = SAutFN
             S = unique([gens(G); inv.(gens(G))])

test/fp_groups.jl

@@ -54,9 +54,14 @@
     Groups.normalform!(h)
     @test h == H([5])
 
-    @testset "GroupsCore conformance: H" begin
-        test_Group_interface(H)
-        test_GroupElement_interface(rand(H, 2)...)
-    end
+    @test_logs (:warn, "using generic isfiniteorder(::AbstractFPGroupElement): the returned `false` might be wrong") isfiniteorder(h)
 
+    @test_logs (:warn, "using generic isfinite(::AbstractFPGroup): the returned `false` might be wrong") isfinite(H)
+
+    Logging.with_logger(Logging.NullLogger()) do
+        @testset "GroupsCore conformance: H" begin
+            test_Group_interface(H)
+            test_GroupElement_interface(rand(H, 2)...)
+        end
+    end
 end

test/free_groups.jl

@@ -37,6 +37,8 @@
         @test k == a*b^-1
 
         @time k = test_iteration(F3, 1000)
+
+        @time test_iteration(F3, 1000)
         @test k == (a^2)*c^2*a^-1
     end
 
@@ -67,5 +69,4 @@
         test_Group_interface(F3)
         test_GroupElement_interface(rand(F3, 2)...)
     end
-
 end

test/group_constructions.jl

@@ -0,0 +1,43 @@
+@testset "GroupConstructions" begin
+
+    @testset "DirectProduct" begin
+        GH =
+            let G = PermutationGroups.SymmetricGroup(3),
+                H = PermutationGroups.SymmetricGroup(4)
+
+                Groups.Constructions.DirectProduct(G, H)
+            end
+        test_Group_interface(GH)
+        test_GroupElement_interface(rand(GH, 2)...)
+
+        @test collect(GH) isa Array{eltype(GH), 2}
+        @test contains(sprint(print, GH), "Direct product")
+        @test sprint(print, rand(GH)) isa String
+    end
+
+    @testset "DirectPower" begin
+        GGG = Groups.Constructions.DirectPower{3}(
+            PermutationGroups.SymmetricGroup(3),
+        )
+        test_Group_interface(GGG)
+        test_GroupElement_interface(rand(GGG, 2)...)
+
+        @test collect(GGG) isa Array{eltype(GGG), 3}
+        @test contains(sprint(print, GGG), "Direct 3-rd power")
+        @test sprint(print, rand(GGG)) isa String
+    end
+    @testset "WreathProduct" begin
+        W =
+            let G = PermutationGroups.SymmetricGroup(2),
+                P = PermutationGroups.SymmetricGroup(4)
+
+                Groups.Constructions.WreathProduct(G, P)
+            end
+        test_Group_interface(W)
+        test_GroupElement_interface(rand(W, 2)...)
+
+        @test collect(W) isa Array{eltype(W), 2}
+        @test contains(sprint(print, W), "Wreath product")
+        @test sprint(print, rand(W)) isa String
+    end
+end

test/homomorphisms.jl

@@ -0,0 +1,71 @@
+function test_homomorphism(hom)
+    F = hom.source
+    @test isone(hom(one(F)))
+    @test all(inv(hom(g)) == hom(inv(g)) for g in gens(F))
+    @test all(isone(hom(g) * hom(inv(g))) for g in gens(F))
+    @test all(hom(g * h) == hom(g) * hom(h) for g in gens(F) for h in gens(F))
+    @test all(
+        hom(inv(g * h)) == inv(hom(g * h)) == hom(inv(h)) * hom(inv(g)) for
+        g in gens(F) for h in gens(F)
+    )
+end
+
+@testset "Homomorphisms" begin
+
+    F₂ = FreeGroup(2)
+    g,h = gens(F₂)
+
+    ℤ² = FPGroup(F₂, [g*h => h*g])
+
+    let hom = Groups.Homomorphism((i, G, H) -> Groups.word_type(H)([i]), F₂, ℤ²)
+
+        @test hom(word(g)) == word(g)
+
+        @test hom(word(g*h*inv(g))) == [1,3,2]
+
+        @test hom(g*h*inv(g)) == hom(h)
+        @test isone(hom(g*h*inv(g)*inv(h)))
+
+        @test contains(sprint(print, hom), "Homomorphism")
+
+        test_homomorphism(hom)
+    end
+
+    SAutF3 = SpecialAutomorphismGroup(FreeGroup(3))
+    SL3Z = MatrixGroups.SpecialLinearGroup{3}(Int8)
+
+    let hom = Groups.Homomorphism(
+            Groups._abelianize,
+            SAutF3,
+            SL3Z,
+        )
+
+        A = alphabet(SAutF3)
+        g = SAutF3([A[Groups.ϱ(1,2)]])
+        h = SAutF3([A[Groups.λ(1,2)]])^-1
+
+        @test !isone(g) && !isone(hom(g))
+        @test !isone(h) && !isone(hom(h))
+        @test !isone(g*h) && isone(hom(g*h))
+
+        test_homomorphism(hom)
+    end
+
+    @testset "Correctness of autπ₁Σ → SpN" begin
+
+        GENUS = 3
+        π₁Σ = Groups.SurfaceGroup(GENUS, 0)
+        autπ₁Σ = AutomorphismGroup(π₁Σ)
+
+        SpN = MatrixGroups.SymplecticGroup{2GENUS}(Int8)
+
+        hom = Groups.Homomorphism(
+            Groups._abelianize,
+            autπ₁Σ,
+            SpN,
+            check = false,
+        )
+
+        test_homomorphism(hom)
+    end
+end

test/matrix_groups.jl

@@ -0,0 +1,79 @@
+using Groups.MatrixGroups
+
+@testset "Matrix Groups" begin
+    @testset "SL(n, ℤ)" begin
+        SL3Z = SpecialLinearGroup{3}(Int8)
+
+        S = gens(SL3Z); union!(S, inv.(S))
+
+        E, sizes = Groups.wlmetric_ball(S, radius=4)
+
+        @test sizes == [13, 121, 883, 5455]
+
+        E(i,j) = SL3Z([A[MatrixGroups.ElementaryMatrix{3}(i,j, Int8(1))]])
+
+        A = alphabet(SL3Z)
+        w = E(1,2)
+        r = E(2,3)^-3
+        s = E(1,3)^2*E(3,2)^-1
+
+        S = [w,r,s]; S = unique([S; inv.(S)]);
+        _, sizes = Groups.wlmetric_ball(S, radius=4);
+        @test sizes == [7, 33, 141, 561]
+        _, sizes = Groups.wlmetric_ball_serial(S, radius=4);
+        @test sizes == [7, 33, 141, 561]
+
+        Logging.with_logger(Logging.NullLogger()) do
+            @testset "GroupsCore conformance" begin
+                test_Group_interface(SL3Z)
+                g = SL3Z(rand(1:length(alphabet(SL3Z)), 10))
+                h = SL3Z(rand(1:length(alphabet(SL3Z)), 10))
+
+                test_GroupElement_interface(g, h)
+            end
+        end
+
+
+        x = w*inv(w)*r
+
+        @test length(word(x)) == 5
+        @test size(x) == (3,3)
+        @test eltype(x) == Int8
+
+        @test contains(sprint(print, SL3Z), "special linear group of 3×3")
+        @test contains(sprint(show, MIME"text/plain"(), x), "SL{3,Int8} matrix:")
+        @test sprint(print, x) isa String
+
+        @test length(word(x)) == 3
+    end
+
+    @testset "Sp(6, ℤ)" begin
+        Sp6 = MatrixGroups.SymplecticGroup{6}(Int8)
+
+        @testset "GroupsCore conformance" begin
+            test_Group_interface(Sp6)
+            g = Sp6(rand(1:length(alphabet(Sp6)), 10))
+            h = Sp6(rand(1:length(alphabet(Sp6)), 10))
+
+            test_GroupElement_interface(g, h)
+        end
+
+        @test contains(sprint(print, Sp6), "group of 6×6 symplectic matrices")
+
+        x = gens(Sp6, 1)
+        x *= inv(x) * gens(Sp6, 2)
+
+        @test length(word(x)) == 3
+        @test size(x) == (6,6)
+        @test eltype(x) == Int8
+
+        @test contains(sprint(show, MIME"text/plain"(), x), "6×6 symplectic matrix:")
+        @test sprint(print, x) isa String
+
+        @test length(word(x)) == 1
+
+        for g in gens(Sp6)
+            @test MatrixGroups.issymplectic(MatrixGroups.matrix_repr(g))
+        end
+    end
+end

test/runtests.jl

@@ -1,6 +1,8 @@
 using Test
-import AbstractAlgebra
 using Groups
+using PermutationGroups
+
+import Logging
 
 import KnuthBendix: Word
 
@@ -9,27 +11,30 @@ include(joinpath(pathof(GroupsCore), "..", "..", "test", "conformance_test.jl"))
 
 @testset "Groups" begin
 
-    @testset "wlmetric_ball" begin
-        M = AbstractAlgebra.MatrixAlgebra(AbstractAlgebra.zz, 3)
-        w = one(M); w[1,2] = 1;
-        r = one(M); r[2,3] = -3;
-        s = one(M); s[1,3] = 2; s[3,2] = -1;
+    _, t = @timed include("free_groups.jl")
+    @info "free_groups.jl took $(round(t, digits=2))s"
+    _, t = @timed include("fp_groups.jl")
+    @info "fp_groups.jl took $(round(t, digits=2))s"
 
-        S = [w,r,s]; S = unique([S; inv.(S)]);
-        _, sizes = Groups.wlmetric_ball(S, radius=4);
-        @test sizes == [7, 33, 141, 561]
-        _, sizes = Groups.wlmetric_ball_serial(S, radius=4);
-        @test sizes == [7, 33, 141, 561]
+    _, t = @timed include("matrix_groups.jl")
+    @info "matrix_groups.jl took $(round(t, digits=2))s"
+    _, t = @timed include("AutFn.jl")
+    @info "AutFn.jl took $(round(t, digits=2))s"
+
+    _, t = @timed include("homomorphisms.jl")
+    @info "homomorphisms.jl took $(round(t, digits=2))s"
+
+    if haskey(ENV, "CI")
+        _, t = @timed include("AutSigma_41.jl")
+        @info "AutSigma_41 took $(round(t, digits=2))s"
+        _, t = @timed include("AutSigma3.jl")
+        @info "AutSigma3 took $(round(t, digits=2))s"
     end
 
-    include("free_groups.jl")
-    include("fp_groups.jl")
-
-    include("AutFn.jl")
-    include("AutSigma_41.jl")
-    include("AutSigma3.jl")
-
-    # if !haskey(ENV, "CI")
-    #    include("benchmarks.jl")
-    # end
+    _, t = @timed include("group_constructions.jl")
+    @info "Constructions took $(round(t, digits=2))s"
+end
+
+if !haskey(ENV, "CI")
+   include("benchmarks.jl")
 end