Inference procedure has parameters:
Ice fuel: 200
Timeout: 60s
Convolution: left


Learning problem is:

env: {
elt -> {a, b}  ;  eltlist -> {cons, nil}
}
definition:
{
(leq, P:
{() -> leq([a, y])
() -> leq([b, b])
(leq([b, a])) -> BOT}
)
(insert, F:
{() -> insert([x, nil, cons(x, nil)])
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)])
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))])}
(insert([_wk, _xk, _yk]) /\ insert([_wk, _xk, _zk])) -> eq_eltlist([_yk, _zk])
)
(sort, F:
{() -> sort([nil, nil])
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl])}
(sort([_cl, _dl]) /\ sort([_cl, _el])) -> eq_eltlist([_dl, _el])
)
}

properties:
{(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)])}


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

Clause system for inference is:

{
() -> insert([x, nil, cons(x, nil)]) -> 0
() -> leq([a, y]) -> 0
() -> leq([b, b]) -> 0
() -> sort([nil, nil]) -> 0
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 0
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 0
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 0
(leq([b, a])) -> BOT -> 0
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 0
}


Solving took 60.000636 seconds.
DontKnow. Stopped because: timeout
Working model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2849, q_gen_2850, q_gen_2851, q_gen_2855, q_gen_2856, q_gen_2858, q_gen_2859, q_gen_2860, q_gen_2861, q_gen_2862, q_gen_2865, q_gen_2866, q_gen_2867, q_gen_2868, q_gen_2869, q_gen_2870, q_gen_2871, q_gen_2872, q_gen_2874, q_gen_2875, q_gen_2876, q_gen_2879, q_gen_2881, q_gen_2885, q_gen_2886, q_gen_2887, q_gen_2888, q_gen_2892, q_gen_2893, q_gen_2894, q_gen_2895, q_gen_2896, q_gen_2901, q_gen_2903, q_gen_2904, q_gen_2905, q_gen_2906, q_gen_2907, q_gen_2908, q_gen_2911, q_gen_2920, q_gen_2921, q_gen_2922, q_gen_2923, q_gen_2924, q_gen_2928, q_gen_2929, q_gen_2930, q_gen_2931, q_gen_2938, q_gen_2948, q_gen_2949, q_gen_2950, q_gen_2955, q_gen_2960, q_gen_2961, q_gen_2966, q_gen_2967, q_gen_2968, q_gen_2972, q_gen_2981, q_gen_2984, q_gen_2991, q_gen_2992, q_gen_2998, q_gen_2999},
Q_f={},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2868
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2870
<a, b>() -> q_gen_2871
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2876
<cons, cons>(q_gen_2851, q_gen_2870) -> q_gen_2886
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2893
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2895
<cons, cons>(q_gen_2861, q_gen_2870) -> q_gen_2904
<cons, cons>(q_gen_2851, q_gen_2895) -> q_gen_2907
<cons, cons>(q_gen_2856, q_gen_2907) -> q_gen_2921
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2924
<cons, cons>(q_gen_2856, q_gen_2893) -> q_gen_2929
<cons, cons>(q_gen_2856, q_gen_2895) -> q_gen_2931
<cons, cons>(q_gen_2856, q_gen_2950) -> q_gen_2949
<cons, cons>(q_gen_2861, q_gen_2876) -> q_gen_2950
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2961
<cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2968
<cons, cons>(q_gen_2861, q_gen_2924) -> q_gen_2992
<cons, cons>(q_gen_2861, q_gen_2961) -> q_gen_2999
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2849
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2855
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2858
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2860
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2865
<b, cons, cons>(q_gen_2856, q_gen_2868) -> q_gen_2867
<b, cons, cons>(q_gen_2851, q_gen_2870) -> q_gen_2869
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2872
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2874
<b, cons, cons>(q_gen_2856, q_gen_2876) -> q_gen_2875
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2879
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2881
<a, cons, cons>(q_gen_2861, q_gen_2886) -> q_gen_2885
<a, cons, cons>(q_gen_2861, q_gen_2870) -> q_gen_2887
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2888
<b, cons, cons>(q_gen_2856, q_gen_2893) -> q_gen_2892
<a, cons, cons>(q_gen_2856, q_gen_2895) -> q_gen_2894
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2896
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2901
<a, cons, cons>(q_gen_2856, q_gen_2904) -> q_gen_2903
<b, cons, cons>(q_gen_2851, q_gen_2895) -> q_gen_2905
<b, cons, cons>(q_gen_2856, q_gen_2907) -> q_gen_2906
<b, cons, cons>(q_gen_2851, q_gen_2893) -> q_gen_2908
<b, cons, cons>(q_gen_2851, q_gen_2876) -> q_gen_2911
<b, cons, cons>(q_gen_2856, q_gen_2921) -> q_gen_2920
<b, cons, cons>(q_gen_2851, q_gen_2886) -> q_gen_2922
<a, cons, cons>(q_gen_2856, q_gen_2924) -> q_gen_2923
<b, cons, cons>(q_gen_2856, q_gen_2929) -> q_gen_2928
<a, cons, cons>(q_gen_2856, q_gen_2931) -> q_gen_2930
<a, cons, cons>(q_gen_2856, q_gen_2893) -> q_gen_2938
<a, cons, cons>(q_gen_2856, q_gen_2949) -> q_gen_2948
<b, cons, cons>(q_gen_2856, q_gen_2870) -> q_gen_2955
<a, cons, cons>(q_gen_2856, q_gen_2961) -> q_gen_2960
<a, cons, cons>(q_gen_2856, q_gen_2950) -> q_gen_2966
<b, cons, cons>(q_gen_2851, q_gen_2968) -> q_gen_2967
<a, cons, cons>(q_gen_2861, q_gen_2968) -> q_gen_2972
<b, cons, cons>(q_gen_2856, q_gen_2968) -> q_gen_2981
<a, cons, cons>(q_gen_2861, q_gen_2876) -> q_gen_2984
<a, cons, cons>(q_gen_2856, q_gen_2992) -> q_gen_2991
<a, cons, cons>(q_gen_2856, q_gen_2999) -> q_gen_2998
}

