If we know that the scripts we are running are aware as well as homogeneous, we can make this iterative process more efficient. If they are aware, they know when they succeed. If they are homogeneous, one success for each script suffices. Thus we need only execute each script until it succeeds, and the permutation embedding algorithm can skip invoking scripts that have already succeeded.

Suppose, e.g., that we have six scripts
`A`,`B`,`C`,`D`,`E`,`F`, to be executed
in that order, and that in
actuality `D` and `E` must occur before `B`; `E`
before `C`; `C` before `A`; and `A` before `F`.
Let us notate a success of `A` as `=A` (representing
unification with `A`'s postconditions) and a failure of `A` as
`!A`. Then the algorithm's execution will proceed as follows:

!A !B !C =D =E !F !A =B =C .. .. !F =A .. .. .. .. =FIn the first pass,

The worst case is that the precedences are the reverse of the
order of the list. In this case the algorithm takes *O*(*n*^{2}) executions,
where *n* is the number of scripts:

!A !B !C !D !E =F !A !B !C !D =E .. !A !B !C =D .. .. !A !B =C .. .. .. !A =B .. .. .. .. =AThere are (

The driving idea here is that

Proposition 6:We should note that this does not mean that we can discover the true precedences between scripts, just that we can discoverThe execution order for an aware, convergent, and homogeneous set of scripts need not be predeclared through precedences, but can be discovered by executing the scripts and observing their effects.