If your values are simple, you can just make copies such as by saying:

my %commands;
$commands{$_} = "10 14 00 07 4d" for qw(GENERATE CREATE SPAWN ETC);
$commands{$_} = "16 75 32 14 77" for qw(DELIVER DELIV SHIP ETC2);
[download]

If your values are more complex (IE; references to larger things), then simply make both references point to the same object.

my %commands;
my $createCMD = {weight=>10, coordinates=>[42,-3.14], logic=>sub{ ... 
+}, sound=>'success.mp3'};
$commands{$_} = $createCMD for qw(GENERATE CREATE SPAWN);
[download]

Just make new hash keys that reference the original keys' values:

use strict;
use warnings;

my %foo = (
  "GENERATE" => "10 14 00 07 4d",
  "DELIVER"  => "16 75 32 14 77"
);

$foo{CREATE} = \$foo{GENERATE};
$foo{DELIV} = \$foo{DELIVER};

use Data::Dumper;
print Dumper \%foo;
[download]

However, now you need to de-reference the values to use them:

print ${ $foo{CREATE} }, $/;
[download]

I recommend just duplicating the data:

$foo{CREATE} = $foo{GENERATE};
$foo{DELIV} = $foo{DELIVER};
[download]

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

I'll have very few hash keys (a dozen or so).

Likely I'll have way more aliases.

Thanks.

Mike

In the end I'd like to have several alternative "keys" per row, including some subset of abbreviations.

use strict;
use warnings;

my %multikeys;
my %yet_used;
             # alternatives                # value
multikeyize ('colors|colores|farben|col|c',"red green purple");
multikeyize ('animals|animalia|a',"sheep cow dog");

# warning example: redefining a masterkey
# multikeyize ('colors|xss|x',"tizio caio sempronio");

# warning example: redefining an alias
# multikeyize ('c|xss|x',"tizio caio sempronio");

sub multikeyize{
    my $alternatives= shift;
    my $value = shift;
    my @alternate = split /\|/,$alternatives;
    my $masterkey = shift @alternate;
    # masterkeys take the precedence..
    if ($yet_used{$masterkey}){
        print "\tWARNING '$masterkey' already defined! wiping previous
+ value!",
             (  $yet_used{$masterkey}=~/^1$/ ?
                "(was an alias)" :
                "(was a masterkey with value of '$yet_used{$masterkey}
+')"
              ),"\n";
        undef $yet_used{$masterkey};
    }
    $multikeys{$masterkey} = $yet_used{$masterkey} = $value;

    map { $yet_used{$_}++;
          $multikeys{$_} = \$multikeys{$masterkey};
          # just to show it..
          print "$_->";
    }
    grep {not exists $yet_used{$_} } @alternate;
    # just to show it..
    print "(masterkey) $masterkey = '$multikeys{$masterkey}'\n\n";
}


__OUTPUT__

colores->farben->col->c->(masterkey) colors = 'red green purple'

animalia->a->(masterkey) animals = 'sheep cow dog'
[download]

You want multiple values to point to the same hash key. You could use a hash to convert multiple values into one.

%convert = (Create=>'Create', Generate=>'Create', 
            Deliver=>'Deliver', Deliv=>'Deliver');
%foo_commands = ( Create  => "10 14 00 07 4d", 
                  Deliver => "16 75 32 14 77");

print $foo_commands{$convert{Deliv}};
[download]

This is just a variation on SuicideJunkie's approach above (update: but with some automatic abbreviation handling added):

c:\@Work\Perl>perl -wMstrict -le
"my %commands;
 ;;
 for my $ar_keys_val (
   [ qw(GENERATE CREATE) => '10 14 00 07 4d', ],
   [ qw(DELETE)          => '12 34 56 78 90', ],
   [ qw(DELIVER)         => '16 75 32 14 77', ],
   [ qw(FOO BAR BOFF)    => '99 88 77 66 55', ],
   ) {
   my @multi_keys = @{ $ar_keys_val }[ 0 .. $#$ar_keys_val - 1 ];
   my $single_val = @{ $ar_keys_val }[-1];
   for my $mk (@multi_keys) {
     die qq{duplicate key '$mk' -> '$single_val'} if exists $commands{
+$mk};
     $commands{$mk} = $single_val;
     }
   };
 ;;
 use Data::Dump qw(dd);
 ;;
 dd \%commands;
 ;;
 CMD:
 for my $cmd (qw(FOO BAR XBAR BARR DEL DELI)) {
   printf qq{command '$cmd': };
   my @candidates = grep { 0 == index $_, $cmd } keys %commands;
   if (not @candidates) {
     print qq{not found};
     next CMD;
     }
   if (@candidates > 1) {
     print qq{ambiguous: @candidates};
     next CMD;
     }
   print qq{($candidates[0]) -> '$commands{$candidates[0]}'};
   }
"
{
  BAR      => "99 88 77 66 55",
  BOFF     => "99 88 77 66 55",
  CREATE   => "10 14 00 07 4d",
  DELETE   => "12 34 56 78 90",
  DELIVER  => "16 75 32 14 77",
  FOO      => "99 88 77 66 55",
  GENERATE => "10 14 00 07 4d",
}

command 'FOO': (FOO) -> '99 88 77 66 55'
command 'BAR': (BAR) -> '99 88 77 66 55'
command 'XBAR': not found
command 'BARR': not found
command 'DEL': ambiguous: DELIVER DELETE
command 'DELI': (DELIVER) -> '16 75 32 14 77'
[download]

Use an aliases table that points to the unique key in the data table.

Oh, I see I wrote "table". I meant hash of course (or did I?).