Datatype: <elt, eltlist, eltlist>
Convolution form: left
}}}
  ;  leq -> 
{{{
Q={q_gen_2844, q_gen_2845, q_gen_2854, q_gen_2857},
Q_f={},
Delta=
{
<b, b>() -> q_gen_2844
<a, b>() -> q_gen_2845
<b, a>() -> q_gen_2854
<a, a>() -> q_gen_2857
}

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2873, q_gen_2877, q_gen_2878, q_gen_2880, q_gen_2882, q_gen_2883, q_gen_2884, q_gen_2889, q_gen_2890, q_gen_2891, q_gen_2897, q_gen_2898, q_gen_2899, q_gen_2900, q_gen_2902, q_gen_2909, q_gen_2910, q_gen_2912, q_gen_2913, q_gen_2914, q_gen_2915, q_gen_2916, q_gen_2917, q_gen_2918, q_gen_2919, q_gen_2925, q_gen_2926, q_gen_2927, q_gen_2932, q_gen_2933, q_gen_2934, q_gen_2935, q_gen_2936, q_gen_2937, q_gen_2939, q_gen_2940, q_gen_2941, q_gen_2942, q_gen_2943, q_gen_2944, q_gen_2945, q_gen_2946, q_gen_2947, q_gen_2951, q_gen_2952, q_gen_2953, q_gen_2954, q_gen_2956, q_gen_2957, q_gen_2958, q_gen_2959, q_gen_2962, q_gen_2963, q_gen_2964, q_gen_2965, q_gen_2969, q_gen_2970, q_gen_2971, q_gen_2973, q_gen_2974, q_gen_2975, q_gen_2976, q_gen_2977, q_gen_2978, q_gen_2979, q_gen_2980, q_gen_2982, q_gen_2983, q_gen_2985, q_gen_2986, q_gen_2987, q_gen_2988, q_gen_2989, q_gen_2990, q_gen_2993, q_gen_2994, q_gen_2995, q_gen_2996, q_gen_2997, q_gen_3000, q_gen_3001, q_gen_3002, q_gen_3003, q_gen_3004},
Q_f={},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2873
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2880
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2878, q_gen_2873) -> q_gen_2883
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2864, q_gen_2890) -> q_gen_2889
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2890
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2878, q_gen_2899) -> q_gen_2898
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2899
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2900
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2902
<cons, cons>(q_gen_2853, q_gen_2910) -> q_gen_2909
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2910
<cons, cons>(q_gen_2878, q_gen_2913) -> q_gen_2912
<cons, cons>(q_gen_2853, q_gen_2890) -> q_gen_2913
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2914
<cons, cons>(q_gen_2878, q_gen_2916) -> q_gen_2915
<cons, cons>(q_gen_2864, q_gen_2882) -> q_gen_2916
<cons, cons>(q_gen_2878, q_gen_2902) -> q_gen_2917
<cons, cons>(q_gen_2864, q_gen_2880) -> q_gen_2918
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2919
<cons, cons>(q_gen_2878, q_gen_2889) -> q_gen_2925
<cons, cons>(q_gen_2878, q_gen_2927) -> q_gen_2926
<cons, cons>(q_gen_2891, q_gen_2890) -> q_gen_2927
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2932
<cons, cons>(q_gen_2878, q_gen_2914) -> q_gen_2933
<cons, cons>(q_gen_2878, q_gen_2910) -> q_gen_2934
<cons, cons>(q_gen_2878, q_gen_2890) -> q_gen_2935
<cons, cons>(q_gen_2891, q_gen_2884) -> q_gen_2936
<cons, cons>(q_gen_2878, q_gen_2884) -> q_gen_2937
<cons, cons>(q_gen_2878, q_gen_2940) -> q_gen_2939
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2940
<cons, cons>(q_gen_2878, q_gen_2942) -> q_gen_2941
<cons, cons>(q_gen_2878, q_gen_2943) -> q_gen_2942
<cons, cons>(q_gen_2853, q_gen_2944) -> q_gen_2943
<cons, cons>(q_gen_2853, q_gen_2889) -> q_gen_2944
<cons, cons>(q_gen_2878, q_gen_2946) -> q_gen_2945
<cons, cons>(q_gen_2891, q_gen_2947) -> q_gen_2946
<cons, cons>(q_gen_2853, q_gen_2935) -> q_gen_2947
<cons, cons>(q_gen_2878, q_gen_2952) -> q_gen_2951
<cons, cons>(q_gen_2853, q_gen_2898) -> q_gen_2952
<cons, cons>(q_gen_2891, q_gen_2954) -> q_gen_2953
<cons, cons>(q_gen_2864, q_gen_2897) -> q_gen_2954
<cons, cons>(q_gen_2891, q_gen_2880) -> q_gen_2956
<cons, cons>(q_gen_2878, q_gen_2958) -> q_gen_2957
<cons, cons>(q_gen_2853, q_gen_2880) -> q_gen_2958
<cons, cons>(q_gen_2853, q_gen_2882) -> q_gen_2959
<cons, cons>(q_gen_2878, q_gen_2935) -> q_gen_2962
<cons, cons>(q_gen_2878, q_gen_2964) -> q_gen_2963
<cons, cons>(q_gen_2853, q_gen_2884) -> q_gen_2964
<cons, cons>(q_gen_2891, q_gen_2935) -> q_gen_2965
<cons, cons>(q_gen_2853, q_gen_2914) -> q_gen_2969
<cons, cons>(q_gen_2878, q_gen_2969) -> q_gen_2970
<cons, cons>(q_gen_2853, q_gen_2940) -> q_gen_2971
<cons, cons>(q_gen_2878, q_gen_2974) -> q_gen_2973
<cons, cons>(q_gen_2853, q_gen_2975) -> q_gen_2974
<cons, cons>(q_gen_2864, q_gen_2976) -> q_gen_2975
<cons, cons>(q_gen_2853, q_gen_2977) -> q_gen_2976
<cons, cons>(q_gen_2853, q_gen_2964) -> q_gen_2977
<cons, cons>(q_gen_2853, q_gen_2979) -> q_gen_2978
<cons, cons>(q_gen_2878, q_gen_2980) -> q_gen_2979
<cons, cons>(q_gen_2891, q_gen_2977) -> q_gen_2980
<cons, cons>(q_gen_2891, q_gen_2914) -> q_gen_2982
<cons, cons>(q_gen_2864, q_gen_2927) -> q_gen_2983
<cons, cons>(q_gen_2878, q_gen_2986) -> q_gen_2985
<cons, cons>(q_gen_2878, q_gen_2987) -> q_gen_2986
<cons, cons>(q_gen_2891, q_gen_2959) -> q_gen_2987
<cons, cons>(q_gen_2878, q_gen_2989) -> q_gen_2988
<cons, cons>(q_gen_2853, q_gen_2990) -> q_gen_2989
<cons, cons>(q_gen_2853, q_gen_2919) -> q_gen_2990
<cons, cons>(q_gen_2878, q_gen_2912) -> q_gen_2993
<cons, cons>(q_gen_2878, q_gen_2880) -> q_gen_2994
<cons, cons>(q_gen_2878, q_gen_2996) -> q_gen_2995
<cons, cons>(q_gen_2864, q_gen_2936) -> q_gen_2996
<cons, cons>(q_gen_2878, q_gen_2944) -> q_gen_2997
<cons, cons>(q_gen_2891, q_gen_2873) -> q_gen_3000
<cons, cons>(q_gen_2878, q_gen_2965) -> q_gen_3001
<cons, cons>(q_gen_2878, q_gen_3003) -> q_gen_3002
<cons, cons>(q_gen_2891, q_gen_2927) -> q_gen_3003
<cons, cons>(q_gen_2891, q_gen_2913) -> q_gen_3004
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

-------------------
STEPS:
-------------------------------------------
Step 0, which took 0.008651 s (model generation: 0.008207,  model checking: 0.000444):

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

}

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

}

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

}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 0
() -> leq([a, y]) -> 0
() -> leq([b, b]) -> 0
() -> sort([nil, nil]) -> 3
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 1
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1
(leq([b, a])) -> BOT -> 1
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 1
}
Sat witness: Found: (() -> sort([nil, nil]), {

})

-------------------------------------------
Step 1, which took 0.006982 s (model generation: 0.006947,  model checking: 0.000035):

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

}

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

}

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843},
Q_f={q_gen_2843},
Delta=
{
<nil, nil>() -> q_gen_2843
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 0
() -> leq([a, y]) -> 0
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 1
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1
(leq([b, a])) -> BOT -> 1
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 1
}
Sat witness: Found: (() -> leq([b, b]), {

})

-------------------------------------------
Step 2, which took 0.007232 s (model generation: 0.007163,  model checking: 0.000069):

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

}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843},
Q_f={q_gen_2843},
Delta=
{
<nil, nil>() -> q_gen_2843
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 0
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 1
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1
(leq([b, a])) -> BOT -> 1
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 1
}
Sat witness: Found: (() -> leq([a, y]), {
y -> b
})

-------------------------------------------
Step 3, which took 0.007724 s (model generation: 0.007600,  model checking: 0.000124):

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

}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843},
Q_f={q_gen_2843},
Delta=
{
<nil, nil>() -> q_gen_2843
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 1
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1
(leq([b, a])) -> BOT -> 1
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 1
}
Sat witness: Found: (() -> insert([x, nil, cons(x, nil)]), {
x -> b
})

