Check that putative generators of a structure at least satisfy the structure axioms

gap/bytable.gi

@@ -36,7 +36,7 @@ InstallGlobalFunction(LeftQuasigroupByMultiplicationTable,
 end);
 
 InstallGlobalFunction(LeftQuasigroupByMultiplicationTableNC,
-  T -> MagmaByMultiplicationTableCreatorNC(T, LeftQuasigroup,
+  T -> MagmaByMultiplicationTableCreatorNC(T, LeftQuasigroupNC,
          IsLeftQuotientElement and IsMagmaByMultiplicationTableObj)
 );
 
@@ -50,7 +50,7 @@ InstallGlobalFunction(RightQuasigroupByMultiplicationTable,
 end);
 
 InstallGlobalFunction(RightQuasigroupByMultiplicationTableNC,
-  T -> MagmaByMultiplicationTableCreatorNC(T, RightQuasigroup,
+  T -> MagmaByMultiplicationTableCreatorNC(T, RightQuasigroupNC,
          IsRightQuotientElement and IsMagmaByMultiplicationTableObj)
 );
 
@@ -68,7 +68,7 @@ InstallGlobalFunction(LeftRackByMultiplicationTable,
   end);
 
 InstallGlobalFunction(LeftRackByMultiplicationTableNC,
-  T -> MagmaByMultiplicationTableCreatorNC(T, LeftRack,
+  T -> MagmaByMultiplicationTableCreatorNC(T, LeftRackNC,
          IsLeftQuotientElement and IsLSelfDistElement and 
          IsMagmaByMultiplicationTableObj
        )
@@ -89,7 +89,7 @@ InstallGlobalFunction(LeftQuandleByMultiplicationTable,
   end);
 
 InstallGlobalFunction(LeftQuandleByMultiplicationTableNC,
-  T -> MagmaByMultiplicationTableCreatorNC(T, LeftQuandle,
+  T -> MagmaByMultiplicationTableCreatorNC(T, LeftQuandleNC,
          IsLeftQuotientElement and IsLSelfDistElement and IsIdempotent and
          IsMagmaByMultiplicationTableObj
        )
@@ -109,7 +109,7 @@ InstallGlobalFunction(RightRackByMultiplicationTable,
 end);
 
 InstallGlobalFunction(RightRackByMultiplicationTableNC,
-  T -> MagmaByMultiplicationTableCreatorNC(T, RightRack,
+  T -> MagmaByMultiplicationTableCreatorNC(T, RightRackNC,
          IsRightQuotientElement and IsRSelfDistElement and 
          IsMagmaByMultiplicationTableObj
        )
@@ -130,7 +130,7 @@ InstallGlobalFunction(RightQuandleByMultiplicationTable,
 end);
 
 InstallGlobalFunction(RightQuandleByMultiplicationTableNC,
-  T -> MagmaByMultiplicationTableCreatorNC(T, RightQuandle,
+  T -> MagmaByMultiplicationTableCreatorNC(T, RightQuandleNC,
          IsRightQuotientElement and IsRSelfDistElement and IsIdempotent and
          IsMagmaByMultiplicationTableObj
        )
@@ -197,21 +197,16 @@ InstallMethod(RightPerms,
 end);
 
 ## Distributivity/idempotence checkers for when need be
-InstallMethod(IsLSelfDistributive, "for magma",
-              [IsMagma and IsFinite],
+InstallMethod(IsLSelfDistributive, "for collections with multiplication tables",
+              [HasMultiplicationTable],
               M -> IsLeftSelfDistributiveTable(MultiplicationTable(M))
 );
 
-InstallMethod(IsRSelfDistributive, "for magma",
-              [IsMagma and IsFinite],
+InstallMethod(IsRSelfDistributive, "for collections with multiplication table",
+              [HasMultiplicationTable],
               M -> IsRightSelfDistributiveTable(MultiplicationTable(M))
 );
 
-InstallMethod(IsElementwiseIdempotent, "for magma",
-              [IsMagma and IsFinite],
-              M -> ForAll(Elements(M), m->IsIdempotent(m))
-);
-
 ## Patch View/Print/Display for magma by mult objects
 InstallMethod(String, "for an element of magma by multiplication table",
   [IsMagmaByMultiplicationTableObj],

gap/structure.gd

@@ -21,15 +21,13 @@ DeclareCategoryCollections("IsLSelfDistElement");
 DeclareCategory("IsRSelfDistElement", IsMultiplicativeElement);
 DeclareCategoryCollections("IsRSelfDistElement");
 
-# Left self-distributive magmas:
-DeclareProperty("IsLSelfDistributive", IsMagma);
-InstallTrueMethod(IsLSelfDistributive, 
-                  IsMagma and IsLSelfDistElementCollection);
+# Left self-distributive collections of elements:
+DeclareProperty("IsLSelfDistributive", IsMultiplicativeElementCollection);
+InstallTrueMethod(IsLSelfDistributive, IsLSelfDistElementCollection);
 
-# Right self-distributive magmas:
-DeclareProperty("IsRSelfDistributive", IsMagma);
-InstallTrueMethod(IsRSelfDistributive, 
-                  IsMagma and IsRSelfDistElementCollection);
+# Right self-distributive collections of elements:
+DeclareProperty("IsRSelfDistributive", IsMultiplicativeElementCollection);
+InstallTrueMethod(IsRSelfDistributive, IsRSelfDistElementCollection);
 
 ## Idempotence
 # There is already a property IsIdempotent on elements, but to definw
@@ -37,9 +35,9 @@ InstallTrueMethod(IsRSelfDistributive,
 # collections category:
 DeclareCategoryCollections("IsIdempotent");
 
-# Idempotent magmas, i.e. magmas in which every element is idempotent
-DeclareProperty("IsElementwiseIdempotent", IsMagma);
-InstallTrueMethod(IsElementwiseIdempotent, IsMagma and IsIdempotentCollection);
+# Collections in which every element is idempotent
+DeclareProperty("IsElementwiseIdempotent", IsMultiplicativeElementCollection);
+InstallTrueMethod(IsElementwiseIdempotent, IsIdempotentCollection);
 
 ## Left and right racks and quandles
 DeclareSynonym("IsLeftRack", IsLeftQuasigroup and IsLSelfDistributive);
@@ -54,11 +52,17 @@ DeclareSynonym("IsRightQuandle", IsLeftRack and IsElementwiseIdempotent);
 # the family of elements of M may be specified, and must be if <gens>
 # is empty (in which case M will be empty as well).
 DeclareGlobalFunction("LeftQuasigroup");
+DeclareGlobalFunction("LeftQuasigroupNC");
 DeclareGlobalFunction("RightQuasigroup");
+DeclareGlobalFunction("RightQuasigroupNC");
 DeclareGlobalFunction("LeftRack");
+DeclareGlobalFunction("LeftRackNC");
 DeclareGlobalFunction("RightRack");
+DeclareGlobalFunction("RightRackNC");
 DeclareGlobalFunction("LeftQuandle");
+DeclareGlobalFunction("LeftQuandleNC");
 DeclareGlobalFunction("RightQuandle");
+DeclareGlobalFunction("RightQuandleNC");
 
 # Underlying operation
 DeclareGlobalFunction("CloneOfTypeByGenerators");

gap/structure.gi

@@ -1,6 +1,36 @@
 ## structure.gi RAQ Implementation of definitiions, reps, and elt operations
 
+## Testing properties of collections the hard way if we have to
+
+InstallMethod(IsElementwiseIdempotent, "for finite collections",
+              [IsMultiplicativeElementCollection and IsFinite],
+              M -> ForAll(Elements(M), m->IsIdempotent(m))
+);
+
+InstallMethod(IsLSelfDistributive,
+              "for arbitrary multiplicative collections, the hard way",
+              [IsMultiplicativeElementCollection],
+  function (C)
+    local a,b,d;
+    for a in C do for b in C do for d in C do
+      if d*(a*b) <> (d*a)*(d*b) then return false; fi;
+    od; od; od;
+    return true;
+end);
+
+InstallMethod(IsRSelfDistributive,
+              "for arbitrary multiplicative collections, the hard way",
+              [IsMultiplicativeElementCollection],
+  function (C)
+    local a,b,d;
+    for a in C do for b in C do for d in C do
+      if (a*b)*d <> (a*d)*(b*d) then return false; fi;
+    od; od; od;
+    return true;
+end);
+                                 
 ## Create structures with generators
+
 InstallGlobalFunction(CloneOfTypeByGenerators,
   function(cat, fam, gens, genAttrib, tableCstr)
     local M;
@@ -13,122 +43,131 @@ InstallGlobalFunction(CloneOfTypeByGenerators,
     return M;
 end);
 
+## Helpers for the constructors below:
+
+ArgHelper@ := function(parmlist)
+  # returns a list of the family and the flat list of elements of parmlist
+  if Length(parmlist) = 0 then
+    Error("usage: RAQ constructors take an optional family, followed by gens");
+  fi;
+  if IsFamily(parmlist[1]) then return [Remove(parmlist,1), Flat(parmlist)]; fi;
+  parmlist := Flat(parmlist);
+  return [FamilyObj(parmlist), parmlist];
+end;
+
+CheckLQGprop@ := function(gens)
+  local g, h;
+  # Make sure all elements in gens have left quotient property pairwise
+  for g in gens do for h in gens do
+    if g*LeftQuotient(g,h) <> h or LeftQuotient(g,g*h) <> h then
+      Error("left quasigroup property of left quotients violated");
+    fi;
+  od; od;
+  return;
+end;
+
+CheckRQGprop@ := function(gens)
+  local g, h;
+  # Make sure all elements in gens have right quotient property pairwise
+  for g in gens do for h in gens do
+    if (h*g)/g <> h or (h/g)*g <> h then
+      Error("right quasigroup property of / violated");
+    fi;
+  od; od;
+  return;
+end;
+
 ## Functions for each of the magma categories here
 InstallGlobalFunction(LeftQuasigroup, function(arg)
-  local fam;
-  if Length(arg) = 0 then
-    Error("usage: LeftQuasigroup([<family>], <gens>)");
-  fi;
-  # Extract the family
-  if IsFamily(arg[1]) then
-    fam := arg[1];
-    Remove(arg, 1);
-    arg := Flat(arg);
-  else
-    arg := Flat(arg);
-    fam := FamilyObj(arg);
-  fi;
-  return CloneOfTypeByGenerators(IsLeftQuasigroup, fam, arg,
+  arg := ArgHelper@(arg);
+  CheckLQGprop@(arg[2]);
+  return LeftQuasigroupNC(arg[1], arg[2]);
+end);
+
+InstallGlobalFunction(LeftQuasigroupNC, function(fam, gens)                      
+  return CloneOfTypeByGenerators(IsLeftQuasigroup, fam, gens,
                                  GeneratorsOfLeftQuasigroup, 
                                  LeftQuasigroupByMultiplicationTableNC);
 end);
 
 InstallGlobalFunction(LeftRack, function(arg)
-  local fam;
-  if Length(arg) = 0 then
-    Error("usage: LeftRack([<family>], <gens>)");
+  arg := ArgHelper@(arg);
+  CheckLQGprop@(arg[2]);
+  if not IsLSelfDistributive(arg[2]) then
+    Error("Left rack must have left distributive generators");
   fi;
-  # Extract the family
-  if IsFamily(arg[1]) then
-    fam := arg[1];
-    Remove(arg, 1);
-    arg := Flat(arg);
-  else
-    arg := Flat(arg);
-    fam := FamilyObj(arg);
-  fi;
-  return CloneOfTypeByGenerators(IsLeftRack, fam, arg,
+  return LeftRackNC(arg[1], arg[2]);
+end);
+
+IntallGlobalFunction(LeftRackNC, function(fam, gens)
+  return CloneOfTypeByGenerators(IsLeftRack, fam, gens,
                                  GeneratorsOfLeftQuasigroup,
                                  LeftRackByMultiplicationTableNC);
 end);
 
 InstallGlobalFunction(LeftQuandle, function(arg)
-  local fam;
-  if Length(arg) = 0 then
-    Error("usage: LeftQuandle([<family>], <gens>)");
+  arg := ArgHelper@(arg);
+  CheckLQGprop@(arg[2]);
+  if not IsLSelfDistributive(arg[2]) then
+    Error("Left quandle must have left distributive generators");
   fi;
-  # Extract the family
-  if IsFamily(arg[1]) then
-    fam := arg[1];
-    Remove(arg, 1);
-    arg := Flat(arg);
-  else
-    arg := Flat(arg);
-    fam := FamilyObj(arg);
+  if not IsElementwiseIdempotent(arg[2]) then
+    Error("Quandles must contain only idempotent elements");
   fi;
-  return CloneOfTypeByGenerators(IsLeftQuandle, fam, arg,
+  return LeftQuandleNC(arg[1], arg[2]);
+end);
+
+InstallGlobalFunction(LeftQuandleNC, function(fam, gens)
+  return CloneOfTypeByGenerators(IsLeftQuandle, fam, gens,
                                  GeneratorsOfLeftQuasigroup,
                                  LeftQuandleByMultiplicationTableNC);
 end);
 
 InstallGlobalFunction(RightQuasigroup, function(arg)
-  local fam;
-  if Length(arg) = 0 then
-    Error("usage: RightQuasigroup([<family>], <gens>)");
-  fi;
-  # Extract the family
-  if IsFamily(arg[1]) then
-    fam := arg[1];
-    Remove(arg, 1);
-    arg := Flat(arg);
-  else
-    arg := Flat(arg);
-    fam := FamilyObj(arg);
-  fi;
-  return CloneOfTypeByGenerators(IsRightQuasigroup, fam, arg,
-                                 GeneratorsOfRightQuasigroup,
+  arg := ArgHelper@(arg);
+  CheckRQGprop@(arg[2]);
+  return RightQuasigroupNC(arg[1], arg[2]);
+end);
+
+InstallGlobalFunction(RightQuasigroupNC, function(fam, gens)
+  return CloneOfTypeByGenerators(IsRightQuasigroup, fam, gens,
+                                 GeneratorsOfRightQuasigroup, 
                                  RightQuasigroupByMultiplicationTableNC);
 end);
 
 InstallGlobalFunction(RightRack, function(arg)
-  local fam;
-  if Length(arg) = 0 then
-    Error("usage: RightRack([<family>], <gens>)");
+  arg := ArgHelper@(arg);
+  CheckRQGprop@(arg[2]);
+  if not IsRSelfDistributive(arg[2]) then
+    Error("Right rack must have right distributive generators");
   fi;
-  # Extract the family
-  if IsFamily(arg[1]) then
-    fam := arg[1];
-    Remove(arg, 1);
-    arg := Flat(arg);
-  else
-    arg := Flat(arg);
-    fam := FamilyObj(arg);
-  fi;
-  return CloneOfTypeByGenerators(IsRightRack, fam, arg,
+  return RightRackNC(arg[1], arg[2]);
+end);
+
+IntallGlobalFunction(RightRackNC, function(fam, gens)
+  return CloneOfTypeByGenerators(IsRightRack, fam, gens,
                                  GeneratorsOfRightQuasigroup,
                                  RightRackByMultiplicationTableNC);
 end);
 
 InstallGlobalFunction(RightQuandle, function(arg)
-  local fam;
-  if Length(arg) = 0 then
-    Error("usage: RightQuandle([<family>], <gens>)");
+  arg := ArgHelper@(arg);
+  CheckLQGprop@(arg[2]);
+  if not IsRSelfDistributive(arg[2]) then
+    Error("Right quandle must have right distributive generators");
   fi;
-  # Extract the family
-  if IsFamily(arg[1]) then
-    fam := arg[1];
-    Remove(arg, 1);
-    arg := Flat(arg);
-  else
-    arg := Flat(arg);
-    fam := FamilyObj(arg);
+  if not IsElementwiseIdempotent(arg[2]) then
+    Error("Quandles must contain only idempotent elements");
   fi;
-  return CloneOfTypeByGenerators(IsRightQuandle, fam, arg,
+  return RightQuandleNC(arg[1], arg[2]);
+end);
+
+InstallGlobalFunction(RightQuandleNC, function(fam, gens)
+  return CloneOfTypeByGenerators(IsRightQuandle, fam, gens,
                                  GeneratorsOfRightQuasigroup,
                                  RightQuandleByMultiplicationTableNC);
 end);
 
-
 ## View and print and such
 LeftObjString@ := function(Q)
   # Don't test distributivity if we haven't already