Solving ../../benchmarks/true/timbuk_reverseImplies.smt2...

Inference procedure has parameters:
Ice fuel: 200
Timeout: 30s
Convolution: complete


Learning problem is:

env: {
elt -> {a, b}  ;  eltlist -> {cons, nil}
}
definition:
{
(leq, P:
{() -> leq([a, y])
() -> leq([b, b])
(leq([b, a])) -> BOT}
)
(append, F:
{() -> append([nil, l2, l2])
(append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)])}
(append([_kd, _ld, _md]) /\ append([_kd, _ld, _nd])) -> eq_eltlist([_md, _nd])
)
(reverse, F:
{() -> reverse([nil, nil])
(append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd])}
(reverse([_qd, _rd]) /\ reverse([_qd, _sd])) -> eq_eltlist([_rd, _sd])
)
(insert, F:
{() -> insert([x, nil, cons(x, nil)])
(insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)])
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))])}
(insert([_ud, _vd, _wd]) /\ insert([_ud, _vd, _xd])) -> eq_eltlist([_wd, _xd])
)
(sort, F:
{() -> sort([nil, nil])
(insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd])}
(sort([_ae, _be]) /\ sort([_ae, _ce])) -> eq_eltlist([_be, _ce])
)
(sorted, P:
{() -> sorted([cons(x, nil)])
() -> sorted([nil])}
)
}

properties:
{(reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee])}


over-approximation: {append, insert, reverse, sort}
under-approximation: {leq, sort}

Clause system for inference is:

{
() -> append([nil, l2, l2]) -> 0  ;  () -> insert([x, nil, cons(x, nil)]) -> 0  ;  () -> leq([a, y]) -> 0  ;  () -> leq([b, b]) -> 0  ;  () -> reverse([nil, nil]) -> 0  ;  () -> sort([nil, nil]) -> 0  ;  () -> sorted([cons(x, nil)]) -> 0  ;  () -> sorted([nil]) -> 0  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 0  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 0  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 0  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 0  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 0  ;  (leq([b, a])) -> BOT -> 0  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 0
}


