a combinational problem involving neo-gothic cadences in a serial context

I am working with some 17-tet materials, and looking into a combinational
problem. (Actually, the problem is not really specific to 17-tet, it
could refer to any et.)

Let's say we have three serial rows, X, Y, and Z in going at once,
in counterpoint, like yay:

X<. . . . . . . . . >
Y<. . . . . . . . .>
Z<. . . . . . . . .>

and let's say that we might happen to notice in the midst of this, a set
of notes like yay:

< . . . . . . . E D F . . . . . .>
< . . . . . . . B C . . . . . .>
< . . . . . . . G F . . . . . .>

Well, now, isn't that nice, we can compose out those notes into a nice
little neo-gothic cadence.

E - D - F
B ----- C
G ----- F

If these rows are scored for 3 instruments, one on each row, (and the
register in which each instrument plays a given note is free), then the
following group of row subsets:

oboe: < . . . . . . . G D F . . . . . .>
clarinet: < . . . . . . . B F . . . . . .>
bassoon: < . . . . . . . E C . . . . . .>

can also still be composed out into a properly registrated neo-gothic
cadence, using some "instrument crossing" (which will make for
timbrally interesting-sounding result):

E (bsn) D (oboe) F (clarinet)
B (clar) C (bassoon)
G (oboe) F (oboe)

Let's call the fact of this neo-gothically-compose-out-able bunch of
notes, occuring in the midst of this serial counterpoint,
"EUREKA". EUREKA could be the above cadence, at any transposition level.
The notes of EUREKA could be distributed in any fashion as long as they
can be squeezed into the right ordering. Thus the following are all valid
"finds" of EUREKA:

< . . . . . . . Gb Bb Db Fb . . . . . .>
< . . . . . . . Eb Fb . . . . . .>
< . . . . . . . Eb Cb . . . . . .>

composed out into a neo-gothic cadence:

Eb - Db - Fb
Bb - - - Cb
Gb - - - Fb

< . . . . . . . G# B A . . . . . .>
< . . . . . . . D# F# E . . . . . .>
< . . . . . . . B A . . . . . .>

composed out:

G# - F# - A
D# - - - E
B - - - A

and so on for these examples:

< . . . . . . . E A G . . . . . .>
< . . . . . . . F# G . . . . . .>
< . . . . . . . C# D . . . . . .>

< . . . . . . . A G C . . . . . .>
< . . . . . . . E Bb F C . . . . . .>
< . . . . . . . . . . . . . . . .>

and so on. . . . . . . . . . .

What I am looking to do is find a row(s) (in a given et) that, in some
combination(s) of 3 versions of itself (ie., inversions, retrogrades,
retrograde inversions or transpositions), will yield as many instances
of "EUREKA" as possible.

I am trying to write a computer program, that I can give it a row,
and it will try all the possible combinations of 3 versions of the row,
and "look around for" EUREKA in each combination. It would tally up the
number of EUREKAs it finds in each combo, and print out the highest
scoring combos.

So it might output the following "If you put the row, plus itself
transposed up 6 steps, plus an inversion transposed 3 steps, then
you can find 6 EUREKAs. That's the best you can do with this row."

So. . . . . I know how to get a program to try all the different
combinations of different row forms, that's not too much of a problem.

The problem is to get it to scan through a given combination of rows, and
look around in all sorts of ways, trying to find EUREKA. The problem
is that EUREKA might happen in all sorts of ways. The ways it could
happen, distribution between voices, etc. seem limitless. What's an
efficient way of defining EUREKA and how to "look around for it"? Is there
an efficient way to describe how to scan through a row combination
looking for EUREKA? A way efficient and tidy enough to be made into a
computable algorithm?

The only progress I've made so far is that EUREKA can be described as two
pitch-class sets, in order. In 12-tone equal they would be:

2 6 9 11 / 0 7 (0) (i.e. D F# A B / C G)

or any transposition thereof.

So, to generalize, I'm looking for an algorithm to scan through a
contrapuntal combination of rows (or any ordered segments) looking for a
set (or in this case, 2 sets) somehow distributed amongst adjacent
pitch-classes in the rows, or among the rows.

How can we teach a computer to do this? Can it be done combinationally, or
does this look like a problem that should be solved entirely in a
different way, like with neural nets or genetic algorithms?

Any ideas?

c bailey