-------------------------------------------
Step 4, which took 0.008908 s (model generation: 0.008340,  model checking: 0.000568):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843},
Q_f={q_gen_2843},
Delta=
{
<nil, nil>() -> q_gen_2843
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 1
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 2
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 2
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> b  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 5, which took 0.008194 s (model generation: 0.008064,  model checking: 0.000130):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843},
Q_f={q_gen_2843},
Delta=
{
<nil, nil>() -> q_gen_2843
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 1
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 2
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 2
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> nil  ;  _bl -> cons(b, nil)  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 6, which took 0.011212 s (model generation: 0.008643,  model checking: 0.002569):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 4
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 2
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 2
}
Sat witness: Found: ((insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]), {
_vk -> cons(b, nil)  ;  x -> b  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 7, which took 0.014038 s (model generation: 0.013609,  model checking: 0.000429):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 4
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 5
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 3
}
Sat witness: Found: ((leq([b, a])) -> BOT, {

})

-------------------------------------------
Step 8, which took 0.009928 s (model generation: 0.009613,  model checking: 0.000315):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 4
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 5
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 4
}
Sat witness: Found: (() -> leq([a, y]), {
y -> a
})

-------------------------------------------
Step 9, which took 0.009191 s (model generation: 0.008801,  model checking: 0.000390):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 4
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 5
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 4
}
Sat witness: Found: (() -> insert([x, nil, cons(x, nil)]), {
x -> a
})

-------------------------------------------
Step 10, which took 0.009701 s (model generation: 0.009058,  model checking: 0.000643):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<a>() -> q_gen_2848
<b>() -> q_gen_2848
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 4
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7
(leq([b, a])) -> BOT -> 5
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 5
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 11, which took 0.009987 s (model generation: 0.009659,  model checking: 0.000328):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<a>() -> q_gen_2848
<b>() -> q_gen_2848
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 4
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 7
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7
(leq([b, a])) -> BOT -> 5
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 5
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> nil  ;  _bl -> cons(b, nil)  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 12, which took 0.010674 s (model generation: 0.010115,  model checking: 0.000559):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<a>() -> q_gen_2848
<b>() -> q_gen_2848
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, b>() -> q_gen_2853
<b, b>() -> q_gen_2853
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 7
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 7
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7
(leq([b, a])) -> BOT -> 5
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 5
}
Sat witness: Found: ((insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]), {
_vk -> cons(a, cons(a, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 13, which took 0.011723 s (model generation: 0.011408,  model checking: 0.000315):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<a>() -> q_gen_2848
<b>() -> q_gen_2848
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, b>() -> q_gen_2853
<b, b>() -> q_gen_2853
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 5
() -> sort([nil, nil]) -> 5
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 7
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 7
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7
(leq([b, a])) -> BOT -> 5
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 8
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(b, nil)  ;  _gl -> nil  ;  l -> nil
})

-------------------------------------------
Step 14, which took 0.012471 s (model generation: 0.011535,  model checking: 0.000936):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2859, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 7
() -> leq([a, y]) -> 7
() -> leq([b, b]) -> 6
() -> sort([nil, nil]) -> 6
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 7
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 7
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10
(leq([b, a])) -> BOT -> 6
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 8
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> b  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 15, which took 0.013550 s (model generation: 0.013131,  model checking: 0.000419):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2859, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<a, b>() -> q_gen_2851
<b, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 7
() -> leq([a, y]) -> 7
() -> leq([b, b]) -> 7
() -> sort([nil, nil]) -> 7
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 7
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 10
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10
(leq([b, a])) -> BOT -> 7
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 8
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(b, nil)  ;  _bl -> cons(b, cons(b, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 16, which took 0.015714 s (model generation: 0.013887,  model checking: 0.001827):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2859, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<a, b>() -> q_gen_2851
<b, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843, q_gen_2852},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 8
() -> leq([a, y]) -> 8
() -> leq([b, b]) -> 8
() -> sort([nil, nil]) -> 8
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 8
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 10
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10
(leq([b, a])) -> BOT -> 8
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 11
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(b, cons(b, nil))  ;  _gl -> cons(b, nil)  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 17, which took 0.015034 s (model generation: 0.013071,  model checking: 0.001963):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2859, q_gen_2861, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 9
() -> leq([a, y]) -> 9
() -> leq([b, b]) -> 9
() -> sort([nil, nil]) -> 9
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 9
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 10
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 13
(leq([b, a])) -> BOT -> 9
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 11
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 18, which took 0.015109 s (model generation: 0.013986,  model checking: 0.001123):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2856
<b, a>() -> q_gen_2856
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 9
() -> leq([a, y]) -> 9
() -> leq([b, b]) -> 9
() -> sort([nil, nil]) -> 9
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 12
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 10
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 13
(leq([b, a])) -> BOT -> 10
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 11
}
Sat witness: Found: ((insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]), {
_vk -> cons(b, cons(b, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 19, which took 0.022848 s (model generation: 0.021574,  model checking: 0.001274):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2856
<b, a>() -> q_gen_2856
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 10
() -> leq([a, y]) -> 10
() -> leq([b, b]) -> 10
() -> sort([nil, nil]) -> 10
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 12
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 13
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 13
(leq([b, a])) -> BOT -> 11
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 11
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> nil  ;  _bl -> cons(a, nil)  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 20, which took 0.018686 s (model generation: 0.015859,  model checking: 0.002827):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2856
<b, a>() -> q_gen_2856
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 11
() -> leq([a, y]) -> 11
() -> leq([b, b]) -> 11
() -> sort([nil, nil]) -> 11
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 13
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 16
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 14
(leq([b, a])) -> BOT -> 12
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 12
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, nil)  ;  _bl -> cons(b, cons(a, nil))  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 21, which took 0.019706 s (model generation: 0.016514,  model checking: 0.003192):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2856
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 12
() -> leq([a, y]) -> 12
() -> leq([b, b]) -> 12
() -> sort([nil, nil]) -> 12
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 14
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 15
(leq([b, a])) -> BOT -> 13
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 13
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, nil)  ;  _bl -> cons(a, cons(b, nil))  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 22, which took 0.023458 s (model generation: 0.020974,  model checking: 0.002484):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2856
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 13
() -> leq([a, y]) -> 13
() -> leq([b, b]) -> 13
() -> sort([nil, nil]) -> 13
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 14
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 15
(leq([b, a])) -> BOT -> 13
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 16
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(b, nil)))  ;  _gl -> cons(a, cons(b, nil))  ;  l -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 23, which took 0.023911 s (model generation: 0.020044,  model checking: 0.003867):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2862},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2856
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843, q_gen_2852},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2852
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 14
() -> leq([a, y]) -> 14
() -> leq([b, b]) -> 14
() -> sort([nil, nil]) -> 14
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 15
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 16
(leq([b, a])) -> BOT -> 14
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 19
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, nil))  ;  _gl -> cons(a, nil)  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 24, which took 0.028182 s (model generation: 0.025006,  model checking: 0.003176):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 15
() -> leq([a, y]) -> 15
() -> leq([b, b]) -> 15
() -> sort([nil, nil]) -> 15
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 16
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 19
(leq([b, a])) -> BOT -> 15
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 19
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> b  ;  z -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 25, which took 0.025884 s (model generation: 0.022044,  model checking: 0.003840):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 16
() -> leq([a, y]) -> 16
() -> leq([b, b]) -> 16
() -> sort([nil, nil]) -> 16
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 17
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 22
(leq([b, a])) -> BOT -> 16
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 20
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 26, which took 0.029724 s (model generation: 0.022529,  model checking: 0.007195):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 17
() -> leq([a, y]) -> 17
() -> leq([b, b]) -> 17
() -> sort([nil, nil]) -> 17
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 18
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 22
(leq([b, a])) -> BOT -> 17
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 20
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(b, nil)  ;  _bl -> cons(b, cons(a, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 27, which took 0.033031 s (model generation: 0.026110,  model checking: 0.006921):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, a>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 18
() -> leq([a, y]) -> 18
() -> leq([b, b]) -> 18
() -> sort([nil, nil]) -> 18
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 19
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 22
(leq([b, a])) -> BOT -> 18
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 23
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(b, cons(a, nil))  ;  _gl -> cons(b, nil)  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 28, which took 0.029134 s (model generation: 0.026798,  model checking: 0.002336):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 19
() -> leq([a, y]) -> 19
() -> leq([b, b]) -> 19
() -> sort([nil, nil]) -> 19
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 22
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 22
(leq([b, a])) -> BOT -> 19
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 23
}
Sat witness: Found: ((insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]), {
_vk -> cons(a, cons(b, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 29, which took 0.030264 s (model generation: 0.028554,  model checking: 0.001710):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 20
() -> leq([a, y]) -> 20
() -> leq([b, b]) -> 20
() -> sort([nil, nil]) -> 20
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 22
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 25
(leq([b, a])) -> BOT -> 20
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 23
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 30, which took 0.033258 s (model generation: 0.031617,  model checking: 0.001641):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 21
() -> leq([a, y]) -> 21
() -> leq([b, b]) -> 21
() -> sort([nil, nil]) -> 21
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 22
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 25
(leq([b, a])) -> BOT -> 21
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 23
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, nil)  ;  _bl -> cons(b, cons(b, nil))  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 31, which took 0.053014 s (model generation: 0.032742,  model checking: 0.020272):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 22
() -> leq([a, y]) -> 22
() -> leq([b, b]) -> 22
() -> sort([nil, nil]) -> 22
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 23
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 25
(leq([b, a])) -> BOT -> 22
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 26
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(a, nil)))  ;  _gl -> cons(a, cons(a, nil))  ;  l -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 32, which took 0.059229 s (model generation: 0.038792,  model checking: 0.020437):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 23
() -> leq([a, y]) -> 23
() -> leq([b, b]) -> 23
() -> sort([nil, nil]) -> 23
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 24
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 26
(leq([b, a])) -> BOT -> 23
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 26
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, nil)  ;  _bl -> cons(b, cons(b, nil))  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 33, which took 0.053879 s (model generation: 0.041100,  model checking: 0.012779):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 24
() -> leq([a, y]) -> 24
() -> leq([b, b]) -> 24
() -> sort([nil, nil]) -> 24
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 25
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 29
(leq([b, a])) -> BOT -> 24
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 27
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> a  ;  z -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 34, which took 0.050311 s (model generation: 0.046069,  model checking: 0.004242):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 25
() -> leq([a, y]) -> 25
() -> leq([b, b]) -> 25
() -> sort([nil, nil]) -> 25
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 28
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 29
(leq([b, a])) -> BOT -> 25
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 27
}
Sat witness: Found: ((insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]), {
_vk -> cons(b, cons(a, cons(b, nil)))  ;  x -> b  ;  y -> a  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 35, which took 0.052435 s (model generation: 0.049854,  model checking: 0.002581):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 26
() -> leq([a, y]) -> 26
() -> leq([b, b]) -> 26
() -> sort([nil, nil]) -> 26
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 28
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 29
(leq([b, a])) -> BOT -> 26
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 28
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(b, cons(a, nil))  ;  _bl -> cons(b, cons(a, cons(b, nil)))  ;  y -> b  ;  z -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 36, which took 0.077935 s (model generation: 0.055405,  model checking: 0.022530):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 27
() -> leq([a, y]) -> 27
() -> leq([b, b]) -> 27
() -> sort([nil, nil]) -> 27
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 29
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 32
(leq([b, a])) -> BOT -> 27
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 29
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> b  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 37, which took 0.074655 s (model generation: 0.060388,  model checking: 0.014267):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 28
() -> leq([a, y]) -> 28
() -> leq([b, b]) -> 28
() -> sort([nil, nil]) -> 28
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 30
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 34
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 32
(leq([b, a])) -> BOT -> 28
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 30
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, nil)  ;  _bl -> cons(a, cons(a, nil))  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 38, which took 0.066713 s (model generation: 0.061821,  model checking: 0.004892):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
<a, a>() -> q_gen_2878
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 29
() -> leq([a, y]) -> 29
() -> leq([b, b]) -> 29
() -> sort([nil, nil]) -> 29
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 30
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 34
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 32
(leq([b, a])) -> BOT -> 29
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 33
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(a, nil)))  ;  _gl -> cons(b, cons(b, nil))  ;  l -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 39, which took 0.090026 s (model generation: 0.067156,  model checking: 0.022870):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843, q_gen_2852},
Delta=
{
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<a, a>() -> q_gen_2853
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 30
() -> leq([a, y]) -> 30
() -> leq([b, b]) -> 30
() -> sort([nil, nil]) -> 30
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 31
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 34
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 33
(leq([b, a])) -> BOT -> 30
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 36
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(a, cons(b, nil))))  ;  _gl -> cons(a, cons(b, cons(b, nil)))  ;  l -> cons(a, cons(a, cons(a, nil)))
})