Solving took 30.188636 seconds.
DontKnow. Stopped because: timeout
Working model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6577, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6587, q_gen_6588, q_gen_6589, q_gen_6590, q_gen_6603, q_gen_6604, q_gen_6605, q_gen_6606, q_gen_6607, q_gen_6608, q_gen_6609, q_gen_6610, q_gen_6615, q_gen_6616, q_gen_6617, q_gen_6618, q_gen_6619, q_gen_6631, q_gen_6632, q_gen_6633, q_gen_6638, q_gen_6639, q_gen_6640, q_gen_6641, q_gen_6642, q_gen_6657, q_gen_6658, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665, q_gen_6677, q_gen_6678, q_gen_6679, q_gen_6680, q_gen_6689, q_gen_6690, q_gen_6691, q_gen_6692, q_gen_6693, q_gen_6694, q_gen_6695, q_gen_6696, q_gen_6704, q_gen_6705, q_gen_6706, q_gen_6707, q_gen_6708, q_gen_6709, q_gen_6710, q_gen_6711, q_gen_6712, q_gen_6716, q_gen_6717, q_gen_6718, q_gen_6719, q_gen_6720, q_gen_6723, q_gen_6724, q_gen_6725, q_gen_6726, q_gen_6727, q_gen_6728, q_gen_6729, q_gen_6730, q_gen_6731, q_gen_6732, q_gen_6733, q_gen_6734, q_gen_6737, q_gen_6738, q_gen_6739, q_gen_6740, q_gen_6741, q_gen_6742, q_gen_6743, q_gen_6744, q_gen_6745, q_gen_6749, q_gen_6750, q_gen_6751, q_gen_6752, q_gen_6753, q_gen_6754, q_gen_6755, q_gen_6756, q_gen_6757, q_gen_6763, q_gen_6764, q_gen_6765, q_gen_6766, q_gen_6767, q_gen_6768, q_gen_6769, q_gen_6770, q_gen_6771, q_gen_6772, q_gen_6773, q_gen_6774, q_gen_6775, q_gen_6776, q_gen_6777, q_gen_6778, q_gen_6779, q_gen_6780, q_gen_6781, q_gen_6782, q_gen_6783, q_gen_6784, q_gen_6785, q_gen_6786, q_gen_6787},
Q_f={},
Delta=
{
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6618
<cons>(q_gen_6618, q_gen_6607) -> q_gen_6641
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6730
<nil, nil>() -> q_gen_6578
<nil, b>() -> q_gen_6579
<b, nil>() -> q_gen_6580
<b, b>() -> q_gen_6581
<nil, a>() -> q_gen_6588
<a, nil>() -> q_gen_6589
<a, a>() -> q_gen_6590
<cons, cons>(q_gen_6590, q_gen_6589, q_gen_6588, q_gen_6578) -> q_gen_6605
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6606
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6609
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6616
<cons, b>(q_gen_6618, q_gen_6607) -> q_gen_6617
<b, cons>(q_gen_6618, q_gen_6607) -> q_gen_6619
<cons, a>(q_gen_6618, q_gen_6607) -> q_gen_6632
<a, cons>(q_gen_6618, q_gen_6607) -> q_gen_6633
<cons, cons>(q_gen_6581, q_gen_6619, q_gen_6617, q_gen_6616) -> q_gen_6639
<cons, b>(q_gen_6618, q_gen_6641) -> q_gen_6640
<b, cons>(q_gen_6618, q_gen_6641) -> q_gen_6642
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6679
<nil, cons>(q_gen_6618, q_gen_6641) -> q_gen_6696
<nil, cons>(q_gen_6618, q_gen_6607) -> q_gen_6712
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6726
<a, b>() -> q_gen_6727
<b, a>() -> q_gen_6740
<nil, nil, nil>() -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6577
<nil, cons, cons>(q_gen_6590, q_gen_6589, q_gen_6588, q_gen_6578) -> q_gen_6587
<cons, nil, cons>(q_gen_6590, q_gen_6589, q_gen_6588, q_gen_6578) -> q_gen_6603
<cons, nil, cons>(q_gen_6581, q_gen_6609, q_gen_6606, q_gen_6605) -> q_gen_6604
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6610
<nil, cons, cons>(q_gen_6581, q_gen_6619, q_gen_6617, q_gen_6616) -> q_gen_6615
<cons, nil, cons>(q_gen_6590, q_gen_6633, q_gen_6632, q_gen_6616) -> q_gen_6631
<nil, cons, cons>(q_gen_6581, q_gen_6642, q_gen_6640, q_gen_6639) -> q_gen_6638
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6658) -> q_gen_6657
<nil, nil, cons>(q_gen_6618, q_gen_6607) -> q_gen_6658
<nil, nil, b>() -> q_gen_6659
<nil, b, cons>(q_gen_6618, q_gen_6607) -> q_gen_6660
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6618, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, b, cons>(q_gen_6618, q_gen_6607) -> q_gen_6664
<b, b, b>() -> q_gen_6665
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6677
<cons, nil, cons>(q_gen_6581, q_gen_6609, q_gen_6579, q_gen_6679) -> q_gen_6678
<nil, cons, cons>(q_gen_6581, q_gen_6609, q_gen_6579, q_gen_6679) -> q_gen_6680
<cons, cons, cons>(q_gen_6694, q_gen_6693, q_gen_6663, q_gen_6692, q_gen_6691, q_gen_6690, q_gen_6659, q_gen_6677) -> q_gen_6689
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6690
<nil, a, b>() -> q_gen_6691
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6692
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6693
<b, a, b>() -> q_gen_6694
<nil, cons, cons>(q_gen_6581, q_gen_6642, q_gen_6579, q_gen_6696) -> q_gen_6695
<cons, cons, cons>(q_gen_6710, q_gen_6709, q_gen_6708, q_gen_6707, q_gen_6706, q_gen_6660, q_gen_6705, q_gen_6658) -> q_gen_6704
<nil, nil, a>() -> q_gen_6705
<nil, b, a>() -> q_gen_6706
<a, nil, cons>(q_gen_6618, q_gen_6607) -> q_gen_6707
<a, nil, a>() -> q_gen_6708
<a, b, cons>(q_gen_6618, q_gen_6607) -> q_gen_6709
<a, b, a>() -> q_gen_6710
<nil, cons, cons>(q_gen_6590, q_gen_6633, q_gen_6588, q_gen_6712) -> q_gen_6711
<cons, cons, cons>(q_gen_6720, q_gen_6719, q_gen_6708, q_gen_6718, q_gen_6717, q_gen_6690, q_gen_6705, q_gen_6677) -> q_gen_6716
<nil, a, a>() -> q_gen_6717
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6718
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6719
<a, a, a>() -> q_gen_6720
<nil, cons, cons>(q_gen_6581, q_gen_6609, q_gen_6606, q_gen_6605) -> q_gen_6723
<cons, cons, cons>(q_gen_6665, q_gen_6733, q_gen_6732, q_gen_6731, q_gen_6661, q_gen_6729, q_gen_6728, q_gen_6725) -> q_gen_6724
<nil, cons, cons>(q_gen_6727, q_gen_6726, q_gen_6579, q_gen_6679) -> q_gen_6725
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6728
<nil, b, cons>(q_gen_6618, q_gen_6730) -> q_gen_6729
<b, cons, cons>(q_gen_6727, q_gen_6726, q_gen_6579, q_gen_6679) -> q_gen_6731
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6732
<b, b, cons>(q_gen_6618, q_gen_6730) -> q_gen_6733
<nil, cons, cons>(q_gen_6727, q_gen_6589, q_gen_6579, q_gen_6578) -> q_gen_6734
<nil, cons, cons>(q_gen_6590, q_gen_6633, q_gen_6632, q_gen_6616) -> q_gen_6737
<cons, cons, cons>(q_gen_6720, q_gen_6745, q_gen_6744, q_gen_6743, q_gen_6717, q_gen_6742, q_gen_6741, q_gen_6739) -> q_gen_6738
<nil, cons, cons>(q_gen_6740, q_gen_6619, q_gen_6588, q_gen_6712) -> q_gen_6739
<nil, cons, a>(q_gen_6618, q_gen_6607) -> q_gen_6741
<nil, a, cons>(q_gen_6608, q_gen_6641) -> q_gen_6742
<a, cons, cons>(q_gen_6740, q_gen_6619, q_gen_6588, q_gen_6712) -> q_gen_6743
<a, cons, a>(q_gen_6618, q_gen_6607) -> q_gen_6744
<a, a, cons>(q_gen_6608, q_gen_6641) -> q_gen_6745
<cons, cons, cons>(q_gen_6665, q_gen_6755, q_gen_6663, q_gen_6754, q_gen_6753, q_gen_6752, q_gen_6751, q_gen_6750) -> q_gen_6749
<cons, nil, cons>(q_gen_6581, q_gen_6619, q_gen_6579, q_gen_6712) -> q_gen_6750
<cons, nil, b>(q_gen_6618, q_gen_6607) -> q_gen_6751
<cons, b, cons>(q_gen_6581, q_gen_6619, q_gen_6579, q_gen_6712) -> q_gen_6752
<cons, b, b>(q_gen_6618, q_gen_6607) -> q_gen_6753
<b, nil, cons>(q_gen_6618, q_gen_6641) -> q_gen_6754
<b, b, cons>(q_gen_6618, q_gen_6641) -> q_gen_6755
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6753, q_gen_6757, q_gen_6751, q_gen_6577) -> q_gen_6756
<cons, b, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6757
<cons, cons, cons>(q_gen_6694, q_gen_6765, q_gen_6663, q_gen_6662, q_gen_6691, q_gen_6764, q_gen_6659, q_gen_6658) -> q_gen_6763
<nil, a, cons>(q_gen_6618, q_gen_6607) -> q_gen_6764
<b, a, cons>(q_gen_6618, q_gen_6607) -> q_gen_6765
<cons, cons, cons>(q_gen_6694, q_gen_6769, q_gen_6663, q_gen_6754, q_gen_6768, q_gen_6767, q_gen_6751, q_gen_6750) -> q_gen_6766
<cons, a, cons>(q_gen_6581, q_gen_6619, q_gen_6579, q_gen_6712) -> q_gen_6767
<cons, a, b>(q_gen_6618, q_gen_6607) -> q_gen_6768
<b, a, cons>(q_gen_6618, q_gen_6641) -> q_gen_6769
<cons, cons, cons>(q_gen_6710, q_gen_6774, q_gen_6708, q_gen_6773, q_gen_6772, q_gen_6752, q_gen_6771, q_gen_6750) -> q_gen_6770
<cons, nil, a>(q_gen_6618, q_gen_6607) -> q_gen_6771
<cons, b, a>(q_gen_6618, q_gen_6607) -> q_gen_6772
<a, nil, cons>(q_gen_6618, q_gen_6641) -> q_gen_6773
<a, b, cons>(q_gen_6618, q_gen_6641) -> q_gen_6774
<cons, cons, cons>(q_gen_6720, q_gen_6777, q_gen_6708, q_gen_6773, q_gen_6776, q_gen_6767, q_gen_6771, q_gen_6750) -> q_gen_6775
<cons, a, a>(q_gen_6618, q_gen_6607) -> q_gen_6776
<a, a, cons>(q_gen_6618, q_gen_6641) -> q_gen_6777
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6781, q_gen_6780, q_gen_6661, q_gen_6660, q_gen_6779, q_gen_6610) -> q_gen_6778
<nil, cons, b>(q_gen_6618, q_gen_6607) -> q_gen_6779
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6780
<b, cons, b>(q_gen_6618, q_gen_6607) -> q_gen_6781
<cons, cons, cons>(q_gen_6665, q_gen_6755, q_gen_6781, q_gen_6784, q_gen_6753, q_gen_6752, q_gen_6783, q_gen_6657) -> q_gen_6782
<cons, cons, b>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6783
<b, cons, cons>(q_gen_6581, q_gen_6619, q_gen_6579, q_gen_6712) -> q_gen_6784
<cons, cons, cons>(q_gen_6710, q_gen_6774, q_gen_6744, q_gen_6787, q_gen_6772, q_gen_6752, q_gen_6786, q_gen_6657) -> q_gen_6785
<cons, cons, a>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6786
<a, cons, cons>(q_gen_6581, q_gen_6619, q_gen_6579, q_gen_6712) -> q_gen_6787
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6564, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568, q_gen_6574, q_gen_6575, q_gen_6576, q_gen_6585, q_gen_6586, q_gen_6591, q_gen_6592, q_gen_6593, q_gen_6594, q_gen_6598, q_gen_6599, q_gen_6600, q_gen_6601, q_gen_6602, q_gen_6620, q_gen_6621, q_gen_6622, q_gen_6623, q_gen_6643, q_gen_6644, q_gen_6645, q_gen_6646, q_gen_6647, q_gen_6648, q_gen_6649, q_gen_6650, q_gen_6651, q_gen_6671, q_gen_6672, q_gen_6685, q_gen_6701},
Q_f={},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<a>() -> q_gen_6586
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6602
<cons>(q_gen_6586, q_gen_6561) -> q_gen_6650
<cons>(q_gen_6562, q_gen_6602) -> q_gen_6672
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, a>() -> q_gen_6568
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6575
<a, a>() -> q_gen_6576
<nil, b>() -> q_gen_6592
<b, b>() -> q_gen_6593
<cons, cons>(q_gen_6593, q_gen_6567, q_gen_6592, q_gen_6565) -> q_gen_6599
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6600
<a, cons>(q_gen_6562, q_gen_6602) -> q_gen_6601
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6621
<b, cons>(q_gen_6562, q_gen_6602) -> q_gen_6622
<cons, cons>(q_gen_6647, q_gen_6646, q_gen_6592, q_gen_6645) -> q_gen_6644
<nil, cons>(q_gen_6586, q_gen_6561) -> q_gen_6645
<a, cons>(q_gen_6586, q_gen_6561) -> q_gen_6646
<a, b>() -> q_gen_6647
<cons, b>(q_gen_6586, q_gen_6561) -> q_gen_6648
<b, cons>(q_gen_6562, q_gen_6650) -> q_gen_6649
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6564
<b, cons, cons>(q_gen_6576, q_gen_6575, q_gen_6566, q_gen_6565) -> q_gen_6574
<a, nil, cons>(q_gen_6586, q_gen_6561) -> q_gen_6585
<b, cons, cons>(q_gen_6593, q_gen_6567, q_gen_6592, q_gen_6565) -> q_gen_6591
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6594
<b, cons, cons>(q_gen_6576, q_gen_6601, q_gen_6600, q_gen_6599) -> q_gen_6598
<b, cons, cons>(q_gen_6593, q_gen_6622, q_gen_6621, q_gen_6599) -> q_gen_6620
<b, nil, cons>(q_gen_6586, q_gen_6602) -> q_gen_6623
<b, cons, cons>(q_gen_6593, q_gen_6649, q_gen_6648, q_gen_6644) -> q_gen_6643
<a, nil, cons>(q_gen_6586, q_gen_6650) -> q_gen_6651
<b, nil, cons>(q_gen_6562, q_gen_6672) -> q_gen_6671
<b, cons, cons>(q_gen_6647, q_gen_6575, q_gen_6592, q_gen_6565) -> q_gen_6685
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6701
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6559, q_gen_6573, q_gen_6584},
Q_f={},
Delta=
{
<b, b>() -> q_gen_6558
<a, b>() -> q_gen_6559
<b, a>() -> q_gen_6573
<a, a>() -> q_gen_6584
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6611, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6634, q_gen_6635, q_gen_6636, q_gen_6637, q_gen_6666, q_gen_6667, q_gen_6668, q_gen_6669, q_gen_6670, q_gen_6681, q_gen_6682, q_gen_6683, q_gen_6684, q_gen_6697, q_gen_6698, q_gen_6699, q_gen_6700, q_gen_6713, q_gen_6714, q_gen_6715, q_gen_6721, q_gen_6722, q_gen_6735, q_gen_6736, q_gen_6746, q_gen_6747, q_gen_6748, q_gen_6758, q_gen_6759, q_gen_6760, q_gen_6761, q_gen_6762},
Q_f={},
Delta=
{
<nil>() -> q_gen_6668
<b>() -> q_gen_6669
<a>() -> q_gen_6683
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6699
<nil, nil>() -> q_gen_6557
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6611
<nil, b>() -> q_gen_6612
<b, nil>() -> q_gen_6613
<b, b>() -> q_gen_6614
<cons, cons>(q_gen_6637, q_gen_6636, q_gen_6635, q_gen_6557) -> q_gen_6634
<nil, a>() -> q_gen_6635
<a, nil>() -> q_gen_6636
<a, a>() -> q_gen_6637
<cons, cons>(q_gen_6614, q_gen_6670, q_gen_6667, q_gen_6611) -> q_gen_6666
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6667
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6670
<cons, cons>(q_gen_6614, q_gen_6684, q_gen_6612, q_gen_6682) -> q_gen_6681
<nil, cons>(q_gen_6683, q_gen_6668) -> q_gen_6682
<b, cons>(q_gen_6683, q_gen_6668) -> q_gen_6684
<cons, cons>(q_gen_6614, q_gen_6700, q_gen_6612, q_gen_6698) -> q_gen_6697
<nil, cons>(q_gen_6669, q_gen_6699) -> q_gen_6698
<b, cons>(q_gen_6669, q_gen_6699) -> q_gen_6700
<cons, cons>(q_gen_6637, q_gen_6715, q_gen_6635, q_gen_6714) -> q_gen_6713
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6714
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6715
<cons, cons>(q_gen_6722, q_gen_6670, q_gen_6635, q_gen_6714) -> q_gen_6721
<b, a>() -> q_gen_6722
<cons, cons>(q_gen_6736, q_gen_6636, q_gen_6612, q_gen_6557) -> q_gen_6735
<a, b>() -> q_gen_6736
<cons, cons>(q_gen_6722, q_gen_6613, q_gen_6635, q_gen_6557) -> q_gen_6746
<cons, cons>(q_gen_6722, q_gen_6670, q_gen_6748, q_gen_6611) -> q_gen_6747
<cons, a>(q_gen_6669, q_gen_6668) -> q_gen_6748
<cons, cons>(q_gen_6736, q_gen_6715, q_gen_6667, q_gen_6611) -> q_gen_6758
<cons, cons>(q_gen_6614, q_gen_6670, q_gen_6762, q_gen_6760) -> q_gen_6759
<cons, cons>(q_gen_6736, q_gen_6636, q_gen_6667, q_gen_6761) -> q_gen_6760
<cons, nil>(q_gen_6669, q_gen_6668) -> q_gen_6761
<cons, b>(q_gen_6683, q_gen_6699) -> q_gen_6762
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6569, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6595, q_gen_6596, q_gen_6597, q_gen_6624, q_gen_6625, q_gen_6626, q_gen_6627, q_gen_6628, q_gen_6629, q_gen_6630, q_gen_6652, q_gen_6653, q_gen_6654, q_gen_6655, q_gen_6656, q_gen_6673, q_gen_6674, q_gen_6675, q_gen_6676, q_gen_6686, q_gen_6687, q_gen_6688, q_gen_6702, q_gen_6703},
Q_f={},
Delta=
{
<nil>() -> q_gen_6626
<b>() -> q_gen_6627
<a>() -> q_gen_6654
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6675
<nil, nil>() -> q_gen_6556
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6569
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
<cons, cons>(q_gen_6597, q_gen_6596, q_gen_6570, q_gen_6556) -> q_gen_6595
<a, nil>() -> q_gen_6596
<a, b>() -> q_gen_6597
<cons, cons>(q_gen_6630, q_gen_6629, q_gen_6628, q_gen_6625) -> q_gen_6624
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6625
<nil, a>() -> q_gen_6628
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6629
<b, a>() -> q_gen_6630
<cons, cons>(q_gen_6656, q_gen_6655, q_gen_6628, q_gen_6653) -> q_gen_6652
<nil, cons>(q_gen_6654, q_gen_6626) -> q_gen_6653
<a, cons>(q_gen_6654, q_gen_6626) -> q_gen_6655
<a, a>() -> q_gen_6656
<cons, cons>(q_gen_6572, q_gen_6676, q_gen_6570, q_gen_6674) -> q_gen_6673
<nil, cons>(q_gen_6627, q_gen_6675) -> q_gen_6674
<b, cons>(q_gen_6627, q_gen_6675) -> q_gen_6676
<cons, cons>(q_gen_6630, q_gen_6571, q_gen_6628, q_gen_6556) -> q_gen_6686
<cons, cons>(q_gen_6572, q_gen_6629, q_gen_6688, q_gen_6569) -> q_gen_6687
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6688
<cons, cons>(q_gen_6630, q_gen_6629, q_gen_6703, q_gen_6569) -> q_gen_6702
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6703
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6554, q_gen_6555, q_gen_6582, q_gen_6583},
Q_f={},
Delta=
{
<nil>() -> q_gen_6553
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6554
<b>() -> q_gen_6555
<cons>(q_gen_6583, q_gen_6553) -> q_gen_6582
<a>() -> q_gen_6583
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

-------------------
STEPS:
-------------------------------------------
Step 0, which took 0.004671 s (model generation: 0.004144,  model checking: 0.000527):

Model:
|_
{
append -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0  ;  () -> insert([x, nil, cons(x, nil)]) -> 0  ;  () -> leq([a, y]) -> 0  ;  () -> leq([b, b]) -> 0  ;  () -> reverse([nil, nil]) -> 0  ;  () -> sort([nil, nil]) -> 0  ;  () -> sorted([cons(x, nil)]) -> 0  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 1  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1  ;  (leq([b, a])) -> BOT -> 1  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 1
}
Sat witness: Yes: (() -> sorted([nil]), {

})

-------------------------------------------
Step 1, which took 0.003573 s (model generation: 0.003527,  model checking: 0.000046):

Model:
|_
{
append -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553},
Q_f={q_gen_6553},
Delta=
{
<nil>() -> q_gen_6553
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0  ;  () -> insert([x, nil, cons(x, nil)]) -> 0  ;  () -> leq([a, y]) -> 0  ;  () -> leq([b, b]) -> 0  ;  () -> reverse([nil, nil]) -> 0  ;  () -> sort([nil, nil]) -> 0  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 1  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1  ;  (leq([b, a])) -> BOT -> 1  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 1
}
Sat witness: Yes: (() -> sorted([cons(x, nil)]), {
x -> b
})

-------------------------------------------
Step 2, which took 0.003498 s (model generation: 0.003415,  model checking: 0.000083):

Model:
|_
{
append -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0  ;  () -> insert([x, nil, cons(x, nil)]) -> 0  ;  () -> leq([a, y]) -> 0  ;  () -> leq([b, b]) -> 0  ;  () -> reverse([nil, nil]) -> 0  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 1  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1  ;  (leq([b, a])) -> BOT -> 1  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 1
}
Sat witness: Yes: (() -> sort([nil, nil]), {

})

-------------------------------------------
Step 3, which took 0.003417 s (model generation: 0.003359,  model checking: 0.000058):

Model:
|_
{
append -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556},
Q_f={q_gen_6556},
Delta=
{
<nil, nil>() -> q_gen_6556
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0  ;  () -> insert([x, nil, cons(x, nil)]) -> 0  ;  () -> leq([a, y]) -> 0  ;  () -> leq([b, b]) -> 0  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 1  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1  ;  (leq([b, a])) -> BOT -> 1  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 1
}
Sat witness: Yes: (() -> reverse([nil, nil]), {

})

-------------------------------------------
Step 4, which took 0.003490 s (model generation: 0.003470,  model checking: 0.000020):

Model:
|_
{
append -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556},
Q_f={q_gen_6556},
Delta=
{
<nil, nil>() -> q_gen_6556
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0  ;  () -> insert([x, nil, cons(x, nil)]) -> 0  ;  () -> leq([a, y]) -> 0  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 1  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1  ;  (leq([b, a])) -> BOT -> 1  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 1
}
Sat witness: Yes: (() -> leq([b, b]), {

})

-------------------------------------------
Step 5, which took 0.004425 s (model generation: 0.004381,  model checking: 0.000044):

Model:
|_
{
append -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558},
Q_f={q_gen_6558},
Delta=
{
<b, b>() -> q_gen_6558
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556},
Q_f={q_gen_6556},
Delta=
{
<nil, nil>() -> q_gen_6556
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0  ;  () -> insert([x, nil, cons(x, nil)]) -> 0  ;  () -> leq([a, y]) -> 3  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 1  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1  ;  (leq([b, a])) -> BOT -> 1  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 1
}
Sat witness: Yes: (() -> leq([a, y]), {
y -> b
})

-------------------------------------------
Step 6, which took 0.008027 s (model generation: 0.007747,  model checking: 0.000280):

Model:
|_
{
append -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558},
Q_f={q_gen_6558},
Delta=
{
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556},
Q_f={q_gen_6556},
Delta=
{
<nil, nil>() -> q_gen_6556
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0  ;  () -> insert([x, nil, cons(x, nil)]) -> 3  ;  () -> leq([a, y]) -> 3  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 1  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1  ;  (leq([b, a])) -> BOT -> 1  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 1
}
Sat witness: Yes: (() -> insert([x, nil, cons(x, nil)]), {
x -> b
})

-------------------------------------------
Step 7, which took 0.010859 s (model generation: 0.010539,  model checking: 0.000320):

Model:
|_
{
append -> 
{{{
Q={},
Q_f={},
Delta=
{

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558},
Q_f={q_gen_6558},
Delta=
{
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556},
Q_f={q_gen_6556},
Delta=
{
<nil, nil>() -> q_gen_6556
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3  ;  () -> insert([x, nil, cons(x, nil)]) -> 3  ;  () -> leq([a, y]) -> 3  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 1  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1  ;  (leq([b, a])) -> BOT -> 1  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 1
}
Sat witness: Yes: (() -> append([nil, l2, l2]), {
l2 -> nil
})

-------------------------------------------
Step 8, which took 0.008742 s (model generation: 0.006874,  model checking: 0.001868):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563},
Q_f={q_gen_6563},
Delta=
{
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558},
Q_f={q_gen_6558},
Delta=
{
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556},
Q_f={q_gen_6556},
Delta=
{
<nil, nil>() -> q_gen_6556
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3  ;  () -> insert([x, nil, cons(x, nil)]) -> 3  ;  () -> leq([a, y]) -> 3  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 1  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4  ;  (leq([b, a])) -> BOT -> 2  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 2
}
Sat witness: Yes: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 9, which took 0.008545 s (model generation: 0.008407,  model checking: 0.000138):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563},
Q_f={q_gen_6563},
Delta=
{
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, a>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558},
Q_f={q_gen_6558},
Delta=
{
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556},
Q_f={q_gen_6556},
Delta=
{
<nil, nil>() -> q_gen_6556
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3  ;  () -> insert([x, nil, cons(x, nil)]) -> 3  ;  () -> leq([a, y]) -> 3  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 1  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 4  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4  ;  (leq([b, a])) -> BOT -> 2  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 2
}
Sat witness: Yes: ((insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]), {
_yd -> nil  ;  _zd -> cons(b, nil)  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 10, which took 0.010204 s (model generation: 0.006809,  model checking: 0.003395):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563},
Q_f={q_gen_6563},
Delta=
{
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, a>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558},
Q_f={q_gen_6558},
Delta=
{
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3  ;  () -> insert([x, nil, cons(x, nil)]) -> 3  ;  () -> leq([a, y]) -> 3  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 1  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 4  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 4  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4  ;  (leq([b, a])) -> BOT -> 2  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 2
}
Sat witness: Yes: ((insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]), {
_td -> cons(b, nil)  ;  x -> b  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 11, which took 0.008489 s (model generation: 0.008093,  model checking: 0.000396):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563},
Q_f={q_gen_6563},
Delta=
{
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558},
Q_f={q_gen_6558},
Delta=
{
<a, b>() -> q_gen_6558
<b, a>() -> q_gen_6558
<b, b>() -> q_gen_6558
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3  ;  () -> insert([x, nil, cons(x, nil)]) -> 3  ;  () -> leq([a, y]) -> 3  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 1  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 4  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 4  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 4  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4  ;  (leq([b, a])) -> BOT -> 2  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 2
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> nil  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 12, which took 0.013339 s (model generation: 0.013045,  model checking: 0.000294):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581},
Q_f={q_gen_6563},
Delta=
{
<nil, nil>() -> q_gen_6578
<nil, b>() -> q_gen_6579
<b, nil>() -> q_gen_6580
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558},
Q_f={q_gen_6558},
Delta=
{
<a, b>() -> q_gen_6558
<b, a>() -> q_gen_6558
<b, b>() -> q_gen_6558
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3  ;  () -> insert([x, nil, cons(x, nil)]) -> 3  ;  () -> leq([a, y]) -> 3  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 3  ;  () -> sorted([nil]) -> 3  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 2  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 4  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 4  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 4  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 3
}
Sat witness: Yes: ((leq([b, a])) -> BOT, {

})

-------------------------------------------
Step 13, which took 0.008890 s (model generation: 0.008743,  model checking: 0.000147):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581},
Q_f={q_gen_6563},
Delta=
{
<nil, nil>() -> q_gen_6578
<nil, b>() -> q_gen_6579
<b, nil>() -> q_gen_6580
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3  ;  () -> insert([x, nil, cons(x, nil)]) -> 3  ;  () -> leq([a, y]) -> 3  ;  () -> leq([b, b]) -> 3  ;  () -> reverse([nil, nil]) -> 3  ;  () -> sort([nil, nil]) -> 3  ;  () -> sorted([cons(x, nil)]) -> 6  ;  () -> sorted([nil]) -> 4  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 3  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 4  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 4  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 4  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 4
}
Sat witness: Yes: (() -> sorted([cons(x, nil)]), {
x -> a
})

-------------------------------------------
Step 14, which took 0.008214 s (model generation: 0.006871,  model checking: 0.001343):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581},
Q_f={q_gen_6563},
Delta=
{
<nil, nil>() -> q_gen_6578
<nil, b>() -> q_gen_6579
<b, nil>() -> q_gen_6580
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3  ;  () -> insert([x, nil, cons(x, nil)]) -> 3  ;  () -> leq([a, y]) -> 6  ;  () -> leq([b, b]) -> 4  ;  () -> reverse([nil, nil]) -> 4  ;  () -> sort([nil, nil]) -> 4  ;  () -> sorted([cons(x, nil)]) -> 6  ;  () -> sorted([nil]) -> 4  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 4  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 4  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 4  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 4  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 4
}
Sat witness: Yes: (() -> leq([a, y]), {
y -> a
})

-------------------------------------------
Step 15, which took 0.009705 s (model generation: 0.008426,  model checking: 0.001279):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581},
Q_f={q_gen_6563},
Delta=
{
<nil, nil>() -> q_gen_6578
<nil, b>() -> q_gen_6579
<b, nil>() -> q_gen_6580
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3  ;  () -> insert([x, nil, cons(x, nil)]) -> 6  ;  () -> leq([a, y]) -> 6  ;  () -> leq([b, b]) -> 4  ;  () -> reverse([nil, nil]) -> 4  ;  () -> sort([nil, nil]) -> 4  ;  () -> sorted([cons(x, nil)]) -> 6  ;  () -> sorted([nil]) -> 4  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 4  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 4  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 4  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 4  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 4
}
Sat witness: Yes: (() -> insert([x, nil, cons(x, nil)]), {
x -> a
})

