#! perl -sw
use 5.010;
use strict;
use Time::HiRes qw[ time ];
use Data::Dump qw[ pp ];
use Devel::Size qw[ total_size ];

my $abstract = do{ local $/; <DATA> };
my @words = split ' ', $abstract;

my %words;
$words{ doubles }{ join ' ', @words[ $_ .. $_ +1 ] } = undef 
    for 0 .. $#words - 1;
$words{ triples }{ join ' ', @words[ $_ .. $_ +2 ] } = undef 
    for 0 .. $#words - 2;
$words{ quads   }{ join ' ', @words[ $_ .. $_ +3 ] } = undef 
    for 0 .. $#words - 3;

say "Using words: ", total_size \%words;

my( $n,  %lookup ) = 0;
my @numbers = map $lookup{ $_ } //= ++$n, @words;

my %numbers;
$numbers{ doubles }{ join ' ', @numbers[ $_ .. $_ +1 ] } = undef 
    for 0 .. $#numbers - 1;
$numbers{ triples }{ join ' ', @numbers[ $_ .. $_ +2 ] } = undef 
    for 0 .. $#numbers - 2;
$numbers{ quads   }{ join ' ', @numbers[ $_ .. $_ +3 ] } = undef 
    for 0 .. $#numbers - 3;

say "Using numbers: ", total_size \%numbers;

say "Numbers array: ", total_size \@numbers;
say "Lookup hash:   ", total_size \%lookup;

my $start = time;
my $words = 0;
for my $size ( keys %words ) {
    exists $words{ $size }{ $_ } and $words++ for keys %{ $words{ $siz
+e } };
}
say "Lookup words:   ", time() - $start, ' seconds';

$start = time;
my $numbers = 0;
for my $size ( keys %words ) {
    exists $numbers{ $size }{ $_ } and $numbers++
        for keys %{ $numbers{ $size } };
}
say "Lookup numbers: ", time() - $start, ' seconds';

say "Lookups words: $words; numbers:$numbers";

__DATA__
There are as I see it two scalability issues in the above code.
The first of these has been addressed well by the various
suggestions to use a sliding window ($i...$i+$n on the array of words)
+.

The second is the keys themselves. You are currently using the actual 
+words
in each phrase as a key. This means that searching for all sequences o
+f N-M
words in a text with K word characters (e.g. alpha-numerics) could
concievably take up (N+N+1+...+M)*K characters for its keys alone.
The actual amount depends on the frequency of each particular word
runs: "a a a ..." will obviously use less space than "a b c d e..."
or "a..z b..za c..zab ...".

If you intend to make either N, the range from N...M or K large,
you might want to consider assigning each word in the text a integer i
+d
and composing your key out of the integers rather than the word string
+s
as you are doing now. Keys composed out of numerical indexes
would save space and possibly search time.
[download]