-------------------------------------------
Step 40, which took 0.094713 s (model generation: 0.076806,  model checking: 0.017907):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843, q_gen_2852},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2852
<a, a>() -> q_gen_2853
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<a, b>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 31
() -> leq([a, y]) -> 31
() -> leq([b, b]) -> 31
() -> sort([nil, nil]) -> 31
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 32
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 37
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 34
(leq([b, a])) -> BOT -> 31
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 36
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(b, nil)  ;  _bl -> cons(b, cons(b, nil))  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 41, which took 0.102771 s (model generation: 0.077021,  model checking: 0.025750):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2882, q_gen_2891},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2843
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2882) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2882) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2882
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 32
() -> leq([a, y]) -> 32
() -> leq([b, b]) -> 32
() -> sort([nil, nil]) -> 32
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 33
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 37
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 35
(leq([b, a])) -> BOT -> 32
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 39
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(b, cons(b, cons(a, nil)))  ;  _gl -> cons(a, cons(a, nil))  ;  l -> cons(a, cons(a, nil))
})

-------------------------------------------
Step 42, which took 0.089833 s (model generation: 0.083887,  model checking: 0.005946):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871, q_gen_2886},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2886
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2886
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2886
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2856, q_gen_2886) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2886) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2886) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2886) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 33
() -> leq([a, y]) -> 33
() -> leq([b, b]) -> 33
() -> sort([nil, nil]) -> 33
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 36
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 37
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 35
(leq([b, a])) -> BOT -> 33
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 39
}
Sat witness: Found: ((insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]), {
_vk -> cons(a, cons(b, cons(a, cons(b, nil))))  ;  x -> b  ;  y -> a  ;  z -> cons(a, cons(b, cons(b, nil)))
})

