I also found that the only key is 6 (just the number 6).

The problem is that you are using the size of the arrays (eg. @quintic in a scalar context) as your hash keys. If you quoted the hashes thus:

$haystack{ "@quintic" }{ "@derivative" } =  \@zeros;
[download]

Or used join something like this:

$haystack{ join ',', @quintic }{ join ',', @derivative } =  \@zeros;
[download]

That might be nearer to what you are after, though it may not sure all the ills.

Note also that I've backslashed \@zeros to store a reference to the array, otherwise you are again storing the size of the array, not its contents.

A few comments:

• The symmetry of the problem leads to 10 different cases only. We can assume that 1<=$c<$b<$a<=$rep.
• This also implies that $a is always at least 3, and $b at least 2.
• This way the loops are simpler and no check for equality is required.
• I think that $a, $b, $c are the correct parameters to store the results rather than the polynomials itself.

use strict;
use warnings;
use Math::Polynomial::Solve qw!poly_derivative poly_roots!;
use Data::Dumper;

my %haystack;
my $rep = int 5; # $rep means right endpoint of the interval [0, $rep]

foreach my $a (3..$rep ) {
    foreach my $b (2..$a-1 ) {
        foreach my $c (1..$b-1 ) {
      my @quintic = (1, -$a - $b - $c, $a*$b + $a*$c + $b*$c, -$a*$b*$
+c, 0, 0); 
      my @derivative = poly_derivative(@quintic);
      my @zeros = poly_roots(@derivative);    
      
      $haystack{"$a,$b,$c"}{"p"} =  \@quintic;
      $haystack{"$a,$b,$c"}{"d"} =  \@derivative;
      $haystack{"$a,$b,$c"}{"z"} =  \@zeros;
        }
    }
}

print Dumper{%haystack};
[download]

That makes a lot of sense when I think of what the problem is, especially the first & last things. Once I got it working I confirmed what I suspected that I actually don't really need to know what the derivatives actually are, only what their zeros are. So I actually only need an ordinary hash. Now that I've got the hash part fixed I want to search the values for zero sets that only contain integers, or maybe values within 0.0001 of an integer since the Solve module uses a numerical matrix method to find the zeros, then print out its key. I think grep is what I'm looking for. Thx for all the help so far everybody :D

btw that dumper module is a real lifesaver!

Echoing BrowserUK ... “the key,” in any hashref, must be “a string.” What you are using right now will be coerced by Perl into “a string,” but it won’t be a string that you can use in this case.   Therefore, you need to produce, from the arrays that you have, some kind of “single string,”   and to make sure that it’s the string that you want.   When developing code like this, I usually add a few extra statements ... creating a few extra scalar variables (my $d= ...; my $z= ...), inserting some statement (such as the suggested join() to produce the value, then perhaps initially adding print STDERR "d=$d, z=$z\n"; so that I can see what value Perl actually came up with (undoubtedly contrary to my expectations).   Once I’m satisfied with the two strings, I use them in a statement like $$haystack{$d}{$z} = \@zeroes;

The “extra” dollar-sign is functionally equivalent to $haystack->{$d}{$z} ... it’s up to you.

The backslash to the right of the equals-sign is also important:   a hashref is always a collection, indexed by “a string,” to “a scalar,” which in this case should be a reference to an array.   (Look up “references” here.)

Also, in all code, be sure to use: use strict; use warnings;.   Perl is designed to be very accepting and forgiving ... it will try to do what you ask, according to its own interpretation.   These two pragmas will tell it to alert you to mistakes that you probably didn’t realize you were making.   Your code should “run clean,” with no errors or warnings raised.