Thanks for the test cases, Dave, they definitely clarify things. I've run through a few of them, and I think the problem is more of a design issue than a bug per se.
The issue is that counters select values on the fly, which might lead to situations where it is impossible for a counter to satisfy both the NOREPLACE and NOT constraints. Consider the following example:
a b c d
t1 2 4 1 3
t2 3 1 2 4
t3 1 2 4 2
t4 4 3 3 1
Things go along nicely until it is time for d to select a value on t3. D has two items, 1 and 2, left in the pool. However, both of those have already been selected on t3 by a and b, so what should it do? Currently, the NOREPLACE rule is given precedent, so it selects from the remaining pool. However, even if NOT were given precedent and it selected 3, you still don't get a nice neat factorial because d already selected 3 on t1.
I'm fairly certain there is no way to always satisfy both NOT and NOREPLACE constraints with "on the fly" selection. Depending on the size of the matrix, there will be some probability that a counter will be painted into a corner. Perhaps we could preselect various matrices until we find one that works, but I'm not convinced that will work either since we have no way of knowing exactly a) how many trials there will be, and b) on which of the trials a given counter will be used, because trials and selections may be inserted or skipped based on data that isn't known at the start of an experiment.
I think the solution must allow you to define selection matrices. This could take the form of a multi-dimensional counter such as the following:
<counter all>
/ items = ( (1,2,3,4), (1 3 2 4), (4 2 1 3), (2 4 3 1) )
/ select = noreplace
</counter>
where subitems can be referenced with an index:
<text one>
/ items = ("a" "b" "c" "d")
/ select = counter.all.selectedvalue.1
</text>
<text two>
/ items = ("a" "b" "c" "d")
/ select = counter.all.selectedvalue.2
</text>
Or it could be accomplished by a new /select option:
<counter group>
/ items = (1,2,3,4)
/ select = noreplace
[...]
</counter>
<counter subgroup>
/ items = (1,2,3,4)
/ select = factorial(group)
</counter>
<text one>
/ items = ("a" "b" "c" "d")
/ select = counter.subgroup.selectedvalue.1
</text>
<text two>
/ items = ("a" "b" "c" "d")
/ select = counter.subgroup.selectedvalue.2
</text>
I think the first option is more flexible, explicit, and intelligible, although things get a little cumbersome as the matrix grows (a 20x20 matrix would involve a lot of typing). Possibly there are some better approaches than either of these - ideas are certainly welcome.
As a historical note, support for factorial selection has been on the feature list since it was first requested way way back in version 1.
-Sean