-------------------------------------------
Step 43, which took 0.089756 s (model generation: 0.088001,  model checking: 0.001755):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871, q_gen_2886},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2886) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2886
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2886
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2886
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2886
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2856, q_gen_2886) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2886) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2886) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2886) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 34
() -> leq([a, y]) -> 34
() -> leq([b, b]) -> 34
() -> sort([nil, nil]) -> 34
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 36
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 37
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 38
(leq([b, a])) -> BOT -> 34
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 39
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> b  ;  y -> b  ;  z -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 44, which took 0.124751 s (model generation: 0.091182,  model checking: 0.033569):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2891},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 35
() -> leq([a, y]) -> 35
() -> leq([b, b]) -> 35
() -> sort([nil, nil]) -> 35
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 37
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 40
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 38
(leq([b, a])) -> BOT -> 35
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 39
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(b, nil))  ;  _bl -> cons(a, cons(b, cons(a, nil)))  ;  y -> a  ;  z -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 45, which took 0.130710 s (model generation: 0.101047,  model checking: 0.029663):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2891},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 36
() -> leq([a, y]) -> 36
() -> leq([b, b]) -> 36
() -> sort([nil, nil]) -> 36
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 38
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 40
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 39
(leq([b, a])) -> BOT -> 36
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 42
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(a, cons(a, nil)))  ;  _gl -> cons(b, cons(b, nil))  ;  l -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 46, which took 0.114589 s (model generation: 0.109345,  model checking: 0.005244):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871, q_gen_2893},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2893
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2893) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2893) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 37
() -> leq([a, y]) -> 37
() -> leq([b, b]) -> 37
() -> sort([nil, nil]) -> 37
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 41
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 40
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 39
(leq([b, a])) -> BOT -> 37
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 42
}
Sat witness: Found: ((insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]), {
_vk -> cons(a, cons(a, cons(b, nil)))  ;  x -> b  ;  y -> a  ;  z -> cons(a, cons(a, nil))
})

-------------------------------------------
Step 47, which took 0.126393 s (model generation: 0.124428,  model checking: 0.001965):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2868, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2868) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2868) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2868
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2868
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2868
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2868
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2856, q_gen_2868) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2868) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2868) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 38
() -> leq([a, y]) -> 38
() -> leq([b, b]) -> 38
() -> sort([nil, nil]) -> 38
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 41
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 40
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 42
(leq([b, a])) -> BOT -> 38
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 42
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> a  ;  z -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 48, which took 0.128915 s (model generation: 0.126062,  model checking: 0.002853):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2868, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2868) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2868
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2868
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2856, q_gen_2868) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2868) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2868) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2864
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 39
() -> leq([a, y]) -> 39
() -> leq([b, b]) -> 39
() -> sort([nil, nil]) -> 39
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 41
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 43
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 42
(leq([b, a])) -> BOT -> 39
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 42
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, nil)  ;  _bl -> cons(a, cons(b, nil))  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 49, which took 0.144885 s (model generation: 0.126135,  model checking: 0.018750):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878},
Q_f={q_gen_2843, q_gen_2852},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 40
() -> leq([a, y]) -> 40
() -> leq([b, b]) -> 40
() -> sort([nil, nil]) -> 40
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 42
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 43
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 42
(leq([b, a])) -> BOT -> 40
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 45
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(b, nil)))  ;  _gl -> cons(b, cons(a, nil))  ;  l -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 50, which took 0.177730 s (model generation: 0.130838,  model checking: 0.046892):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2861
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878},
Q_f={q_gen_2843, q_gen_2852},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2852
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2852
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 41
() -> leq([a, y]) -> 41
() -> leq([b, b]) -> 41
() -> sort([nil, nil]) -> 41
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 43
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 46
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 43
(leq([b, a])) -> BOT -> 41
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 45
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, nil)  ;  _bl -> cons(b, cons(b, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 51, which took 0.143402 s (model generation: 0.129462,  model checking: 0.013940):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878},
Q_f={q_gen_2843, q_gen_2852},
Delta=
{
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2852
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2852
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 42
() -> leq([a, y]) -> 42
() -> leq([b, b]) -> 42
() -> sort([nil, nil]) -> 42
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 44
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 44
(leq([b, a])) -> BOT -> 42
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 46
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(b, nil)  ;  _bl -> cons(a, cons(b, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 52, which took 0.145581 s (model generation: 0.134142,  model checking: 0.011439):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2877
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2877
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 43
() -> leq([a, y]) -> 43
() -> leq([b, b]) -> 43
() -> sort([nil, nil]) -> 43
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 45
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 45
(leq([b, a])) -> BOT -> 43
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 49
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(b, cons(b, nil))  ;  _gl -> cons(a, nil)  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 53, which took 0.148520 s (model generation: 0.131768,  model checking: 0.016752):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2891, q_gen_2897},
Q_f={q_gen_2843, q_gen_2897},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 44
() -> leq([a, y]) -> 44
() -> leq([b, b]) -> 44
() -> sort([nil, nil]) -> 44
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 46
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 46
(leq([b, a])) -> BOT -> 44
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 52
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(b, nil)))  ;  _gl -> cons(b, cons(a, nil))  ;  l -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 54, which took 0.154008 s (model generation: 0.134788,  model checking: 0.019220):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2877
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 45
() -> leq([a, y]) -> 45
() -> leq([b, b]) -> 45
() -> sort([nil, nil]) -> 45
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 47
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 52
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 47
(leq([b, a])) -> BOT -> 45
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 52
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, nil)  ;  _bl -> cons(a, cons(a, nil))  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 55, which took 0.165050 s (model generation: 0.145824,  model checking: 0.019226):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2882, q_gen_2891},
Q_f={q_gen_2843},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2882) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2864, q_gen_2882) -> q_gen_2882
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2882
<cons, cons>(q_gen_2891, q_gen_2882) -> q_gen_2882
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 46
() -> leq([a, y]) -> 46
() -> leq([b, b]) -> 46
() -> sort([nil, nil]) -> 46
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 48
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 52
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 48
(leq([b, a])) -> BOT -> 46
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 55
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(a, cons(b, nil)))  ;  _gl -> cons(b, cons(a, nil))  ;  l -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 56, which took 0.210064 s (model generation: 0.150815,  model checking: 0.059249):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2877
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 47
() -> leq([a, y]) -> 47
() -> leq([b, b]) -> 47
() -> sort([nil, nil]) -> 47
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 49
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 55
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 49
(leq([b, a])) -> BOT -> 47
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 55
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(a, nil))  ;  _bl -> cons(a, cons(a, cons(b, nil)))  ;  y -> b  ;  z -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 57, which took 0.186331 s (model generation: 0.173327,  model checking: 0.013004):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2897},
Q_f={q_gen_2843, q_gen_2852, q_gen_2897},
Delta=
{
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 48
() -> leq([a, y]) -> 48
() -> leq([b, b]) -> 48
() -> sort([nil, nil]) -> 48
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 50
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 55
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 50
(leq([b, a])) -> BOT -> 48
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 58
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(a, cons(b, nil)))  ;  _gl -> cons(a, cons(a, nil))  ;  l -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 58, which took 0.204155 s (model generation: 0.180729,  model checking: 0.023426):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2884},
Q_f={q_gen_2843, q_gen_2852, q_gen_2884},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2884) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2884) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2884
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2884
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 49
() -> leq([a, y]) -> 49
() -> leq([b, b]) -> 49
() -> sort([nil, nil]) -> 49
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 51
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 58
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 51
(leq([b, a])) -> BOT -> 49
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 58
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(a, nil))  ;  _bl -> cons(a, cons(a, cons(b, nil)))  ;  y -> a  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 59, which took 0.244624 s (model generation: 0.195552,  model checking: 0.049072):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2884},
Q_f={q_gen_2843, q_gen_2852, q_gen_2884},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2884) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2884) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2884
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2884
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 50
() -> leq([a, y]) -> 50
() -> leq([b, b]) -> 50
() -> sort([nil, nil]) -> 50
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 52
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 58
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 52
(leq([b, a])) -> BOT -> 50
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 61
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(a, cons(b, cons(b, cons(b, cons(a, nil))))))  ;  _gl -> cons(a, cons(a, cons(b, cons(a, cons(a, nil)))))  ;  l -> cons(a, cons(b, cons(b, cons(a, cons(b, nil)))))
})