-------------------------------------------
Step 16, which took 0.017575 s (model generation: 0.014031,  model checking: 0.003544):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581},
Q_f={q_gen_6563},
Delta=
{
<nil, nil>() -> q_gen_6578
<nil, b>() -> q_gen_6579
<b, nil>() -> q_gen_6580
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6  ;  () -> insert([x, nil, cons(x, nil)]) -> 6  ;  () -> leq([a, y]) -> 6  ;  () -> leq([b, b]) -> 4  ;  () -> reverse([nil, nil]) -> 4  ;  () -> sort([nil, nil]) -> 4  ;  () -> sorted([cons(x, nil)]) -> 6  ;  () -> sorted([nil]) -> 4  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 4  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 4  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 4  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 4  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 4
}
Sat witness: Yes: (() -> append([nil, l2, l2]), {
l2 -> cons(a, nil)
})

-------------------------------------------
Step 17, which took 0.026812 s (model generation: 0.014666,  model checking: 0.012146):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581},
Q_f={q_gen_6563},
Delta=
{
<nil, nil>() -> q_gen_6578
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, nil>() -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6  ;  () -> insert([x, nil, cons(x, nil)]) -> 6  ;  () -> leq([a, y]) -> 6  ;  () -> leq([b, b]) -> 4  ;  () -> reverse([nil, nil]) -> 4  ;  () -> sort([nil, nil]) -> 4  ;  () -> sorted([cons(x, nil)]) -> 6  ;  () -> sorted([nil]) -> 4  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 4  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 4  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 4  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 4  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 5
}
Sat witness: Yes: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> b  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 18, which took 0.018452 s (model generation: 0.014411,  model checking: 0.004041):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581},
Q_f={q_gen_6563},
Delta=
{
<nil, nil>() -> q_gen_6578
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, nil>() -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<b, nil>() -> q_gen_6571
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6  ;  () -> insert([x, nil, cons(x, nil)]) -> 6  ;  () -> leq([a, y]) -> 6  ;  () -> leq([b, b]) -> 4  ;  () -> reverse([nil, nil]) -> 4  ;  () -> sort([nil, nil]) -> 4  ;  () -> sorted([cons(x, nil)]) -> 6  ;  () -> sorted([nil]) -> 4  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 4  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 4  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 4  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 7  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 5
}
Sat witness: Yes: ((insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]), {
_yd -> nil  ;  _zd -> cons(b, nil)  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 19, which took 0.032299 s (model generation: 0.016381,  model checking: 0.015918):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581},
Q_f={q_gen_6563},
Delta=
{
<nil, nil>() -> q_gen_6578
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, nil>() -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6  ;  () -> insert([x, nil, cons(x, nil)]) -> 6  ;  () -> leq([a, y]) -> 6  ;  () -> leq([b, b]) -> 4  ;  () -> reverse([nil, nil]) -> 4  ;  () -> sort([nil, nil]) -> 4  ;  () -> sorted([cons(x, nil)]) -> 6  ;  () -> sorted([nil]) -> 4  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 4  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 4  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 7  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 7  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 5
}
Sat witness: Yes: ((insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]), {
_td -> cons(b, cons(b, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 20, which took 0.017213 s (model generation: 0.010459,  model checking: 0.006754):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581},
Q_f={q_gen_6563},
Delta=
{
<nil, nil>() -> q_gen_6578
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, nil>() -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6  ;  () -> insert([x, nil, cons(x, nil)]) -> 6  ;  () -> leq([a, y]) -> 6  ;  () -> leq([b, b]) -> 4  ;  () -> reverse([nil, nil]) -> 4  ;  () -> sort([nil, nil]) -> 4  ;  () -> sorted([cons(x, nil)]) -> 6  ;  () -> sorted([nil]) -> 4  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 4  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 7  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 7  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 7  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 5
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(a, nil)  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> cons(a, nil)
})

-------------------------------------------
Step 21, which took 0.014557 s (model generation: 0.014136,  model checking: 0.000421):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557},
Q_f={q_gen_6557},
Delta=
{
<nil, nil>() -> q_gen_6557
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6  ;  () -> insert([x, nil, cons(x, nil)]) -> 6  ;  () -> leq([a, y]) -> 6  ;  () -> leq([b, b]) -> 4  ;  () -> reverse([nil, nil]) -> 4  ;  () -> sort([nil, nil]) -> 4  ;  () -> sorted([cons(x, nil)]) -> 6  ;  () -> sorted([nil]) -> 4  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 7  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 7  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 7  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 7  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7  ;  (leq([b, a])) -> BOT -> 5  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 5
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> nil  ;  _pd -> cons(b, nil)  ;  h1 -> b  ;  t1 -> nil
})

