Error in determining commutativity of crossed product

[olexandr-konovalov]

Reported by email by Rene Marczinzik. This calculation reports that U is commutative, while it is not:

gap> G:=QuaternionGroup(8);
<pc group of size 8 with 3 generators>
gap> R:=GroupRing(Rationals,G);
<algebra-with-one over Rationals, with 3 generators>
gap> W:=WedderburnDecomposition(R);
[ Rationals, Rationals, Rationals, Rationals, 
  <crossed product with center Rationals over GaussianRationals of a group of \
size 2> ]
gap> U:=W[5];
<crossed product with center Rationals over GaussianRationals of a group of si\
ze 2>
gap> Dimension(U);
2
gap> IsCommutative(U);
true

[olexandr-konovalov]

There is nothing for determining commutativity of the crossed product in the Wedderga code for crossed product, except a comment and a commented out block of code:

wedderga/lib/crossed.gi

Lines 603 to 606 in bd28375

	# What about IsCommutative ? In MagmaRings it is as below:
	# if HasIsCommutative( R ) and HasIsCommutative( G ) then
	# SetIsCommutative( RG, IsCommutative( R ) and IsCommutative( G ) );
	# fi;

It happens that the commutativity is determined elsewhere, namely in lib/magma.gd:

gap> f:=ApplicableMethod(IsCommutative,[U]);
function( D ) ... end
gap> PageSource(f);
Showing source in /Users/obk1/gap/gap-4.12.2/lib/magma.gd (from line 1009)
##  <C><A>GeneratorsOfStruct</A>( <A>D</A> )</C> commute.
##  </Description>
##  </ManSection>
##
BindGlobal( "IsCommutativeFromGenerators", function( GeneratorsStruct )
    return function( D )

    local gens,   # list of generators
          i, j;   # loop variables

    # Test if every element commutes with all the others.
    gens:= GeneratorsStruct( D );
    for i in [ 2 .. Length( gens ) ] do
      for j in [ 1 .. i-1 ] do
        if gens[i] * gens[j] <> gens[j] * gens[i] then
          return false;
        fi;
      od;
    od;

    # All generators commute.
    return true;
    end;
end );

The fix is to install a proper method for IsCommutative for objects in IsCrossedProduct.

[drallenherman]

There is a problem with applying a function designed for algebras to one of the "crossed product algebras" produced by the "WedderburnDecomposition" function, because these crossed product algebras are not designed to be algebras in the usual sense. In wedderga, to get output that is a list of simple algebras over their centers, one should use "WedderburnDecompositionAsSCAlgebras". If they use this function they will get the answer they are expecting.

[angeldelriomateos]

One way to decide if a crossed product is commutative is by comparing the center with the Leftactingdomain. The crossed product is commutative if and only if its center and its left acting domain coincide.

[fingolfin]

The fix is to install a proper method for IsCommutative for objects in IsCrossedProduct.

I think that would just paper over a deeper (design?) issue with the code in question. Your code offers this:

gap> IsAlgebra(U);
true
gap> gens:=GeneratorsOfLeftOperatorRingWithOne(U);
[ (ZmodnZObj( 1, 4 ))*(1), (ZmodnZObj( 3, 4 ))*(1) ]
gap> a:=gens[1];; b:=gens[2];;
gap> a*b = b*a;
true

So U is an algebra and it generators commute, and hence GAP decides it is commutative.

But it isn't, and the discrepancy is caused by GAP being mislead: U isn't actually an algebra (in the sense GAP defines it): the GAP manual states:

An algebra is a vector space equipped with a bilinear map (multiplication).

But your multiplication is not bilinear in GAP's sense, otherwise these three products all would evaluate to the same result:

gap> E(4) * (b * a);
(ZmodnZObj( 3, 4 ))*(-E(4))
gap> (E(4) * b) * a;
(ZmodnZObj( 3, 4 ))*(-E(4))
gap> b * (E(4) * a);
(ZmodnZObj( 3, 4 ))*(E(4))

(There are other ways to define "bilinear" but in all definitions of "algebra over a field" I know, this one is used).

This definition ensures that "the non-commutativity is in the basis/generators", and not hidden in the interaction between scalars and generators as is the case here for the crossed products.

To fix this, you either need to rewrite this as an algebra over the rationals (of correspondingly higher dimension), or change the implementation to not imply IsAlgebra.

Otherwise I am sure there are other algorithms that will return "wrong" results.

[olexandr-konovalov]

@limakzi @fingolfin I have tried some more approaches, and failed. I suggest #106 as an alternative for now, to prevent wrong results - please have a look!

[limakzi]

It looks like we have problems with proper object mapping between LeftActingDomain and the Center the crossed product. It seems center of a crossed product do not any Basis attribute.

LoadPackage("wedderga");
R := GF(2);
G := TrivialGroup();;
act := function(RG,g)
    return IdentityMapping( LeftActingDomain( RG ) );;
end;
twist1 := function( RG, g, h )
    return One( LeftActingDomain( RG ) );
end;
RG := CrossedProduct( R, G, act, twist1 );

gap> Center(RG);
<algebra-with-one of dimension 1 over GF(2)>
gap> LeftActingDomain(RG);
GF(2)
gap> Elements(LeftActingDomain(RG));
[ 0*Z(2), Z(2)^0 ]
gap> Size(Center(RG));
2

I would agree that for a while, the best solution would be to improve UseBasis method or disable IsCommutative property for CrossedProducts at all for a while.

[olexandr-konovalov]

For now, I have merged #106 as a workaround, to prevent GAP from returning wrong results, and will keep this issue open.