-------------------------------------------
Step 60, which took 0.258099 s (model generation: 0.255779,  model checking: 0.002320):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2884},
Q_f={q_gen_2843, q_gen_2852, q_gen_2884},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2884) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2884
<cons, cons>(q_gen_2853, q_gen_2884) -> q_gen_2884
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2884
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 51
() -> leq([a, y]) -> 51
() -> leq([b, b]) -> 51
() -> sort([nil, nil]) -> 51
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 52
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 58
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 55
(leq([b, a])) -> BOT -> 51
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 61
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> a  ;  z -> cons(a, cons(b, cons(b, nil)))
})

-------------------------------------------
Step 61, which took 0.268224 s (model generation: 0.241434,  model checking: 0.026790):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2884},
Q_f={q_gen_2843, q_gen_2852, q_gen_2884},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2853, q_gen_2884) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<b, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2884) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2884
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2884
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 52
() -> leq([a, y]) -> 52
() -> leq([b, b]) -> 52
() -> sort([nil, nil]) -> 52
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 53
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 61
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 56
(leq([b, a])) -> BOT -> 52
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 61
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(b, nil))  ;  _bl -> cons(a, cons(a, cons(b, nil)))  ;  y -> a  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 62, which took 0.426505 s (model generation: 0.254390,  model checking: 0.172115):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871, q_gen_2893},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2893) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2893
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2893
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2893) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2893) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2893) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2891, q_gen_2910},
Q_f={q_gen_2843, q_gen_2910},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2853, q_gen_2910) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2910
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 53
() -> leq([a, y]) -> 53
() -> leq([b, b]) -> 53
() -> sort([nil, nil]) -> 53
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 54
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 61
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 57
(leq([b, a])) -> BOT -> 53
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 64
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(a, cons(b, cons(a, nil)))))  ;  _gl -> cons(a, cons(b, cons(b, cons(b, nil))))  ;  l -> cons(b, cons(a, cons(b, cons(a, nil))))
})

-------------------------------------------
Step 63, which took 0.386023 s (model generation: 0.327172,  model checking: 0.058851):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2890, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2890) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2890) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2877
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2890
<cons, cons>(q_gen_2878, q_gen_2890) -> q_gen_2890
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2890
<cons, cons>(q_gen_2891, q_gen_2890) -> q_gen_2890
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 54
() -> leq([a, y]) -> 54
() -> leq([b, b]) -> 54
() -> sort([nil, nil]) -> 54
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 55
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 64
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 58
(leq([b, a])) -> BOT -> 54
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 64
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(a, nil))  ;  _bl -> cons(a, cons(b, cons(a, nil)))  ;  y -> b  ;  z -> cons(a, cons(a, nil))
})

-------------------------------------------
Step 64, which took 0.350538 s (model generation: 0.330712,  model checking: 0.019826):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2889, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2889) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2877
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2889
<cons, cons>(q_gen_2853, q_gen_2889) -> q_gen_2889
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2889
<cons, cons>(q_gen_2864, q_gen_2889) -> q_gen_2889
<cons, cons>(q_gen_2878, q_gen_2889) -> q_gen_2889
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2889
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2889
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 55
() -> leq([a, y]) -> 55
() -> leq([b, b]) -> 55
() -> sort([nil, nil]) -> 55
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 56
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 64
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 59
(leq([b, a])) -> BOT -> 55
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 67
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(b, cons(a, nil))))  ;  _gl -> cons(a, cons(b, cons(a, nil)))  ;  l -> cons(b, cons(a, cons(a, nil)))
})

-------------------------------------------
Step 65, which took 0.382323 s (model generation: 0.362075,  model checking: 0.020248):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2884, q_gen_2891},
Q_f={q_gen_2843, q_gen_2852, q_gen_2884},
Delta=
{
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2884) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2884) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2884) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2884) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2884
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2884
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2884
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 56
() -> leq([a, y]) -> 56
() -> leq([b, b]) -> 56
() -> sort([nil, nil]) -> 56
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 57
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 67
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 60
(leq([b, a])) -> BOT -> 56
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 67
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, nil)  ;  _bl -> cons(a, cons(a, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 66, which took 0.388090 s (model generation: 0.345978,  model checking: 0.042112):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2889, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2889) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2877
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2889
<cons, cons>(q_gen_2853, q_gen_2889) -> q_gen_2889
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2889
<cons, cons>(q_gen_2864, q_gen_2889) -> q_gen_2889
<cons, cons>(q_gen_2878, q_gen_2889) -> q_gen_2889
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2889
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2889
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 57
() -> leq([a, y]) -> 57
() -> leq([b, b]) -> 57
() -> sort([nil, nil]) -> 57
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 58
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 67
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 61
(leq([b, a])) -> BOT -> 57
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 70
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(b, cons(a, nil))))  ;  _gl -> cons(b, cons(a, cons(b, nil)))  ;  l -> cons(b, cons(a, cons(a, nil)))
})

-------------------------------------------
Step 67, which took 0.418895 s (model generation: 0.380532,  model checking: 0.038363):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2882, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2843
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2843
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2853, q_gen_2882) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2882) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2882) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2882) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2877
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2882
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 58
() -> leq([a, y]) -> 58
() -> leq([b, b]) -> 58
() -> sort([nil, nil]) -> 58
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 59
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 70
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 62
(leq([b, a])) -> BOT -> 58
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 70
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(b, nil))  ;  _bl -> cons(a, cons(a, cons(a, nil)))  ;  y -> a  ;  z -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 68, which took 0.542319 s (model generation: 0.465462,  model checking: 0.076857):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2884, q_gen_2891},
Q_f={q_gen_2843, q_gen_2852, q_gen_2884},
Delta=
{
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2853, q_gen_2884) -> q_gen_2852
<cons, cons>(q_gen_2864, q_gen_2884) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2884) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2884) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2884
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2884
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 59
() -> leq([a, y]) -> 59
() -> leq([b, b]) -> 59
() -> sort([nil, nil]) -> 59
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 60
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 70
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 63
(leq([b, a])) -> BOT -> 59
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 73
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(a, cons(b, nil))))  ;  _gl -> cons(a, cons(a, cons(a, nil)))  ;  l -> cons(b, cons(a, cons(b, nil)))
})

-------------------------------------------
Step 69, which took 0.506709 s (model generation: 0.442335,  model checking: 0.064374):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2884, q_gen_2891},
Q_f={q_gen_2843, q_gen_2852, q_gen_2884},
Delta=
{
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<a, a>() -> q_gen_2853
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2853, q_gen_2884) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2884) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2884
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2884
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 60
() -> leq([a, y]) -> 60
() -> leq([b, b]) -> 60
() -> sort([nil, nil]) -> 60
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 61
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 73
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 64
(leq([b, a])) -> BOT -> 60
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 73
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(b, nil))  ;  _bl -> cons(a, cons(a, cons(b, nil)))  ;  y -> a  ;  z -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 70, which took 0.544614 s (model generation: 0.530533,  model checking: 0.014081):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2891, q_gen_2897},
Q_f={q_gen_2843, q_gen_2852, q_gen_2897},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2852
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2897) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2897) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 61
() -> leq([a, y]) -> 61
() -> leq([b, b]) -> 61
() -> sort([nil, nil]) -> 61
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 62
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 73
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 67
(leq([b, a])) -> BOT -> 61
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 73
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> a  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 71, which took 0.537332 s (model generation: 0.512880,  model checking: 0.024452):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2890, q_gen_2891, q_gen_2897},
Q_f={q_gen_2843, q_gen_2897},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2890) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2890) -> q_gen_2890
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2890
<cons, cons>(q_gen_2864, q_gen_2897) -> q_gen_2890
<cons, cons>(q_gen_2878, q_gen_2890) -> q_gen_2890
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2890
<cons, cons>(q_gen_2891, q_gen_2890) -> q_gen_2890
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 62
() -> leq([a, y]) -> 62
() -> leq([b, b]) -> 62
() -> sort([nil, nil]) -> 62
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 63
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 73
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 68
(leq([b, a])) -> BOT -> 62
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 76
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(a, nil)))  ;  _gl -> cons(b, cons(b, nil))  ;  l -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 72, which took 0.588470 s (model generation: 0.529034,  model checking: 0.059436):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2891, q_gen_2897},
Q_f={q_gen_2843, q_gen_2852, q_gen_2897},
Delta=
{
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2852
<cons, cons>(q_gen_2891, q_gen_2897) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2897) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 63
() -> leq([a, y]) -> 63
() -> leq([b, b]) -> 63
() -> sort([nil, nil]) -> 63
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 64
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 76
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 69
(leq([b, a])) -> BOT -> 63
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 76
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(b, cons(a, nil))  ;  _bl -> cons(b, cons(b, cons(b, nil)))  ;  y -> b  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 73, which took 0.549450 s (model generation: 0.504102,  model checking: 0.045348):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2891, q_gen_2897},
Q_f={q_gen_2843, q_gen_2852, q_gen_2897},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2843
<cons, cons>(q_gen_2864, q_gen_2897) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2897) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 64
() -> leq([a, y]) -> 64
() -> leq([b, b]) -> 64
() -> sort([nil, nil]) -> 64
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 65
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 76
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 70
(leq([b, a])) -> BOT -> 64
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 79
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(b, cons(b, nil))))  ;  _gl -> cons(b, cons(a, cons(b, nil)))  ;  l -> cons(b, cons(b, cons(b, nil)))
})

