my $defined_x_no_y = grep { defined $_->{x} && !defined $_->{y} } valu
+es %hash;
my $defined_z      = grep { defined $_->{z} } values %hash;
[download]

Note that I used defined and not exists, since you said "defined", but you might have meant "exists" ...

#!/usr/local/bin/perl

use strict;
use warnings;

my %hash = (
    'a' => {
        'x' => 40,
        'z' => 102
    },
    'b' => {
        'z' => 100,
        'x' => 10,
        'y' => 20
    },
    'c' => {
        'x' => 50
    },
    'd' => {
        'z' => 101,
        'y' => 30
    }
);

my $x_but_not_y = 0;
my $z = 0;

foreach my $key (keys %hash) {
    $x_but_not_y++ if defined $hash{$key}->{x} and not defined $hash{$
+key}->{y};
    $z++ if defined $hash{$key}->{z};
}

print "number of keys where x defined, but not y: $x_but_not_y\n";
print "number of keys where z defined: $z\n";
[download]

#!/usr/bin/perl -w
use strict;


my %hash = (
          'a' => {
                   'x' => 40,
                   'z' => 102
                 },
          'b' => {
                   'z' => 100,
                   'x' => 10,
                   'y' => 20
                 },
          'c' => {
                   'x' => 50
                 },
          'd' => {
                   'z' => 101,
                   'y' => 30
                 }
        );

sub stats {
    my %hhp = @_;
    
    my %counters; # a counter hash of which keys are used at level two
    
    foreach my $key1 (keys %hhp) {
        my @cList = ();
        foreach my $key2 (keys %{$hhp{$key1}}) {
            push(@cList,$key2);
        }
        ++$counters{join('+',sort @cList)};
    }
    return %counters;
}

#### main
my %result = stats(%hash);
foreach my $key (keys %result){
    print "$key $result{$key}\n";
}
[download]

x+y+z 1
y+z 1
x+z 1
x 1
[download]

#!/usr/bin/perl -w
use strict;
use warnings;

my %hash = (
          'a' => {
                   'x' => 40,
                   'z' => 102
                 },
          'b' => {
                   'z' => 100,
                   'x' => 10,
                   'y' => 20
                 },
          'c' => {
                   'x' => 50
                 },
          'd' => {
                   'z' => 101,
                   'y' => 30
                 }
        );

sub stats {
    my ($hhp, $SearchKey, $SearchVal) = @_;
    my %counters; # a counter hash of which keys are used at level two
    my $SearchCount;

    foreach my $key1 (keys %$hhp) {
        my @cList = keys %{$hhp->{$key1}};
        ++$counters{join('+',sort @cList)};
        ++$SearchCount if exists $hhp->{$key1}->{$SearchKey} 
                         and $hhp->{$key1}->{$SearchKey} == $SearchVal
+;
    }
    return $SearchCount, %counters;
}

#### main
my ($SearchCount, %result) = stats(\%hash,'z',101);
foreach my $key (sort keys %result){
    print "$key \t$result{$key}\n";
}
print "Count of z==101 is $SearchCount\n";
__END__
## OUTPUT ##
x       1
x+y+z   1
x+z     1
y+z     1
Count of z==101 is 1
[download]

The direct generation of the $key2 list directly into @cList is a nice improvement. I just want to add one more version more in the spirit of general statistical collection rather than situation testing. In this version, you can see what I call structural flattening. (Not sure that is the most appropriate term for it, but hey, I'm JAPH.)

If the statistics are too detailed or at the wrong level, just modify the sprintf expression.

We have pretty much hammered this little problem to death.

sub stats {
    my %hhp = @_;
    
    my $keyCounter = {}; # a counter hash of which keys are used at le
+vel two
    my $statCounter = {}; # a counter for the actual values
    
    foreach my $key1 (keys %hhp) {
        my @cList = ();
        foreach my $key2 (sort keys %{$hhp{$key1}}) {
           push(@cList,$key2);
           my $statKey = sprintf("%s->%s=%s",$key1,$key2,$hhp{$key1}{$
+key2});
           ++ $$statCounter{$statKey}; # make statistical entry on val
+ue
        }
        ++ $$keyCounter{join('+',@cList)}; # make statistical entry on
+ key2
        
    }
    return ($keyCounter,$statCounter);
}

#### main
my ($keyResult,$statResult) = stats(%hash);

foreach my $hash ($keyResult,$statResult){
    foreach my $key (sort keys %$hash){
        print "$key $$hash{$key}\n";
    }
}
                       
__END__

## the result
x 1
x+y+z 1
x+z 1
y+z 1
a->x=40 1
a->z=102 1
b->x=10 1
b->y=20 1
b->z=100 1
c->x=50 1
d->y=30 1
d->z=101 1
[download]

perlcapt
-ben

$c = 0; for (keys %hash) { $c++ if $hash{$_}{'x'} && !$hash{$_}{'y'}; 
+} print "$c\n";
$c = 0; for (keys %hash) { $c++ if $hash{$_}{'z'}; } print "$c\n";
$c = 0; for (keys %hash) { $c++ if $hash{$_}{'z'} == 101; } print "$c\
+n";
[download]