Results

How the data was derived

The tables below are each derived from 100 runs of the Learner. Abbreviations used in table headings is expanded as follows.

C.E. Accumulated size of counterexamples given during a run.
Equiv. No. equivalence queries put to the Teacher during a run.
Mem. No. membership queries put to the Teacher during a run.
RQ No. states found by reusing a counterexample.
RT No. transitions found by reusing a counterexample.
SQ No. states found by returning to a saved counterexample.
ST No. transitions found by returning to a saved counterexample.
m, s Mean value and standard deviation, respectively.

Expression

C.E. Eq. Mem. A RQ RT SQ ST
m s m s m s m s m s m s m s m s
Learner 26300 1440 106 .000 3250 713 5.00 .000 - - - - - - - -
Reuser 7350 1580 18.6 3.98 12200 5490 5.00 .000 1.46 .642 87.0 2.80 - - - -
Saver 5590 1010 13.0 3.49 13400 6110 5.00 .000 1.34 .934 65.4 18.7 .280 .514 27.0 17.9

When learning Expression, the number of equivalence queries is reduced by 82.5% when counterexamples are reused, and by 87.5% when counterexamples are also saved. After comparing these reduction rates with those of other test languages, we can establish that Expression is more susceptible to both extensions of the learner than any other test language. An explanation of why this is the case is attempted in the presentation of the tree language Expression.

Typed and Untyped Formula

C.E. Eq. Mem. A RQ RT SQ ST
m s m s m s m s m s m s m s m s
Learner 8180 338 168 .171 2980 138 11.0 .000 - - - - - - - -
Reuser 4450 409 76.8 6.02 3970 300 11.0 .171 6.06 1.09 86.1 5.63 - - - -
Saver 4230 431 70.9 6.87 4090 384 10.9 .239 4.91 1.61 75.4 8.87 1.08 .774 16.6 9.19

C.E. Eq. Mem. A RQ RT SQ ST
m s m s m s m s m s m s m s m s
Learner 27820 726 447 .747 11300 611 14.7 .486 - - - - - - - -
Reuser 16300 779 240 9.19 14700 979 14.8 .479 7.34 1.46 201 9.03 - - - -
Saver 15600 769 227 9.29 14800 1070 14.7 .575 6.35 1.69 182 13.4 1.18 .925 32.2 13.8

By comparing, in the results for (Typed) Formula and Random Monadic, the number of states and transitions found by reusing counterexamples, with the number of states and transitions found by saving counterexamples, resp., we observe an interesting effect: To some extent, saving counterexamples diminishes the benefit of reusing them. This can be explained as follows. If a new state is discovered, the reusing learner is likely to find some of the corresponding transitions "by coincidence" when examining one of the next counterexamples (rather than the present one). In contrast, the saving learner may discover the same transitions prior to examining the next counterexamples, even if it needs them in any case.

Interestingly, the number of equivalence queries made when learning Simple English in the reusing mode is much smaller than the corresponding number in plain mode, whereas absolutely nothing is won by saving counterexamples in this case. As expected, we can observe that the number of equivalence queries made when learning Formula in save mode is less then the corresponding number in reuse mode. However, the reduction of approximately 5.4% is unexpectedly small. As the tables show, this situation changes if we look at Expressions and Random Monadic. In these cases, both reusing and saving counterexamples lead to a considerable reduction of the number of equivalence queries.

See also the presentations of tree languages Untyped Formula and Formula.

Tall Monadic

C.E. Eq. Mem. A RQ RT SQ ST
m s m s m s m s m s m s m s m s
Learner 3120 0.0 79.0 0.0 4756 0.0 41 0.0 - - - - - - - -
Reuser 40.0 0.0 2.0 0.0 4757 0.0 41 0.0 39 0.0 39 0.0 - - - -
Saver 40.0 0.0 2.0 0.0 4757 0.0 41 0.0 39 0.0 39 0.0 0 0.0 0 0.0

The first automaton that the Learner synthesises recognises only the empty language. For this reason, the teacher can only respond by returning the single tree in Tall Monadic, but this tree contains (subtrees representing) every state and transition needed to recognise Tall Monadic. Hence, if the counterexample is reused, then only one more is necessary, namely null which signals that the target language is achieved. Since the Learner terminates when receiving this second counterexample, it will never revisit a saved counterexample, and this explains why columns SQ and ST are always empty or zero.

Random Monadic

C.E. Eq. Mem. A RQ RT SQ ST
m s m s m s m s m s m s m s m s
Learner 1550 170 51.5 2.97 831 154 39.3 2.06 - - - - - - - -
Reuser 416 144 13.5 4.16 823 182 39.8 1.29 28.3 3.77 31.8 2.84 - - - -
Saver 230 71.3 7.81 1.89 878 235 39.7 1.64 13.8 8.58 15.7 8.54 18.8 8.52 20.0 8.91

Recall that to recognise Random Monadic, at most 40 states and 39 transitions are needed. Now, to infer Random Monadic, the Learner uses approximately 52 equivalence queries, while the Reuser manages with only 14 and the Saver as little as 8. The reason for the large speed-up is that all counterexamples contains a fair amount of information, so much can be gained by reusing and/or saving them. In fact, every counterexample of height h contains (trees representing) exactly min(h,h') states and min(h,h')-1 transitions, where h' is the maximum height of the trees in Random Monadic.

Simple English

C.E. Eq. Mem. A RQ RT SQ ST
m s m s m s m s m s m s m s m s
Learner 3390 1160 71.0 0.00 1480 153 19.0 0.00 - - - - - - - -
Reuser 1450 389 14.8 3.94 2230 418 19.0 0.00 17.0 0.00 40.2 3.95 - - - -
Saver 1400 444 14.6 3.70 2230 494 19.0 0.00 17.0 0.00 40.4 3.70 0.00 0.00 0.00 0.00

Apart from Tall Monadic, Simple English is the only language where saving counterexamples does not reduce the number of equivalence queries stated. One possible explanation is that trees t and t' that represents distinct constituents, will seldom, if ever, have a shared context c such that both c[t] and c[t'] belong to Simple English. In other words, the Learner is not likely to overlook a piece information, so there is little to gain by returning to an already processed counterexample, as chances are that it is already drained of all information.

Contexts

C.E. Eq. Mem. A RQ RT SQ ST
m s m s m s m s m s m s m s m s
Learner 560 85.5 20.0 0.00 145 24.0 4.90 .302 - - - - - - - -
Reuser 382 76.2 14.3 1.77 155 26.3 4.92 .273 .450 .500 5.67 1.77 - - - -
Saver 313 65.5 11.3 2.00 157 30.3 4.86 .349 .060 .239 3.10 1.36 .610 .490 5.62 2.22

Note that in infering the tree language Contexts, the learner needs only to synthesise just below five automata, on average. The first automaton is created from the initial observation table, and this cannot be avoided, since the learner must guess the target language although it knows nothing about it, in order to provoke a counterexample from the teacher. The remaining four automatons correspond to the finding of the four states needed to recognise Contexts.