-------------------------------------------
Step 74, which took 0.664436 s (model generation: 0.592116,  model checking: 0.072320):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2891, q_gen_2897},
Q_f={q_gen_2843, q_gen_2852, q_gen_2897},
Delta=
{
<cons, cons>(q_gen_2891, q_gen_2897) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2852
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2897
<cons, cons>(q_gen_2864, q_gen_2897) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 65
() -> leq([a, y]) -> 65
() -> leq([b, b]) -> 65
() -> sort([nil, nil]) -> 65
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 66
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 79
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 71
(leq([b, a])) -> BOT -> 65
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 79
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(b, cons(a, nil))  ;  _bl -> cons(a, cons(b, cons(b, nil)))  ;  y -> a  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 75, which took 0.665665 s (model generation: 0.606425,  model checking: 0.059240):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2873, q_gen_2878, q_gen_2891, q_gen_2897},
Q_f={q_gen_2843, q_gen_2852, q_gen_2897},
Delta=
{
<cons, cons>(q_gen_2864, q_gen_2897) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2873) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2873) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2897) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2853, q_gen_2873) -> q_gen_2873
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2873
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2873
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2873
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2873
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2873
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2873) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 66
() -> leq([a, y]) -> 66
() -> leq([b, b]) -> 66
() -> sort([nil, nil]) -> 66
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 67
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 79
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 72
(leq([b, a])) -> BOT -> 66
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 82
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(b, cons(b, cons(b, cons(b, cons(a, cons(b, nil))))))))  ;  _gl -> cons(b, cons(a, cons(a, cons(b, cons(b, cons(a, cons(b, nil)))))))  ;  l -> cons(b, cons(a, cons(b, cons(b, cons(b, cons(a, cons(b, nil)))))))
})

-------------------------------------------
Step 76, which took 0.964483 s (model generation: 0.904032,  model checking: 0.060451):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2873, q_gen_2878, q_gen_2891, q_gen_2897},
Q_f={q_gen_2843, q_gen_2852, q_gen_2897},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2852
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2873) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2873) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2873
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2873
<cons, cons>(q_gen_2878, q_gen_2873) -> q_gen_2873
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2873
<cons, cons>(q_gen_2891, q_gen_2897) -> q_gen_2873
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2897
<cons, cons>(q_gen_2864, q_gen_2897) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2873) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 67
() -> leq([a, y]) -> 67
() -> leq([b, b]) -> 67
() -> sort([nil, nil]) -> 67
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 68
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 82
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 73
(leq([b, a])) -> BOT -> 67
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 82
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(a, nil))  ;  _bl -> cons(a, cons(b, cons(b, nil)))  ;  y -> b  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 77, which took 1.119539 s (model generation: 0.954174,  model checking: 0.165365):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2891, q_gen_2909},
Q_f={q_gen_2843, q_gen_2852, q_gen_2909},
Delta=
{
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2864, q_gen_2909) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2852
<cons, cons>(q_gen_2891, q_gen_2909) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2909) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2909
<cons, cons>(q_gen_2853, q_gen_2909) -> q_gen_2909
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2909
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 68
() -> leq([a, y]) -> 68
() -> leq([b, b]) -> 68
() -> sort([nil, nil]) -> 68
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 69
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 82
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 74
(leq([b, a])) -> BOT -> 68
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 85
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(b, cons(a, cons(a, nil)))  ;  _gl -> cons(a, cons(a, nil))  ;  l -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 78, which took 1.286256 s (model generation: 0.994648,  model checking: 0.291608):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<a, b>() -> q_gen_2851
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2873, q_gen_2878, q_gen_2891, q_gen_2897},
Q_f={q_gen_2843, q_gen_2852, q_gen_2897},
Delta=
{
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2852
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2873) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2873) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2897) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2873
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2873
<cons, cons>(q_gen_2864, q_gen_2897) -> q_gen_2873
<cons, cons>(q_gen_2878, q_gen_2873) -> q_gen_2873
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2873
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2853, q_gen_2897) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2873) -> q_gen_2897
<cons, cons>(q_gen_2891, q_gen_2897) -> q_gen_2897
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 69
() -> leq([a, y]) -> 69
() -> leq([b, b]) -> 69
() -> sort([nil, nil]) -> 69
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 70
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 85
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 75
(leq([b, a])) -> BOT -> 69
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 85
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(b, cons(b, nil))  ;  _bl -> cons(a, cons(b, cons(b, nil)))  ;  y -> a  ;  z -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 79, which took 1.172211 s (model generation: 1.077062,  model checking: 0.095149):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2890, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2890) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2890) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2890) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2877
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2890) -> q_gen_2890
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2890
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2890
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2890
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 70
() -> leq([a, y]) -> 70
() -> leq([b, b]) -> 70
() -> sort([nil, nil]) -> 70
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 71
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 85
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 76
(leq([b, a])) -> BOT -> 70
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 88
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(a, cons(a, cons(b, cons(a, cons(b, nil))))))  ;  _gl -> cons(a, cons(b, cons(b, cons(a, cons(a, nil)))))  ;  l -> cons(a, cons(b, cons(b, cons(a, cons(a, nil)))))
})

-------------------------------------------
Step 80, which took 1.601098 s (model generation: 1.541498,  model checking: 0.059600):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2890, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2890) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2890) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2877
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2890
<cons, cons>(q_gen_2853, q_gen_2890) -> q_gen_2890
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2890
<cons, cons>(q_gen_2878, q_gen_2890) -> q_gen_2890
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2890
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 71
() -> leq([a, y]) -> 71
() -> leq([b, b]) -> 71
() -> sort([nil, nil]) -> 71
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 72
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 88
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 77
(leq([b, a])) -> BOT -> 71
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 88
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(b, cons(b, nil)))  ;  _bl -> cons(a, cons(a, cons(b, cons(a, nil))))  ;  y -> a  ;  z -> cons(a, cons(b, cons(b, nil)))
})

