Thanks, Jacques. Not only does it make things faster for larger permutations (something I take your word for), but it also makes posMaps and negMaps look nicely simple (as seen using printlevel := 10).

While theoretical improvements are nice in themselves, the practical concern of whether to improve the effiicency of this routine depends on how you intend to deploy it. My assumption is that this procedure would be part of a separate procedure that is called one time, with a particular set of symmetries, and is used to create an indexing function for that class of tensor.  For example, for a tensor with four indices, you would create an index function for a 4 dimensional array with indices ranging from 1 to 4 (or similar).  To do that, you'd use this routine to partition the 4⁴ = 256 set of indices and then use that to create a special array that encodes the desired symmetry. The actual indexing function would use this array.  Because you only have to generate that array once (the indexing function can be reused for any tensor with that symmetry class), inefficiencies in it construction may not be significant. This presumes that your goal is to actually compute with the tensors, and not merely study symmetry classes of tensors.

Maybe that wasn't clear.  Here is a demo of the indexing technique I had in mind for a two-form (completely antisymmetric two-covector):

First, generate the special index table.  I do that by hand here, rather than using your code.  A zero entry (the default) indicates a zero component, otherwise the first entry in the sequence is the symmetry factor (-1,+1), the rest the indices of the stored component.

D2 := rtable(1..2,1..2,'storage=sparse'):
D2[1,2] := (1,1,2):
D2[2,1] := (-1,1,2):

 Create an index function that uses D2 (this general procedure remains the same for all tensors, you merely have to create it in a procedure that makes D2 local to it).

`index/twoform` := proc( idx :: list( posint )
                         , D :: rtable, val::list )
local d2;
    d2 := D2[idx[]];
    if _npassed = 2 then
        # retrieval
        if d2 = 0 then
            return 0;
        else
            d2[1]*D[d2[2..-1]];
        end if;
    else
        # storage
        if d2 = 0 then
            if val[] <> 0 then
                error "illegal assignment";
            else
                try
                    D[idx[]] := val[];
                catch "unable to store":
                    val[];
                end try;
            end if;
        else
            # general value
            D[d2[2..-1]] := d2[1]*val[];
        end if;
    end if;
end proc:

Now create a two-form, say F
 

F := Array('twoform',1..2,1..2,'storage=sparse'):

F[1,1] := 0.;  # just checking
F[1,2] := 3:
print(F);
                                   [ 0    3]
                                   [       ]
                                   [-3    0]