-------------------------------------------
Step 22, which took 0.031417 s (model generation: 0.010727,  model checking: 0.020690):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, b>() -> q_gen_6612
<b, nil>() -> q_gen_6613
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 9  ;  () -> insert([x, nil, cons(x, nil)]) -> 7  ;  () -> leq([a, y]) -> 7  ;  () -> leq([b, b]) -> 5  ;  () -> reverse([nil, nil]) -> 5  ;  () -> sort([nil, nil]) -> 5  ;  () -> sorted([cons(x, nil)]) -> 7  ;  () -> sorted([nil]) -> 5  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 7  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 7  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 7  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 7  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7  ;  (leq([b, a])) -> BOT -> 6  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 6
}
Sat witness: Yes: (() -> append([nil, l2, l2]), {
l2 -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 23, which took 0.010050 s (model generation: 0.007154,  model checking: 0.002896):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, b>() -> q_gen_6612
<b, nil>() -> q_gen_6613
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 9  ;  () -> insert([x, nil, cons(x, nil)]) -> 7  ;  () -> leq([a, y]) -> 7  ;  () -> leq([b, b]) -> 6  ;  () -> reverse([nil, nil]) -> 6  ;  () -> sort([nil, nil]) -> 6  ;  () -> sorted([cons(x, nil)]) -> 7  ;  () -> sorted([nil]) -> 6  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 7  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 7  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 7  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 7  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10  ;  (leq([b, a])) -> BOT -> 7  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 7
}
Sat witness: Yes: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> b  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 24, which took 0.013991 s (model generation: 0.010215,  model checking: 0.003776):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, b>() -> q_gen_6612
<b, nil>() -> q_gen_6613
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572},
Q_f={q_gen_6556},
Delta=
{
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 9  ;  () -> insert([x, nil, cons(x, nil)]) -> 7  ;  () -> leq([a, y]) -> 7  ;  () -> leq([b, b]) -> 7  ;  () -> reverse([nil, nil]) -> 7  ;  () -> sort([nil, nil]) -> 7  ;  () -> sorted([cons(x, nil)]) -> 7  ;  () -> sorted([nil]) -> 7  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 7  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 7  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 7  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 10  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10  ;  (leq([b, a])) -> BOT -> 8  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 8
}
Sat witness: Yes: ((insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]), {
_yd -> nil  ;  _zd -> cons(a, cons(b, nil))  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 25, which took 0.042036 s (model generation: 0.019736,  model checking: 0.022300):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, b>() -> q_gen_6612
<b, nil>() -> q_gen_6613
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<nil>() -> q_gen_6626
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 9  ;  () -> insert([x, nil, cons(x, nil)]) -> 7  ;  () -> leq([a, y]) -> 7  ;  () -> leq([b, b]) -> 7  ;  () -> reverse([nil, nil]) -> 7  ;  () -> sort([nil, nil]) -> 7  ;  () -> sorted([cons(x, nil)]) -> 7  ;  () -> sorted([nil]) -> 7  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 7  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 10  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 8  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 10  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10  ;  (leq([b, a])) -> BOT -> 8  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 8
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, nil)  ;  h1 -> a  ;  l2 -> nil  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 26, which took 0.009044 s (model generation: 0.008664,  model checking: 0.000380):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, b>() -> q_gen_6612
<b, nil>() -> q_gen_6613
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<nil>() -> q_gen_6626
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 9  ;  () -> insert([x, nil, cons(x, nil)]) -> 7  ;  () -> leq([a, y]) -> 7  ;  () -> leq([b, b]) -> 7  ;  () -> reverse([nil, nil]) -> 7  ;  () -> sort([nil, nil]) -> 7  ;  () -> sorted([cons(x, nil)]) -> 7  ;  () -> sorted([nil]) -> 7  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 10  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 10  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 8  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 10  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10  ;  (leq([b, a])) -> BOT -> 8  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 8
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> nil  ;  _pd -> cons(a, nil)  ;  h1 -> a  ;  t1 -> nil
})