-------------------------------------------
Step 81, which took 1.514898 s (model generation: 1.490874,  model checking: 0.024024):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<a, b>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2877, q_gen_2878, q_gen_2882, q_gen_2889, q_gen_2891},
Q_f={q_gen_2843, q_gen_2877},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2864, q_gen_2877) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2882) -> q_gen_2843
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2882) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2882) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2889) -> q_gen_2863
<a, b>() -> q_gen_2864
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2877
<cons, cons>(q_gen_2878, q_gen_2877) -> q_gen_2877
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2878, q_gen_2889) -> q_gen_2882
<cons, cons>(q_gen_2891, q_gen_2877) -> q_gen_2882
<cons, cons>(q_gen_2853, q_gen_2877) -> q_gen_2889
<cons, cons>(q_gen_2853, q_gen_2882) -> q_gen_2889
<cons, cons>(q_gen_2853, q_gen_2889) -> q_gen_2889
<cons, cons>(q_gen_2864, q_gen_2889) -> q_gen_2889
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2889
<b, a>() -> q_gen_2891
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 72
() -> leq([a, y]) -> 72
() -> leq([b, b]) -> 72
() -> sort([nil, nil]) -> 72
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 73
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 88
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 78
(leq([b, a])) -> BOT -> 72
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 91
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(a, nil)))  ;  _gl -> cons(a, cons(a, nil))  ;  l -> cons(a, cons(a, nil))
})

-------------------------------------------
Step 82, which took 1.619840 s (model generation: 1.430210,  model checking: 0.189630):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2852, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2891, q_gen_2910},
Q_f={q_gen_2843, q_gen_2852, q_gen_2910},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2910) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2852
<cons, cons>(q_gen_2878, q_gen_2852) -> q_gen_2852
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2910) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2910) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2852) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2910) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2852) -> q_gen_2910
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2910
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 73
() -> leq([a, y]) -> 73
() -> leq([b, b]) -> 73
() -> sort([nil, nil]) -> 73
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 74
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 91
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 79
(leq([b, a])) -> BOT -> 73
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 91
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(b, cons(b, nil))  ;  _bl -> cons(a, cons(b, cons(b, nil)))  ;  y -> a  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 83, which took 1.947616 s (model generation: 1.839877,  model checking: 0.107739):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2882, q_gen_2891, q_gen_2909},
Q_f={q_gen_2843, q_gen_2909},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2909) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2909) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2853, q_gen_2882) -> q_gen_2882
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2891, q_gen_2882) -> q_gen_2882
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2909) -> q_gen_2909
<cons, cons>(q_gen_2864, q_gen_2882) -> q_gen_2909
<cons, cons>(q_gen_2878, q_gen_2882) -> q_gen_2909
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2909
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 74
() -> leq([a, y]) -> 74
() -> leq([b, b]) -> 74
() -> sort([nil, nil]) -> 74
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 75
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 91
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 80
(leq([b, a])) -> BOT -> 74
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 94
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(b, cons(a, cons(a, cons(b, nil)))))  ;  _gl -> cons(a, cons(b, cons(b, cons(a, nil))))  ;  l -> cons(a, cons(b, cons(a, cons(b, nil))))
})

-------------------------------------------
Step 84, which took 3.825551 s (model generation: 3.365581,  model checking: 0.459970):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2882, q_gen_2891, q_gen_2909},
Q_f={q_gen_2843, q_gen_2909},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2882) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2882) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2909) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2909) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2882) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2882
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2882) -> q_gen_2909
<cons, cons>(q_gen_2853, q_gen_2909) -> q_gen_2909
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2909
<cons, cons>(q_gen_2891, q_gen_2909) -> q_gen_2909
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 75
() -> leq([a, y]) -> 75
() -> leq([b, b]) -> 75
() -> sort([nil, nil]) -> 75
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 76
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 94
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 81
(leq([b, a])) -> BOT -> 75
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 94
}
Sat witness: Found: ((insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]), {
_al -> cons(a, cons(b, cons(b, nil)))  ;  _bl -> cons(a, cons(a, cons(a, cons(a, nil))))  ;  y -> a  ;  z -> cons(b, cons(a, cons(b, nil)))
})

-------------------------------------------
Step 85, which took 2.607690 s (model generation: 2.481016,  model checking: 0.126674):

Model:
|_
{
insert -> 
{{{
Q={q_gen_2846, q_gen_2847, q_gen_2848, q_gen_2850, q_gen_2851, q_gen_2856, q_gen_2859, q_gen_2861, q_gen_2862, q_gen_2866, q_gen_2871},
Q_f={q_gen_2846},
Delta=
{
<nil>() -> q_gen_2847
<b>() -> q_gen_2848
<a>() -> q_gen_2859
<cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2850
<cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2850
<cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2850
<nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2850
<b, b>() -> q_gen_2851
<a, a>() -> q_gen_2856
<b, a>() -> q_gen_2861
<cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2866
<cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2866
<nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2866
<a, b>() -> q_gen_2871
<a, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2850) -> q_gen_2846
<a, cons, cons>(q_gen_2861, q_gen_2866) -> q_gen_2846
<a, nil, cons>(q_gen_2859, q_gen_2847) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2846
<b, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2846
<b, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2846
<b, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2846
<a, cons, cons>(q_gen_2851, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2851, q_gen_2866) -> q_gen_2862
<a, cons, cons>(q_gen_2856, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
<a, cons, cons>(q_gen_2871, q_gen_2866) -> q_gen_2862
<a, nil, cons>(q_gen_2848, q_gen_2847) -> q_gen_2862
<b, cons, cons>(q_gen_2856, q_gen_2866) -> q_gen_2862
<b, cons, cons>(q_gen_2871, q_gen_2850) -> q_gen_2862
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_2843, q_gen_2853, q_gen_2863, q_gen_2864, q_gen_2878, q_gen_2882, q_gen_2891, q_gen_2909},
Q_f={q_gen_2843, q_gen_2909},
Delta=
{
<cons, cons>(q_gen_2853, q_gen_2843) -> q_gen_2843
<cons, cons>(q_gen_2878, q_gen_2843) -> q_gen_2843
<nil, nil>() -> q_gen_2843
<b, b>() -> q_gen_2853
<cons, cons>(q_gen_2853, q_gen_2863) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2843) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2882) -> q_gen_2863
<cons, cons>(q_gen_2864, q_gen_2909) -> q_gen_2863
<cons, cons>(q_gen_2878, q_gen_2909) -> q_gen_2863
<cons, cons>(q_gen_2891, q_gen_2843) -> q_gen_2863
<a, b>() -> q_gen_2864
<a, a>() -> q_gen_2878
<cons, cons>(q_gen_2864, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2878, q_gen_2863) -> q_gen_2882
<cons, cons>(q_gen_2891, q_gen_2882) -> q_gen_2882
<cons, cons>(q_gen_2891, q_gen_2909) -> q_gen_2882
<b, a>() -> q_gen_2891
<cons, cons>(q_gen_2853, q_gen_2882) -> q_gen_2909
<cons, cons>(q_gen_2853, q_gen_2909) -> q_gen_2909
<cons, cons>(q_gen_2878, q_gen_2882) -> q_gen_2909
<cons, cons>(q_gen_2891, q_gen_2863) -> q_gen_2909
}

Datatype: <eltlist, eltlist>
Convolution form: left
}}}

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

Teacher's answer:
New clause system:
{
() -> insert([x, nil, cons(x, nil)]) -> 76
() -> leq([a, y]) -> 76
() -> leq([b, b]) -> 76
() -> sort([nil, nil]) -> 76
(insert([x, z, _vk]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _vk)]) -> 77
(insert([y, _al, _bl]) /\ sort([z, _al])) -> sort([cons(y, z), _bl]) -> 94
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 82
(leq([b, a])) -> BOT -> 76
(sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]) -> 97
}
Sat witness: Found: ((sort([l, _gl]) /\ sort([cons(a, l), _fl])) -> eq_eltlist([_fl, cons(a, _gl)]), {
_fl -> cons(a, cons(a, cons(a, cons(a, nil))))  ;  _gl -> cons(a, cons(b, cons(a, nil)))  ;  l -> cons(b, cons(b, cons(b, nil)))
})

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