my $prod = 1; # multiplicative identity, of course

for ( @a )
{
    my($x,$y) = @$_;
    $prod *= $x + $y;
}

That does what you describe, but it's not 2^N. Not sure where the discrepancy lies...

I don't see an operator between arr[0][0] and arr[1][0], so I presume the parenthesis mean you want to multiply.

Your description does not adequately explain what you want, particularly the (a[N-1][0] + a[N-1][1]).

Indices from your example:

0,0 1,0
0,0 1,1
0,1 1,0
0,1 1,1

Don't follow. They should be:

0,0 1,0
0,0 1,1
1,0 1,0
1,1 1,1
2,0 1,0
2,1 1,1
3,0 1,0
3,1 1,1
...

The wrong element is incrementing -- a[0][N-1] * a[1][0], a[0][N-1] * a[1][1].

Furthermore, this makes no sense. Are a[0][1] and a[1][1] use repeatedly throughout? If so, why not change them into constants?

If 2^N could become m^n, then you could use a recursive solution:

#! perl -slw
use strict;

sub expand{
    return @{ $_[0] } if @_ == 1;
    map{
        my $x = $_;
        my @part = expand( @_ );
        map{ $x * $_ } @part;
    } @{ pop @_ };
}

my @mat = ( [ -1, 2 ], [ 3, -4 ] );
printf +("%s " x @mat ) . '= ',  map{ "[ @$_ ] " } @mat;
print join ' ', expand( @mat );

@mat = ( [ 1, 2 ], [ 3, 4 ], [ 5, 6 ], );
printf +("%s " x @mat ) . '= ',  map{ "[ @$_ ] " } @mat;
print join ' ', expand( @mat );

@mat = ( [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ], );
printf +("%s " x @mat ) . '= ',  map{ "[ @$_ ] " } @mat;
print join ' ', expand( @mat );

__END__
P:\test>junk
[ -1 2 ]  [ 3 -4 ]  = -3 6 4 -8
[ 1 2 ]  [ 3 4 ]  [ 5 6 ]  = 15 30 20 40 18 36 24 48
[ 1 2 3 ]  [ 4 5 6 ]  [ 7 8 9 ]  = 28 56 84 35 70 105 42 84 126 32 64 96 40 80 120 48 96 144 36 72 108 45 90 135 54 108 162

That's funny, because when I run the program for N=2, I get:

term[0] = a[0][0] a[1][0] a[2][0]
term[1] = a[0][0] a[1][0] a[2][1]
term[2] = a[0][0] a[1][1] a[2][0]
term[3] = a[0][0] a[1][1] a[2][1]
term[4] = a[0][1] a[1][0] a[2][0]
term[5] = a[0][1] a[1][0] a[2][1]
term[6] = a[0][1] a[1][1] a[2][0]
term[7] = a[0][1] a[1][1] a[2][1]

So perhaps I have an off-by-one error, but certainly I'm generating 2^N terms.

I believe that to solve this you would need to create two separate arrays; one to contain the variables on the left side of the equation and another to contain each of the terms on the right side of the equation. Since you know that you will have 2**N variables on the left side, you would want to create an array named, say, Variable{2**N-1) to contain the variables. Then you would create an array Terms2**N-1 to contain the terms generated by multiplying the polynomials. I don't think one would need a two dimensional array. The first part of the program code could pop up a message box asking what N is, and then it would create the arrays as I described above. Then the code would step through array Variable[] multiplying the variables as appropriate and placing the resulting terms into array Terms[]. So the expansion is simply the sum of the elements of array Terms2**N-1. I am new to Perl so I am still working on actual code to do what I've described. I think that this is an interesting problem. BTW, ignore those hyperlinks..there should be brackets there but it's late and I'd rather sleep than read the writeup formatting tips tonight:)

Completely irrelevant time waster:

#!/your/perl/here

use strict;
use warnings;

{ # closure for sub terms
  
  my @term_list = ('A'..'Z', 'a'..'z');
  
  sub terms
  {
    my $N = shift;
    my $last = 2*$N-1;
    my @pairs;
    my $index = 0;
    my $globber = '';
    while ( $index < $last )
    {
      $globber .= '{' 
               . $term_list[$index++] 
               . ',' 
               . $term_list[$index++]
               . '}';
    }
    my $terms = join ' + ', glob($globber);
    return $terms;
  }

} # end closure for sub terms

foreach my $n (1..5)
{
  my $terms = terms($n);
  print "N=$n: <", $terms, ">\n";
}

exit;

__OUTPUT__
N=1: 
N=2: 
N=3: 
N=4: 
N=5: 

-QM
--
Quantum Mechanics: The dreams stuff is made of

In a way you are correct, except that it's "factorial" not "faculty" - I used the word permutations a bit too loosely.

However, the module Math::Combinatorics can still be used to iterate through the 2**N subsets as well as the nCr combinations and the N! permutations.