-------------------------------------------
Step 27, which took 0.038457 s (model generation: 0.015286,  model checking: 0.023171):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<nil>() -> q_gen_6626
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 12  ;  () -> insert([x, nil, cons(x, nil)]) -> 8  ;  () -> leq([a, y]) -> 8  ;  () -> leq([b, b]) -> 8  ;  () -> reverse([nil, nil]) -> 8  ;  () -> sort([nil, nil]) -> 8  ;  () -> sorted([cons(x, nil)]) -> 8  ;  () -> sorted([nil]) -> 8  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 10  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 10  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 9  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 10  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10  ;  (leq([b, a])) -> BOT -> 9  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 9
}
Sat witness: Yes: (() -> append([nil, l2, l2]), {
l2 -> cons(b, cons(b, cons(b, nil)))
})

-------------------------------------------
Step 28, which took 0.019339 s (model generation: 0.009582,  model checking: 0.009757):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<nil>() -> q_gen_6626
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 12  ;  () -> insert([x, nil, cons(x, nil)]) -> 9  ;  () -> leq([a, y]) -> 9  ;  () -> leq([b, b]) -> 9  ;  () -> reverse([nil, nil]) -> 9  ;  () -> sort([nil, nil]) -> 9  ;  () -> sorted([cons(x, nil)]) -> 9  ;  () -> sorted([nil]) -> 9  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 10  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 10  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 10  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 10  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 13  ;  (leq([b, a])) -> BOT -> 10  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 10
}
Sat witness: Yes: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> b  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 29, which took 0.013726 s (model generation: 0.010773,  model checking: 0.002953):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<nil>() -> q_gen_6626
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 12  ;  () -> insert([x, nil, cons(x, nil)]) -> 10  ;  () -> leq([a, y]) -> 10  ;  () -> leq([b, b]) -> 10  ;  () -> reverse([nil, nil]) -> 10  ;  () -> sort([nil, nil]) -> 10  ;  () -> sorted([cons(x, nil)]) -> 10  ;  () -> sorted([nil]) -> 10  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 10  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 10  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 10  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 13  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 13  ;  (leq([b, a])) -> BOT -> 11  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 11
}
Sat witness: Yes: ((insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]), {
_yd -> nil  ;  _zd -> cons(a, cons(a, nil))  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 30, which took 0.029989 s (model generation: 0.015695,  model checking: 0.014294):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 12  ;  () -> insert([x, nil, cons(x, nil)]) -> 10  ;  () -> leq([a, y]) -> 10  ;  () -> leq([b, b]) -> 10  ;  () -> reverse([nil, nil]) -> 10  ;  () -> sort([nil, nil]) -> 10  ;  () -> sorted([cons(x, nil)]) -> 10  ;  () -> sorted([nil]) -> 10  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 10  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 13  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 11  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 13  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 13  ;  (leq([b, a])) -> BOT -> 11  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 11
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, nil)  ;  h1 -> b  ;  l2 -> cons(b, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 31, which took 0.016546 s (model generation: 0.013987,  model checking: 0.002559):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, b>() -> q_gen_6659
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614},
Q_f={q_gen_6557},
Delta=
{
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 12  ;  () -> insert([x, nil, cons(x, nil)]) -> 10  ;  () -> leq([a, y]) -> 10  ;  () -> leq([b, b]) -> 10  ;  () -> reverse([nil, nil]) -> 10  ;  () -> sort([nil, nil]) -> 10  ;  () -> sorted([cons(x, nil)]) -> 10  ;  () -> sorted([nil]) -> 10  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 13  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 13  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 11  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 13  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 13  ;  (leq([b, a])) -> BOT -> 11  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 11
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> cons(b, nil)  ;  _pd -> cons(b, cons(b, nil))  ;  h1 -> b  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 32, which took 0.040067 s (model generation: 0.024313,  model checking: 0.015754):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, b>() -> q_gen_6659
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<nil>() -> q_gen_6668
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 13  ;  () -> insert([x, nil, cons(x, nil)]) -> 11  ;  () -> leq([a, y]) -> 11  ;  () -> leq([b, b]) -> 11  ;  () -> reverse([nil, nil]) -> 11  ;  () -> sort([nil, nil]) -> 11  ;  () -> sorted([cons(x, nil)]) -> 11  ;  () -> sorted([nil]) -> 11  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 13  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 13  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 12  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 16  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 14  ;  (leq([b, a])) -> BOT -> 12  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 12
}
Sat witness: Yes: ((insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]), {
_yd -> nil  ;  _zd -> cons(b, cons(b, cons(b, nil)))  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 33, which took 0.048312 s (model generation: 0.014938,  model checking: 0.033374):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, b>() -> q_gen_6659
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<nil>() -> q_gen_6668
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 13  ;  () -> insert([x, nil, cons(x, nil)]) -> 12  ;  () -> leq([a, y]) -> 12  ;  () -> leq([b, b]) -> 12  ;  () -> reverse([nil, nil]) -> 12  ;  () -> sort([nil, nil]) -> 12  ;  () -> sorted([cons(x, nil)]) -> 12  ;  () -> sorted([nil]) -> 12  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 13  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 16  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 13  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 16  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 14  ;  (leq([b, a])) -> BOT -> 13  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 13
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(a, nil)  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 34, which took 0.024641 s (model generation: 0.014884,  model checking: 0.009757):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, b>() -> q_gen_6659
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<nil>() -> q_gen_6668
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 13  ;  () -> insert([x, nil, cons(x, nil)]) -> 13  ;  () -> leq([a, y]) -> 13  ;  () -> leq([b, b]) -> 13  ;  () -> reverse([nil, nil]) -> 13  ;  () -> sort([nil, nil]) -> 13  ;  () -> sorted([cons(x, nil)]) -> 13  ;  () -> sorted([nil]) -> 13  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 16  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 16  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 14  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 16  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 14  ;  (leq([b, a])) -> BOT -> 14  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 14
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> nil  ;  _pd -> cons(b, cons(a, nil))  ;  h1 -> b  ;  t1 -> nil
})

