Several options are provided to filter the kind of magmas enumerated.  For the most part, these circumscribe various equational identities that the enumerated magmas are required to satisfy.

The recognized options are as follows:

The presence of multiple property options implies the conjunction of all the passed option properties.  Consequently, contradictory properties, such as associative and szasz will result in no magmas being enumerated.

process = processor

The process = processor option allows you to specify a procedure to be called on each representative of the isomorphism classes of magmas enumerated. The procedure (processor) will be passed the Cayley table as the first argument and the order of the magma (a positive integer) as the second argument, and it can do whatever processing you want with the isomorphism class representative. Note that, if you want the processor argument to keep a copy of the Cayley table, then it must make an explicit copy (using, for instance, the copy command), since the same Array will be passed on each call, but with different numerical entries each time. The processor procedure should not attempt to modify the passed Array representing the Cayley table of the magma; changes will not be reflected in the enumeration.

test = tester

The test = tester option allows you to specify a nonbuilt-in predicate to be used to prune the search tree. It is passed a partially completed Cayley table for a magma of the specified order, as well as the order.  Only nonzero elements of the Cayley table are to be tested, as zero elements are, at the time the supplied predicate is called, deemed to be undetermined. It will be called after all the built-in tests have been performed.  Therefore, it is safe to assume that partial Cayley tables passed to it already satisfy all partial checks implied by any other properties specified. The tester predicate you pass with this option will be called as a procedure with the partially completed Cayley table as the first argument, and the order of the magma (a positive integer) as the second argument.  The partially completed Cayley table has the form of a two-dimensional array with datatype equal to integer[4] and with C_order storage order.  Thus, it is possible to use a compiled procedure as the value of this option.

The Enumerate command enumerates small (finite) magmas, optionally subject to certain constraints, described below. By default, it simply counts the number of such structures, up to isomorphism.

When called with no options or optional arguments, the Enumerate command simply counts the number of isomorphism classes of magmas of order n.

$\mathrm{with}\left(\mathrm{Magma}\right)\:$

$\mathrm{Enumerate}\left(2\right)$

$10$

$\mathrm{Enumerate}\left(4\,'\mathrm{commutative}'\,'\mathrm{associative}'\right)$

$58$

$L≔\mathrm{Enumerate}\left(3\,'\mathrm{associative}'\,'\mathrm{commutative}'\,'\mathrm{output}'='\mathrm{list}'\right)$

$L≔\left[\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\end{array}\right]\,\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 2\end{array}\right]\,\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 3\end{array}\right]\,\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 2\\ 1& 2& 3\end{array}\right]\,\left[\begin{array}{ccc}1& 1& 1\\ 1& 2& 1\\ 1& 1& 3\end{array}\right]\,\left[\begin{array}{ccc}1& 1& 1\\ 1& 2& 2\\ 1& 2& 2\end{array}\right]\,\left[\begin{array}{ccc}1& 1& 1\\ 1& 2& 2\\ 1& 2& 3\end{array}\right]\,\left[\begin{array}{ccc}1& 1& 1\\ 1& 2& 3\\ 1& 3& 2\end{array}\right]\,\left[\begin{array}{ccc}1& 1& 3\\ 1& 1& 3\\ 3& 3& 1\end{array}\right]\,\left[\begin{array}{ccc}1& 1& 3\\ 1& 2& 3\\ 3& 3& 1\end{array}\right]\,\left[\begin{array}{ccc}1& 2& 2\\ 2& 1& 1\\ 2& 1& 1\end{array}\right]\,\left[\begin{array}{ccc}1& 2& 3\\ 2& 3& 1\\ 3& 1& 2\end{array}\right]\right]$

$\mathrm{andmap}\left(\mathrm{IsAssociative}\,L\right)$

$\mathrm{true}$

$\mathrm{andmap}\left(\mathrm{IsCommutative}\,L\right)$

$\mathrm{true}$

$\mathrm{Enumerate}\left(4\,'\mathrm{group}'\,\mathrm{`=`}\left('\mathrm{process}'\,\left(m\,n\right)\mapsto \mathrm{lprint}\left(\mathrm{convert}\left(m\,'\mathrm{listlist}'\right)\right)\right)\right)$

[[1, 2, 3, 4], [2, 1, 4, 3], [3, 4, 1, 2], [4, 3, 2, 1]]
[[1, 2, 3, 4], [2, 1, 4, 3], [3, 4, 2, 1], [4, 3, 1, 2]]

$2$

$L≔\mathrm{Enumerate}\left(6\,\mathrm{leftbol}\,\mathrm{rightbol}\,\mathrm{loop}\right)$

$L≔2$

isconnected := proc( m, n )
   local i, gens;

   try
     gens := map( convert, {seq}( convert( m[ .., i ], 'list' ), i = 1 .. n ), 'disjcyc' )
   catch "not a permutation", "argument must be a permutation, but received %1":
     return true
   end try;
   GroupTheory:-IsTransitive( GroupTheory:-Group( map( Perm, gens ) ), {seq}( 1 .. n ) )
end proc:

$\mathrm{Enumerate}\left(5\,'\mathrm{quandle}'\,'\mathrm{test}'=\mathrm{isconnected}\right)$

$3$

Enumerate( 9, 'group', 'test' = proc( m, n )
 local i, L := remove( type, [seq]( m[ i, i ], i = 1 .. n ), 0 );
 evalb( nops( L ) = nops( {op}( L ) ) ) end proc );

$2$

sqcomm := proc( m :: Array( datatype = integer[4], order = C_order ), n :: posint )
  option autocompile;
  local i, j, z;

  for i from 1 to n do
    z := m[ i, i ];
    if z <> 0 then # ignore undefined entries
      for j from 1 to n do
        if m[ z, j ] <> 0 and m[ j, z ] <> 0 then # ignore undefined entries
          if m[ z, j ] <> m[ j, z ] then
            return false
          end if
        end if
      end do
    end if
  end do;
  true
end proc:

$L≔\mathrm{Enumerate}\left(6\&comma;'\mathrm{loop}'\&comma;'\mathrm{test}'='\mathrm{sqcomm}'\&comma;'\mathrm{output}'='\mathrm{list}'\right)\&colon;$

$\mathrm{nops}\left(L\right)$

$15$

$\mathrm{nops}\left(\mathrm{remove}\left(\mathrm{IsCommutative}\&comma;L\right)\right)$

$7$

The Magma[Enumerate] command was introduced in Maple 15.

For more information on Maple 15 changes, see Updates in Maple 15.

The semilattice option was introduced in Maple 16.

For more information on Maple 16 changes, see Updates in Maple 16.