package Tie::Hash::KeyAlias;
use Carp;

sub TIEHASH {
    my $class = shift;
    my $self = {};
    $self->{aliases} = {} ;
    $self->{keys} = {@_};
    $self->{keystore} = [];
    $self->{keystoreindex} = 0;
    bless $self, $class;
}

sub STORE {
    my ($self,$key,$value) = @_;
    if (exists $self->{aliases}{$key} ){
        my $realkey = $self->{aliases}{$key};
        $self->{keys}{$realkey} = $value;

    }else{
        $self->{keys}{$key} = $value;
    }
}

sub FETCH {
    my ($self,$key) = @_;
    if (exists $self->{aliases}{$key} ){
        my $realkey = $self->{aliases}{$key};
        $self->{keys}{$realkey} ;

    }else{
        $self->{keys}{$key};
    }
}

sub DELETE {
    my ($self,$key) = @_;
    if (exists $self->{aliases}{$key} ){
        my $realkey = $self->{aliases}{$key};
        foreach my $k (keys %{$self->{aliases}}){
            delete $self->{aliases}{$k} if $self->{aliases}{$k} eq $re
+alkey;
        }

        delete $self->{keys}{$realkey} ;
    }else{
        foreach my $k (keys %{$self->{aliases}}){
            delete $self->{aliases}{$k} if $self->{aliases}{$k} eq $ke
+y;
        }
    }
    delete $self->{keys}{$key};
    
    
}

sub EXISTS {
    my ($self,$key) = @_;
    if (exists $self->{aliases}{$key} ){
        my $realkey = $self->{aliases}{$key};
        exists $self->{keys}{$realkey} ;

    }else{
        exists $self->{keys}{$key};
    }
}

sub DEFINED {
    my ($self,$key) = @_;
    if (exists $self->{aliases}{$key} ){
        my $realkey = $self->{aliases}{$key};
        defined $self->{keys}{$realkey} ;

    }else{
        defined $self->{keys}{$key};
    }
}

sub CLEAR {
    my $self = shift;
    $self = {};

}

sub FIRSTKEY {
    my $self = shift;
    $self->{keystore} = [ keys %{$self->{keys}}, keys %{$self->{aliase
+s}} ];
    return shift @{$self->{keystore}};
}

sub NEXTKEY {
    my $self = shift;
    return shift @{$self->{keystore}};
}

sub alias {
    my $self = shift;
    my %aliases = (@_);
    foreach my $k (keys %aliases){
        
        if (exists $self->{keys}{ $aliases{$k} } ){
            $self->{aliases}{$k} = $aliases{$k};
        }elsif(exists $self->{aliases}{ $aliases{$k} } ){
            my $realkey = $self->{aliases}{ $aliases{$k} };
            $self->{aliases}{$k} = $realkey;
        }else{
            croak "Can't ALIAS to a non-existant key! $k => $aliases{$
+k}" ;    
        }
    }
}

# EXAMPLE USAGE
package main;

use Data::Dumper;

my %hash;

tie %hash, 'Tie::Hash::KeyAlias';

$hash{key1} = '10';
$hash{anotherkey} = 55;
tied(%hash)->alias( key2=>'key1', key3=>'key2');

print Dumper(\%hash);
$hash{key3} ++;           # Modify key1,key2,key3
print Dumper(\%hash);
delete $hash{key2};    # delete key1,key2,key3 
print Dumper(\%hash);
untie %hash;
[download]

You could even hide the extra layer behind a tie.

Abigail

#!/usr/bin/perl
use strict;

use Data::Dumper;
my %hash = map { my $item = pop @$_; map { $_, $item } @$_ } 
 [qw(HELP ?) => sub { print "help\n"; }], 
 [qw(QUIT EXIT LEAVE) => sub { "exit"; }];

&{%hash->{HELP}}();
&{%hash->{'?'}}();
print Dumper(%hash);
1;
[download]

yields

help
help
$VAR1 = '?';
$VAR2 = sub { "DUMMY" };
$VAR3 = 'HELP';
$VAR4 = $VAR2;
$VAR5 = 'EXIT';
$VAR6 = sub { "DUMMY" };
$VAR7 = 'QUIT';
$VAR8 = $VAR6;
$VAR9 = 'LEAVE';
$VAR10 = $VAR6;
[download]

The [qw xxx],[qw xxx] are the list on which the first (leftmost) map operates.
For each [qw(X Y), anon_sub] the block of the leftmost map is executed and the result appended to the resulting hash.
In this block the last element is fetched in $item (my $item = pop @$_;) and then for each remaing element, which is the key, used as value in the resulting hash
(map { $_, $item } @$_)