-------------------------------------------
Step 35, which took 0.030662 s (model generation: 0.017042,  model checking: 0.013620):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, b>() -> q_gen_6659
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 14  ;  () -> insert([x, nil, cons(x, nil)]) -> 14  ;  () -> leq([a, y]) -> 14  ;  () -> leq([b, b]) -> 14  ;  () -> reverse([nil, nil]) -> 14  ;  () -> sort([nil, nil]) -> 14  ;  () -> sorted([cons(x, nil)]) -> 14  ;  () -> sorted([nil]) -> 14  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 16  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 16  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 15  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 19  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 15  ;  (leq([b, a])) -> BOT -> 15  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 15
}
Sat witness: Yes: ((insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]), {
_yd -> cons(a, nil)  ;  _zd -> cons(b, cons(b, nil))  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 36, which took 0.098011 s (model generation: 0.018498,  model checking: 0.079513):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, b>() -> q_gen_6659
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 15  ;  () -> insert([x, nil, cons(x, nil)]) -> 15  ;  () -> leq([a, y]) -> 15  ;  () -> leq([b, b]) -> 15  ;  () -> reverse([nil, nil]) -> 15  ;  () -> sort([nil, nil]) -> 15  ;  () -> sorted([cons(x, nil)]) -> 15  ;  () -> sorted([nil]) -> 15  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 16  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 19  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 16  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 19  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 16  ;  (leq([b, a])) -> BOT -> 16  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 16
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(a, nil)  ;  h1 -> b  ;  l2 -> cons(a, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 37, which took 0.029923 s (model generation: 0.018176,  model checking: 0.011747):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, b>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 16  ;  () -> insert([x, nil, cons(x, nil)]) -> 16  ;  () -> leq([a, y]) -> 16  ;  () -> leq([b, b]) -> 16  ;  () -> reverse([nil, nil]) -> 16  ;  () -> sort([nil, nil]) -> 16  ;  () -> sorted([cons(x, nil)]) -> 16  ;  () -> sorted([nil]) -> 16  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 19  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 19  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 17  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 19  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 17  ;  (leq([b, a])) -> BOT -> 17  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 17
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> nil  ;  _pd -> cons(b, cons(b, cons(b, nil)))  ;  h1 -> b  ;  t1 -> nil
})

-------------------------------------------
Step 38, which took 0.030767 s (model generation: 0.019510,  model checking: 0.011257):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, b>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 17  ;  () -> insert([x, nil, cons(x, nil)]) -> 17  ;  () -> leq([a, y]) -> 17  ;  () -> leq([b, b]) -> 17  ;  () -> reverse([nil, nil]) -> 17  ;  () -> sort([nil, nil]) -> 17  ;  () -> sorted([cons(x, nil)]) -> 17  ;  () -> sorted([nil]) -> 17  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 19  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 19  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 18  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 22  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 18  ;  (leq([b, a])) -> BOT -> 18  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 18
}
Sat witness: Yes: ((insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]), {
_yd -> cons(b, nil)  ;  _zd -> cons(a, cons(b, nil))  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 39, which took 0.227097 s (model generation: 0.020201,  model checking: 0.206896):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, b>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, b>() -> q_gen_6663
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 18  ;  () -> insert([x, nil, cons(x, nil)]) -> 18  ;  () -> leq([a, y]) -> 18  ;  () -> leq([b, b]) -> 18  ;  () -> reverse([nil, nil]) -> 18  ;  () -> sort([nil, nil]) -> 18  ;  () -> sorted([cons(x, nil)]) -> 18  ;  () -> sorted([nil]) -> 18  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 19  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 22  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 19  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 22  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 19  ;  (leq([b, a])) -> BOT -> 19  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 19
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, nil)  ;  h1 -> a  ;  l2 -> cons(b, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 40, which took 0.035118 s (model generation: 0.022440,  model checking: 0.012678):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, nil, a>() -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 19  ;  () -> insert([x, nil, cons(x, nil)]) -> 19  ;  () -> leq([a, y]) -> 19  ;  () -> leq([b, b]) -> 19  ;  () -> reverse([nil, nil]) -> 19  ;  () -> sort([nil, nil]) -> 19  ;  () -> sorted([cons(x, nil)]) -> 19  ;  () -> sorted([nil]) -> 19  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 22  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 22  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 20  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 22  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 20  ;  (leq([b, a])) -> BOT -> 20  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 20
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> nil  ;  _pd -> cons(a, cons(b, nil))  ;  h1 -> a  ;  t1 -> nil
})

-------------------------------------------
Step 41, which took 0.141987 s (model generation: 0.024506,  model checking: 0.117481):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, nil, a>() -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 20  ;  () -> insert([x, nil, cons(x, nil)]) -> 20  ;  () -> leq([a, y]) -> 20  ;  () -> leq([b, b]) -> 20  ;  () -> reverse([nil, nil]) -> 20  ;  () -> sort([nil, nil]) -> 20  ;  () -> sorted([cons(x, nil)]) -> 20  ;  () -> sorted([nil]) -> 20  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 22  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 25  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 21  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 23  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 21  ;  (leq([b, a])) -> BOT -> 21  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 21
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(a, nil)  ;  h1 -> a  ;  l2 -> cons(a, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 42, which took 0.042143 s (model generation: 0.030534,  model checking: 0.011609):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, nil, a>() -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 21  ;  () -> insert([x, nil, cons(x, nil)]) -> 21  ;  () -> leq([a, y]) -> 21  ;  () -> leq([b, b]) -> 21  ;  () -> reverse([nil, nil]) -> 21  ;  () -> sort([nil, nil]) -> 21  ;  () -> sorted([cons(x, nil)]) -> 21  ;  () -> sorted([nil]) -> 21  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 25  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 25  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 22  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 23  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 22  ;  (leq([b, a])) -> BOT -> 22  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 22
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> cons(a, nil)  ;  _pd -> cons(a, cons(b, nil))  ;  h1 -> b  ;  t1 -> nil
})

