You're very close.  jettero has already mentioned that you need to use the appropriate sigil; '$' instead of '%' for your hash.

You also are expecting a reference to a list in your subroutine hashOfArraysRef, but you have an extra level of indirection here:

&hashOfArraysRef(\$distri{$probExpr[0]});
[download]

because $distri{$probExpr[0]} is already holding an array reference.  If you change it to this:

&hashOfArraysRef($distri{$probExpr[0]});
[download]

you should find that it works closer to the way you need.

foreach (@probExpr) {
    print "$_\n";
    #%distri{$_}=();
    %distri{$_}=[];
}
[download]

Others have explained how to fix the syntax here, but even with that change, all this does is initialize each value of %distri to (a reference to) an empty anonymous array. Initializing variables to "empty" values is common practice in languages like C, but in Perl it is usually unnecessary and sometimes a sign of poor design. I will come back to this particular case in a moment...

&hashOfArraysRef(\$distri{$probExpr[0]});
[download]

This feels strange to me, and somewhat obfuscated, for code whose basic purpose is to assign something to that hash element. Yes, it is clear how it works when I look at the code for the subroutine, but apart from that additional context _this_ line could be... misleading. It would seem much more straightforward like this:

  $disti{$probExpr[0]} = function_that_returns_anonymous_array();
[download]

Or, assuming your function really wants to assign different anonymous arrays to different elements, perhaps something more like this:

  $disti{$probExpr[0]} = function_that_returns_anonymous_array($probEx
+pr[0]);
[download]

Or even...

   $disti{$_} = function_that_returns_anonymous_array($_) for @probExp
+r;
[download]

Then the basic flow of what's going on would be fairly clear _without_ seeing the subroutine definition. Since one of the major purposes of subroutines is to factor out details so that the main flow of the code can be seen, that would seem a desirable outcome.

Further, the initialization loop above would then become superfluous, further simplifying the code.

#!/bin/perl5

use strict;
use warnings;
use Data::Dumper;

my $distri;

$distri = { # hash ref
  one   => [qw{1 2 3}], # array ref
  two   => [qw{3 4 5}],
  three => [qw{6 7 8}],
};

my ($aref);

my $key_new = 'four';
$aref = [qw{9 10 11}];
$distri = update_hash($distri, $key_new, $aref);

my $key_existing = 'one';
$aref = [qw{12 13 14}];
$distri = update_hash($distri, $key_existing, $aref);

print Dumper $distri;


sub update_hash {
  
  # unpack and copy the arguments
  my ($href, $key, $aref) = @_;
  
  # key will be created if it doesn't exist
  # (autovivified)
  push @{$href->{$key}}, @{$aref}; # append
  # $href->{$key} = $aref;         # overwrite
  
  # return the copy
  # (leaving the original intact)
  return $href;
  
}
[download]

---------- Capture Output ----------
> "C:\Perl\bin\perl.exe" _new.pl
$VAR1 = {
          'three' => [
                       '6',
                       '7',
                       '8'
                     ],
          'one' => [
                     '1',
                     '2',
                     '3',
                     '12',
                     '13',
                     '14'
                   ],
          'two' => [
                     '3',
                     '4',
                     '5'
                   ],
          'four' => [
                      '9',
                      '10',
                      '11'
                    ]
        };

> Terminated with exit code 0.
[download]

In perl, that leading type indicator indicates the context. You want $distri{$_} = []; since you're assigning a scalar