This fails (the code computes the quotient group directly from the definition):

with(GroupTheory):

Qgr := (sgr, gr) -> CustomGroup(LeftCosets(sgr, gr),
  `.` = ((a, b) -> LeftCoset(Representative(a) . Representative(b), sgr)),
  `/` = ((a) -> LeftCoset(Representative(a)^(-1), sgr)),
  `=` = ((a, b) -> Elements(a) = Elements(b)));

gr := QuaternionGroup();
Generators(gr);
                [(1, 2, 3, 4)(5, 6, 8, 7), (1, 5, 3, 8)(2, 7, 4, 6)]

qgr := Qgr(Subgroup({Generators(gr)[1]^2}, gr), gr);
                  qgr := ` < a custom group with 4 generators > `

AreIsomorphic(qgr, DirectProduct(CyclicGroup(2), CyclicGroup(2)));
Error, (in =) invalid keyword expression

If I rename the parameters in the definition of Qgr, e.g., change the last line to

`=` = ((aa, bb) -> Elements(aa) = Elements(bb))

then everything works, AreIsomorphic gives true.

This doesn't work directly:

is(RootOf(_Z^3-_Z-1, index = 1)+RootOf(_Z^3-_Z-1, index = 2) = 0);
                                      FAIL

But Maple can compute the bounding interval for a polynomial RootOf (convert(..., RootOf, form=interval)), and evalrC can perform operations on complex intervals:

evalrC(RootOf(_Z^3-_Z-1, index = 1)+RootOf(_Z^3-_Z-1, index = 2));
       INTERVAL(0.6623589782, 0.5622795119, 0.6623589795, 0.5622795122)

evalrC(Re(%));
Error, (in evalrC/INTERVAL) not implemented yet: 4

Re and Im are obviously positive though. Why doesn't Maple try to do that automatically, and also, how do I check if the point is inside the interval? (Without writing my own function to handle real intervals, unions of real intervals, and complex intervals.)

With Typesetting level: Extended, INTERVAL displays only the first argument. So evalr(1/INTERVAL(-1 .. 1)) is displayed as INTERVAL(-infinity .. -1), and INTERVAL(-1,-1,1,1) is displayed as INTERVAL(-1).

applyrule(a::integer = 0, x = 1);
                             x = 1

applyrule(conditional(a::anything, a::`=`) = 0, x = 1);
Error, (in PatternMatching:-AlgStruct:-TableLookup) testing against an invalid type

Why doesn't applyrule do a replacement inside (x=1) and why is `=` an invalid type?

type(.5, rational);
                             false
is(.5, rational);
                              true
is([.5], list(rational));
                             false

is(.5, rational) seems to be the odd one out.