-------------------------------------------
Step 43, which took 1.109526 s (model generation: 0.031117,  model checking: 1.078409):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, nil, a>() -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 22  ;  () -> insert([x, nil, cons(x, nil)]) -> 22  ;  () -> leq([a, y]) -> 22  ;  () -> leq([b, b]) -> 22  ;  () -> reverse([nil, nil]) -> 22  ;  () -> sort([nil, nil]) -> 22  ;  () -> sorted([cons(x, nil)]) -> 22  ;  () -> sorted([nil]) -> 22  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 25  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 28  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 23  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 24  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 23  ;  (leq([b, a])) -> BOT -> 23  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 23
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, cons(a, nil))  ;  h1 -> b  ;  l2 -> cons(b, cons(a, nil))  ;  t1 -> nil
})

-------------------------------------------
Step 44, which took 0.080597 s (model generation: 0.065014,  model checking: 0.015583):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 23  ;  () -> insert([x, nil, cons(x, nil)]) -> 23  ;  () -> leq([a, y]) -> 23  ;  () -> leq([b, b]) -> 23  ;  () -> reverse([nil, nil]) -> 23  ;  () -> sort([nil, nil]) -> 23  ;  () -> sorted([cons(x, nil)]) -> 23  ;  () -> sorted([nil]) -> 23  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 28  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 28  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 24  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 25  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 24  ;  (leq([b, a])) -> BOT -> 24  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 24
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> nil  ;  _pd -> cons(b, nil)  ;  h1 -> a  ;  t1 -> nil
})

-------------------------------------------
Step 45, which took 0.710184 s (model generation: 0.154578,  model checking: 0.555606):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<a, b>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 24  ;  () -> insert([x, nil, cons(x, nil)]) -> 24  ;  () -> leq([a, y]) -> 24  ;  () -> leq([b, b]) -> 24  ;  () -> reverse([nil, nil]) -> 24  ;  () -> sort([nil, nil]) -> 24  ;  () -> sorted([cons(x, nil)]) -> 24  ;  () -> sorted([nil]) -> 24  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 28  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 31  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 25  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 26  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 25  ;  (leq([b, a])) -> BOT -> 25  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 25
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(a, cons(b, nil))  ;  h1 -> a  ;  l2 -> cons(a, cons(b, nil))  ;  t1 -> nil
})

-------------------------------------------
Step 46, which took 0.107691 s (model generation: 0.086853,  model checking: 0.020838):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6663
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<a, b>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 25  ;  () -> insert([x, nil, cons(x, nil)]) -> 25  ;  () -> leq([a, y]) -> 25  ;  () -> leq([b, b]) -> 25  ;  () -> reverse([nil, nil]) -> 25  ;  () -> sort([nil, nil]) -> 25  ;  () -> sorted([cons(x, nil)]) -> 25  ;  () -> sorted([nil]) -> 25  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 31  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 31  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 26  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 27  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 26  ;  (leq([b, a])) -> BOT -> 26  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 26
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> cons(a, nil)  ;  _pd -> cons(a, cons(b, nil))  ;  h1 -> b  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 47, which took 3.389899 s (model generation: 0.066974,  model checking: 3.322925):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<nil, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6663
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, a>(q_gen_6669, q_gen_6668) -> q_gen_6612
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<a, b>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 26  ;  () -> insert([x, nil, cons(x, nil)]) -> 26  ;  () -> leq([a, y]) -> 26  ;  () -> leq([b, b]) -> 26  ;  () -> reverse([nil, nil]) -> 26  ;  () -> sort([nil, nil]) -> 26  ;  () -> sorted([cons(x, nil)]) -> 26  ;  () -> sorted([nil]) -> 26  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 31  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 34  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 27  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 28  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 27  ;  (leq([b, a])) -> BOT -> 27  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 27
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, cons(b, nil))  ;  h1 -> b  ;  l2 -> cons(b, nil)  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 48, which took 0.107784 s (model generation: 0.083967,  model checking: 0.023817):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<cons, nil, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<cons, b, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<cons, b, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6663
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, a>(q_gen_6669, q_gen_6668) -> q_gen_6612
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<a, b>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 27  ;  () -> insert([x, nil, cons(x, nil)]) -> 27  ;  () -> leq([a, y]) -> 27  ;  () -> leq([b, b]) -> 27  ;  () -> reverse([nil, nil]) -> 27  ;  () -> sort([nil, nil]) -> 27  ;  () -> sorted([cons(x, nil)]) -> 27  ;  () -> sorted([nil]) -> 27  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 34  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 34  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 28  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 29  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 28  ;  (leq([b, a])) -> BOT -> 28  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 28
}
Sat witness: Yes: ((append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]), {
_od -> cons(b, cons(b, nil))  ;  _pd -> cons(b, cons(b, nil))  ;  h1 -> b  ;  t1 -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 49, which took 2.347832 s (model generation: 0.744629,  model checking: 1.603203):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<cons, nil, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<cons, b, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<cons, b, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6663
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<cons, nil>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, a>(q_gen_6669, q_gen_6668) -> q_gen_6612
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<a, b>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 28  ;  () -> insert([x, nil, cons(x, nil)]) -> 28  ;  () -> leq([a, y]) -> 28  ;  () -> leq([b, b]) -> 28  ;  () -> reverse([nil, nil]) -> 28  ;  () -> sort([nil, nil]) -> 28  ;  () -> sorted([cons(x, nil)]) -> 28  ;  () -> sorted([nil]) -> 28  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 34  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 37  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 29  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 30  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 29  ;  (leq([b, a])) -> BOT -> 29  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 29
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, cons(b, nil))  ;  h1 -> b  ;  l2 -> cons(a, nil)  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 50, which took 4.104174 s (model generation: 0.975001,  model checking: 3.129173):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<cons, nil, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<cons, a, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<cons, b, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<cons, a, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<cons, b, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6663
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<cons, nil>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, a>(q_gen_6669, q_gen_6668) -> q_gen_6612
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<a, b>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 29  ;  () -> insert([x, nil, cons(x, nil)]) -> 29  ;  () -> leq([a, y]) -> 29  ;  () -> leq([b, b]) -> 29  ;  () -> reverse([nil, nil]) -> 29  ;  () -> sort([nil, nil]) -> 29  ;  () -> sorted([cons(x, nil)]) -> 29  ;  () -> sorted([nil]) -> 29  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 35  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 40  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 30  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 31  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 30  ;  (leq([b, a])) -> BOT -> 30  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 30
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, cons(b, nil))  ;  h1 -> a  ;  l2 -> cons(b, nil)  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 51, which took 3.248487 s (model generation: 0.187502,  model checking: 3.060985):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<cons, nil, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<cons, nil, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<cons, a, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<cons, b, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<cons, a, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<cons, b, a>(q_gen_6608, q_gen_6607) -> q_gen_6661
<cons, b, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6663
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<cons, nil>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, a>(q_gen_6669, q_gen_6668) -> q_gen_6612
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<a, b>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 30  ;  () -> insert([x, nil, cons(x, nil)]) -> 30  ;  () -> leq([a, y]) -> 30  ;  () -> leq([b, b]) -> 30  ;  () -> reverse([nil, nil]) -> 30  ;  () -> sort([nil, nil]) -> 30  ;  () -> sorted([cons(x, nil)]) -> 30  ;  () -> sorted([nil]) -> 30  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 36  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 43  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 31  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 32  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 31  ;  (leq([b, a])) -> BOT -> 31  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 31
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, cons(b, nil))  ;  h1 -> a  ;  l2 -> cons(a, nil)  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 52, which took 1.700008 s (model generation: 0.143855,  model checking: 1.556153):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<cons, nil, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<cons, nil, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<cons, a, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<cons, b, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<cons, a, a>(q_gen_6608, q_gen_6607) -> q_gen_6661
<cons, a, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<cons, b, a>(q_gen_6608, q_gen_6607) -> q_gen_6661
<cons, b, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6663
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<cons, nil>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, a>(q_gen_6669, q_gen_6668) -> q_gen_6612
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<a, b>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 31  ;  () -> insert([x, nil, cons(x, nil)]) -> 31  ;  () -> leq([a, y]) -> 31  ;  () -> leq([b, b]) -> 31  ;  () -> reverse([nil, nil]) -> 31  ;  () -> sort([nil, nil]) -> 31  ;  () -> sorted([cons(x, nil)]) -> 31  ;  () -> sorted([nil]) -> 31  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 37  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 46  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 32  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 33  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 32  ;  (leq([b, a])) -> BOT -> 32  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 32
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, cons(b, nil))  ;  h1 -> b  ;  l2 -> cons(b, cons(b, nil))  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 53, which took 8.622991 s (model generation: 0.339438,  model checking: 8.283553):

Model:
|_
{
append -> 
{{{
Q={q_gen_6563, q_gen_6578, q_gen_6579, q_gen_6580, q_gen_6581, q_gen_6607, q_gen_6608, q_gen_6659, q_gen_6660, q_gen_6661, q_gen_6662, q_gen_6663, q_gen_6664, q_gen_6665},
Q_f={q_gen_6563},
Delta=
{
<cons>(q_gen_6608, q_gen_6607) -> q_gen_6607
<nil>() -> q_gen_6607
<a>() -> q_gen_6608
<b>() -> q_gen_6608
<cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6578
<nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6578
<nil, nil>() -> q_gen_6578
<cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6579
<cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6579
<nil, a>() -> q_gen_6579
<nil, b>() -> q_gen_6579
<a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<a, nil>() -> q_gen_6580
<b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6580
<b, nil>() -> q_gen_6580
<a, a>() -> q_gen_6581
<a, b>() -> q_gen_6581
<b, a>() -> q_gen_6581
<b, b>() -> q_gen_6581
<cons, cons, cons>(q_gen_6665, q_gen_6664, q_gen_6663, q_gen_6662, q_gen_6661, q_gen_6660, q_gen_6659, q_gen_6563) -> q_gen_6563
<cons, nil, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6563
<nil, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6563
<nil, nil, nil>() -> q_gen_6563
<cons, cons, b>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6659
<cons, nil, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<cons, nil, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6659
<nil, nil, a>() -> q_gen_6659
<nil, nil, b>() -> q_gen_6659
<cons, a, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<cons, b, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6660
<nil, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<nil, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6660
<cons, a, a>(q_gen_6608, q_gen_6607) -> q_gen_6661
<cons, a, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<cons, b, a>(q_gen_6608, q_gen_6607) -> q_gen_6661
<cons, b, b>(q_gen_6608, q_gen_6607) -> q_gen_6661
<nil, a, a>() -> q_gen_6661
<nil, a, b>() -> q_gen_6661
<nil, b, a>() -> q_gen_6661
<nil, b, b>() -> q_gen_6661
<a, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<a, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<b, cons, cons>(q_gen_6581, q_gen_6580, q_gen_6579, q_gen_6578) -> q_gen_6662
<b, nil, cons>(q_gen_6608, q_gen_6607) -> q_gen_6662
<a, cons, a>(q_gen_6608, q_gen_6607) -> q_gen_6663
<a, nil, a>() -> q_gen_6663
<b, cons, b>(q_gen_6608, q_gen_6607) -> q_gen_6663
<b, nil, b>() -> q_gen_6663
<a, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, a, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<b, b, cons>(q_gen_6608, q_gen_6607) -> q_gen_6664
<a, a, a>() -> q_gen_6665
<a, b, a>() -> q_gen_6665
<b, a, b>() -> q_gen_6665
<b, b, b>() -> q_gen_6665
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: complete
}}}
  ;  insert -> 
{{{
Q={q_gen_6560, q_gen_6561, q_gen_6562, q_gen_6565, q_gen_6566, q_gen_6567, q_gen_6568},
Q_f={q_gen_6560},
Delta=
{
<cons>(q_gen_6562, q_gen_6561) -> q_gen_6561
<nil>() -> q_gen_6561
<a>() -> q_gen_6562
<b>() -> q_gen_6562
<cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6565
<nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6565
<cons, a>(q_gen_6562, q_gen_6561) -> q_gen_6566
<cons, b>(q_gen_6562, q_gen_6561) -> q_gen_6566
<nil, a>() -> q_gen_6566
<nil, b>() -> q_gen_6566
<a, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<b, cons>(q_gen_6562, q_gen_6561) -> q_gen_6567
<a, a>() -> q_gen_6568
<a, b>() -> q_gen_6568
<b, a>() -> q_gen_6568
<b, b>() -> q_gen_6568
<a, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<a, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
<b, cons, cons>(q_gen_6568, q_gen_6567, q_gen_6566, q_gen_6565) -> q_gen_6560
<b, nil, cons>(q_gen_6562, q_gen_6561) -> q_gen_6560
}

Datatype: <elt, eltlist, eltlist>
Convolution form: complete
}}}
  ;  leq -> 
{{{
Q={q_gen_6558, q_gen_6573},
Q_f={q_gen_6558},
Delta=
{
<a, a>() -> q_gen_6558
<a, b>() -> q_gen_6558
<b, b>() -> q_gen_6558
<b, a>() -> q_gen_6573
}

Datatype: <elt, elt>
Convolution form: complete
}}}
  ;  reverse -> 
{{{
Q={q_gen_6557, q_gen_6612, q_gen_6613, q_gen_6614, q_gen_6668, q_gen_6669},
Q_f={q_gen_6557},
Delta=
{
<cons>(q_gen_6669, q_gen_6668) -> q_gen_6668
<nil>() -> q_gen_6668
<a>() -> q_gen_6669
<b>() -> q_gen_6669
<cons, cons>(q_gen_6614, q_gen_6613, q_gen_6612, q_gen_6557) -> q_gen_6557
<cons, nil>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, cons>(q_gen_6669, q_gen_6668) -> q_gen_6557
<nil, nil>() -> q_gen_6557
<cons, a>(q_gen_6669, q_gen_6668) -> q_gen_6612
<cons, b>(q_gen_6669, q_gen_6668) -> q_gen_6612
<nil, a>() -> q_gen_6612
<nil, b>() -> q_gen_6612
<a, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<a, nil>() -> q_gen_6613
<b, cons>(q_gen_6669, q_gen_6668) -> q_gen_6613
<b, nil>() -> q_gen_6613
<a, a>() -> q_gen_6614
<a, b>() -> q_gen_6614
<b, a>() -> q_gen_6614
<b, b>() -> q_gen_6614
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sort -> 
{{{
Q={q_gen_6556, q_gen_6570, q_gen_6571, q_gen_6572, q_gen_6626, q_gen_6627},
Q_f={q_gen_6556},
Delta=
{
<cons>(q_gen_6627, q_gen_6626) -> q_gen_6626
<nil>() -> q_gen_6626
<a>() -> q_gen_6627
<b>() -> q_gen_6627
<cons, cons>(q_gen_6572, q_gen_6571, q_gen_6570, q_gen_6556) -> q_gen_6556
<nil, cons>(q_gen_6627, q_gen_6626) -> q_gen_6556
<nil, nil>() -> q_gen_6556
<cons, a>(q_gen_6627, q_gen_6626) -> q_gen_6570
<cons, b>(q_gen_6627, q_gen_6626) -> q_gen_6570
<nil, a>() -> q_gen_6570
<nil, b>() -> q_gen_6570
<a, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<a, nil>() -> q_gen_6571
<b, cons>(q_gen_6627, q_gen_6626) -> q_gen_6571
<b, nil>() -> q_gen_6571
<a, a>() -> q_gen_6572
<a, b>() -> q_gen_6572
<b, a>() -> q_gen_6572
<b, b>() -> q_gen_6572
}

Datatype: <eltlist, eltlist>
Convolution form: complete
}}}
  ;  sorted -> 
{{{
Q={q_gen_6553, q_gen_6555},
Q_f={q_gen_6553},
Delta=
{
<cons>(q_gen_6555, q_gen_6553) -> q_gen_6553
<nil>() -> q_gen_6553
<a>() -> q_gen_6555
<b>() -> q_gen_6555
}

Datatype: <eltlist>
Convolution form: complete
}}}

}
--
Equality automata are defined for: {eq_elt, eq_eltlist}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 32  ;  () -> insert([x, nil, cons(x, nil)]) -> 32  ;  () -> leq([a, y]) -> 32  ;  () -> leq([b, b]) -> 32  ;  () -> reverse([nil, nil]) -> 32  ;  () -> sort([nil, nil]) -> 32  ;  () -> sorted([cons(x, nil)]) -> 32  ;  () -> sorted([nil]) -> 32  ;  (append([_od, cons(h1, nil), _pd]) /\ reverse([t1, _od])) -> reverse([cons(h1, t1), _pd]) -> 38  ;  (append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]) -> 49  ;  (insert([x, z, _td]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _td)]) -> 33  ;  (insert([y, _yd, _zd]) /\ sort([z, _yd])) -> sort([cons(y, z), _zd]) -> 34  ;  (leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 33  ;  (leq([b, a])) -> BOT -> 33  ;  (reverse([_de, _ee]) /\ reverse([l, _de]) /\ sorted([l])) -> sorted([_ee]) -> 33
}
Sat witness: Yes: ((append([t1, l2, _jd])) -> append([cons(h1, t1), l2, cons(h1, _jd)]), {
_jd -> cons(b, cons(b, nil))  ;  h1 -> a  ;  l2 -> cons(b, cons(b, nil))  ;  t1 -> cons(b, nil)
})

Total time: 30.188636
Reason for stopping: DontKnow. Stopped because: timeout