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


Learning problem is:

env: {
elt -> {a, b}  ;  eltlist -> {cons, nil}  ;  nat -> {s, z}
}
definition:
{
(leq, P:
{() -> leq([a, y])
() -> leq([b, b])
(leq([b, a])) -> BOT}
)
(insert, F:
{() -> insert([x, nil, cons(x, nil)])
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)])
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))])}
(insert([_at, _bt, _ct]) /\ insert([_at, _bt, _dt])) -> eq_eltlist([_ct, _dt])
)
(sort, F:
{() -> sort([nil, nil])
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft])}
(sort([_gt, _ht]) /\ sort([_gt, _it])) -> eq_eltlist([_ht, _it])
)
(append, F:
{() -> append([nil, l2, l2])
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)])}
(append([_kt, _lt, _mt]) /\ append([_kt, _lt, _nt])) -> eq_eltlist([_mt, _nt])
)
}

properties:
{(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt])}


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

Clause system for inference is:

{
() -> append([nil, l2, l2]) -> 0
() -> insert([x, nil, cons(x, nil)]) -> 0
() -> leq([a, y]) -> 0
() -> leq([b, b]) -> 0
() -> sort([nil, nil]) -> 0
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 0
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 0
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 0
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 0
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 0
(leq([b, a])) -> BOT -> 0
}


Solving took 60.000511 seconds.
DontKnow. Stopped because: timeout
Working model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5003, q_gen_5004, q_gen_5005, q_gen_5009, q_gen_5010, q_gen_5011, q_gen_5021, q_gen_5022, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5033, q_gen_5036, q_gen_5037, q_gen_5040, q_gen_5041, q_gen_5047, q_gen_5048, q_gen_5049, q_gen_5050, q_gen_5051, q_gen_5052, q_gen_5055, q_gen_5056, q_gen_5057, q_gen_5058, q_gen_5061, q_gen_5062, q_gen_5063, q_gen_5064, q_gen_5071, q_gen_5073, q_gen_5076, q_gen_5077, q_gen_5078, q_gen_5079, q_gen_5080, q_gen_5085, q_gen_5086, q_gen_5087, q_gen_5088, q_gen_5092, q_gen_5093, q_gen_5094, q_gen_5095, q_gen_5096, q_gen_5101, q_gen_5102, q_gen_5103, q_gen_5104, q_gen_5106, q_gen_5107, q_gen_5108, q_gen_5112, q_gen_5113, q_gen_5114, q_gen_5115, q_gen_5118, q_gen_5119, q_gen_5125, q_gen_5126, q_gen_5128},
Q_f={},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5115
<nil, nil>() -> q_gen_5004
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_5010
<a, a>() -> q_gen_5011
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5064
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5079
<a, b>() -> q_gen_5080
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5087
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5104
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_5003
<nil, cons, cons>(q_gen_5011, q_gen_5010) -> q_gen_5009
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5021
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_5022
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<b, b, b>() -> q_gen_5026
<cons, nil, cons>(q_gen_5011, q_gen_5004) -> q_gen_5033
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5036
<cons, cons, cons>(q_gen_5041, q_gen_5023) -> q_gen_5040
<a, b, a>() -> q_gen_5041
<cons, cons, cons>(q_gen_5041, q_gen_4994) -> q_gen_5047
<nil, cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_5048
<cons, cons, cons>(q_gen_5052, q_gen_5050) -> q_gen_5049
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
<b, a, b>() -> q_gen_5052
<cons, nil, cons>(q_gen_5011, q_gen_5037) -> q_gen_5055
<cons, cons, cons>(q_gen_5057, q_gen_5050) -> q_gen_5056
<a, a, a>() -> q_gen_5057
<cons, cons, cons>(q_gen_5057, q_gen_5023) -> q_gen_5058
<cons, cons, cons>(q_gen_5026, q_gen_5036) -> q_gen_5061
<cons, cons, cons>(q_gen_5041, q_gen_5063) -> q_gen_5062
<cons, nil, cons>(q_gen_5005, q_gen_5064) -> q_gen_5063
<cons, nil, cons>(q_gen_5005, q_gen_5010) -> q_gen_5071
<cons, cons, cons>(q_gen_5041, q_gen_5050) -> q_gen_5073
<nil, cons, cons>(q_gen_5005, q_gen_5010) -> q_gen_5076
<cons, cons, cons>(q_gen_5041, q_gen_5078) -> q_gen_5077
<nil, cons, cons>(q_gen_5080, q_gen_5079) -> q_gen_5078
<cons, nil, cons>(q_gen_5005, q_gen_5079) -> q_gen_5085
<nil, cons, cons>(q_gen_5005, q_gen_5087) -> q_gen_5086
<cons, cons, cons>(q_gen_5057, q_gen_4994) -> q_gen_5088
<cons, cons, cons>(q_gen_5041, q_gen_5093) -> q_gen_5092
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_5093
<cons, cons, cons>(q_gen_5026, q_gen_5095) -> q_gen_5094
<cons, cons, cons>(q_gen_5041, q_gen_5085) -> q_gen_5095
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5096
<cons, cons, cons>(q_gen_5026, q_gen_5096) -> q_gen_5101
<cons, cons, cons>(q_gen_5041, q_gen_5103) -> q_gen_5102
<cons, nil, cons>(q_gen_5005, q_gen_5104) -> q_gen_5103
<cons, cons, cons>(q_gen_5041, q_gen_5096) -> q_gen_5106
<cons, cons, cons>(q_gen_5026, q_gen_5108) -> q_gen_5107
<cons, nil, cons>(q_gen_5011, q_gen_5104) -> q_gen_5108
<nil, cons, cons>(q_gen_5011, q_gen_5079) -> q_gen_5112
<cons, cons, cons>(q_gen_5057, q_gen_5114) -> q_gen_5113
<nil, nil, cons>(q_gen_5051, q_gen_5115) -> q_gen_5114
<cons, nil, cons>(q_gen_5011, q_gen_5079) -> q_gen_5118
<cons, cons, cons>(q_gen_5041, q_gen_5055) -> q_gen_5119
<cons, cons, cons>(q_gen_5052, q_gen_5096) -> q_gen_5125
<cons, cons, cons>(q_gen_5057, q_gen_5103) -> q_gen_5126
<cons, cons, cons>(q_gen_5052, q_gen_5085) -> q_gen_5128
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4995, q_gen_4996, q_gen_4997, q_gen_5001, q_gen_5002, q_gen_5007, q_gen_5008, q_gen_5012, q_gen_5013, q_gen_5014, q_gen_5017, q_gen_5018, q_gen_5019, q_gen_5020, q_gen_5027, q_gen_5028, q_gen_5029, q_gen_5030, q_gen_5034, q_gen_5038, q_gen_5042, q_gen_5043, q_gen_5044, q_gen_5045, q_gen_5046, q_gen_5066, q_gen_5067, q_gen_5069, q_gen_5070, q_gen_5072, q_gen_5081, q_gen_5082, q_gen_5083, q_gen_5090, q_gen_5097, q_gen_5098, q_gen_5105, q_gen_5109, q_gen_5110, q_gen_5116, q_gen_5117, q_gen_5120, q_gen_5121, q_gen_5122, q_gen_5127},
Q_f={},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5013
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5020
<cons, cons>(q_gen_5029, q_gen_5018) -> q_gen_5028
<a, b>() -> q_gen_5029
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5044
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5070
<cons, cons>(q_gen_5002, q_gen_5083) -> q_gen_5082
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5083
<cons, cons>(q_gen_5029, q_gen_4996) -> q_gen_5098
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5117
<cons, cons>(q_gen_5013, q_gen_5028) -> q_gen_5121
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4995
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5001
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5007
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5012
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5017
<b, cons, cons>(q_gen_5002, q_gen_5020) -> q_gen_5019
<b, cons, cons>(q_gen_4997, q_gen_5028) -> q_gen_5027
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
<a, cons, cons>(q_gen_5029, q_gen_4996) -> q_gen_5034
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5038
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5042
<b, cons, cons>(q_gen_5002, q_gen_5044) -> q_gen_5043
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5045
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5046
<a, cons, cons>(q_gen_5002, q_gen_5020) -> q_gen_5066
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5067
<b, cons, cons>(q_gen_5002, q_gen_5070) -> q_gen_5069
<a, cons, cons>(q_gen_5013, q_gen_5028) -> q_gen_5072
<a, cons, cons>(q_gen_5002, q_gen_5082) -> q_gen_5081
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5090
<b, cons, cons>(q_gen_5029, q_gen_5098) -> q_gen_5097
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5105
<a, cons, cons>(q_gen_5002, q_gen_5083) -> q_gen_5109
<a, cons, cons>(q_gen_5002, q_gen_5098) -> q_gen_5110
<b, cons, cons>(q_gen_5002, q_gen_5117) -> q_gen_5116
<a, cons, cons>(q_gen_5002, q_gen_5121) -> q_gen_5120
<a, cons, cons>(q_gen_5002, q_gen_5117) -> q_gen_5122
<b, cons, cons>(q_gen_5029, q_gen_4996) -> q_gen_5127
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5015, q_gen_5016, q_gen_5031, q_gen_5032, q_gen_5035, q_gen_5039, q_gen_5053, q_gen_5054, q_gen_5059, q_gen_5060, q_gen_5065, q_gen_5068, q_gen_5074, q_gen_5075, q_gen_5084, q_gen_5089, q_gen_5091, q_gen_5099, q_gen_5100, q_gen_5111, q_gen_5123, q_gen_5124},
Q_f={},
Delta=
{
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<a, b>() -> q_gen_5032
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_5035
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_5039
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_5053
<a, a>() -> q_gen_5054
<cons, cons>(q_gen_5032, q_gen_5053) -> q_gen_5059
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_5060
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5065
<cons, cons>(q_gen_5054, q_gen_5015) -> q_gen_5068
<cons, cons>(q_gen_5054, q_gen_4998) -> q_gen_5074
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_5075
<cons, cons>(q_gen_5016, q_gen_5053) -> q_gen_5084
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5089
<cons, cons>(q_gen_5032, q_gen_5015) -> q_gen_5091
<cons, cons>(q_gen_4999, q_gen_5100) -> q_gen_5099
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5100
<cons, cons>(q_gen_5054, q_gen_5035) -> q_gen_5111
<cons, cons>(q_gen_5054, q_gen_5053) -> q_gen_5123
<cons, cons>(q_gen_5054, q_gen_5065) -> q_gen_5124
}

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

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

-------------------
STEPS:
-------------------------------------------
Step 0, which took 0.007939 s (model generation: 0.007495,  model checking: 0.000444):

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

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  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, eq_nat}
_|

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0
() -> insert([x, nil, cons(x, nil)]) -> 0
() -> leq([a, y]) -> 0
() -> leq([b, b]) -> 0
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 1
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 1
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 1
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1
(leq([b, a])) -> BOT -> 1
}
Sat witness: Found: (() -> sort([nil, nil]), {

})

-------------------------------------------
Step 1, which took 0.009027 s (model generation: 0.008990,  model checking: 0.000037):

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

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  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_4988},
Q_f={q_gen_4988},
Delta=
{
<nil, nil>() -> q_gen_4988
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0
() -> insert([x, nil, cons(x, nil)]) -> 0
() -> leq([a, y]) -> 0
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 1
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 1
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 1
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1
(leq([b, a])) -> BOT -> 1
}
Sat witness: Found: (() -> leq([b, b]), {

})

-------------------------------------------
Step 2, which took 0.010176 s (model generation: 0.010130,  model checking: 0.000046):

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

}

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

}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0
() -> insert([x, nil, cons(x, nil)]) -> 0
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 1
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 1
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 1
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1
(leq([b, a])) -> BOT -> 1
}
Sat witness: Found: (() -> leq([a, y]), {
y -> b
})

-------------------------------------------
Step 3, which took 0.007990 s (model generation: 0.007866,  model checking: 0.000124):

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

}

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

}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 0
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 1
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 1
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 1
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1
(leq([b, a])) -> BOT -> 1
}
Sat witness: Found: (() -> insert([x, nil, cons(x, nil)]), {
x -> b
})

-------------------------------------------
Step 4, which took 0.007528 s (model generation: 0.007388,  model checking: 0.000140):

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

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 1
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 1
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 1
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 1
(leq([b, a])) -> BOT -> 1
}
Sat witness: Found: (() -> append([nil, l2, l2]), {
l2 -> nil
})

-------------------------------------------
Step 5, which took 0.008522 s (model generation: 0.008294,  model checking: 0.000228):

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

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 1
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 1
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 1
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 1
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 2
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> b  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 6, which took 0.009050 s (model generation: 0.008864,  model checking: 0.000186):

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

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<b, b>() -> q_gen_4997
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 1
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 1
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 1
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 2
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> nil  ;  _ft -> cons(b, nil)  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 7, which took 0.008804 s (model generation: 0.008302,  model checking: 0.000502):

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

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<b, b>() -> q_gen_4997
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 1
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 1
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 4
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 2
}
Sat witness: Found: ((insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]), {
_zs -> cons(b, nil)  ;  x -> b  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 8, which took 0.009197 s (model generation: 0.008905,  model checking: 0.000292):

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

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 4
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 2
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 4
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 2
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> nil  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 9, which took 0.009541 s (model generation: 0.009523,  model checking: 0.000018):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005},
Q_f={q_gen_4994},
Delta=
{
<nil, nil>() -> q_gen_5004
<b, b>() -> q_gen_5005
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 3
() -> leq([b, b]) -> 3
() -> sort([nil, nil]) -> 3
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 4
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 2
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 4
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 5
}
Sat witness: Found: ((leq([b, a])) -> BOT, {

})

-------------------------------------------
Step 10, which took 0.009564 s (model generation: 0.009151,  model checking: 0.000413):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005},
Q_f={q_gen_4994},
Delta=
{
<nil, nil>() -> q_gen_5004
<b, b>() -> q_gen_5005
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3
() -> insert([x, nil, cons(x, nil)]) -> 3
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 4
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 3
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 4
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 5
}
Sat witness: Found: (() -> leq([a, y]), {
y -> a
})

-------------------------------------------
Step 11, which took 0.009829 s (model generation: 0.009383,  model checking: 0.000446):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005},
Q_f={q_gen_4994},
Delta=
{
<nil, nil>() -> q_gen_5004
<b, b>() -> q_gen_5005
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 3
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 4
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 4
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 4
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 5
}
Sat witness: Found: (() -> insert([x, nil, cons(x, nil)]), {
x -> a
})

-------------------------------------------
Step 12, which took 0.010150 s (model generation: 0.009877,  model checking: 0.000273):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005},
Q_f={q_gen_4994},
Delta=
{
<nil, nil>() -> q_gen_5004
<b, b>() -> q_gen_5005
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<a>() -> q_gen_4993
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 4
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 4
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 4
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 4
(leq([b, a])) -> BOT -> 5
}
Sat witness: Found: (() -> append([nil, l2, l2]), {
l2 -> cons(a, cons(a, nil))
})

-------------------------------------------
Step 13, which took 0.010135 s (model generation: 0.009638,  model checking: 0.000497):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005},
Q_f={q_gen_4994},
Delta=
{
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<a>() -> q_gen_4993
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 4
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 4
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 4
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 4
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7
(leq([b, a])) -> BOT -> 5
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 14, which took 0.010778 s (model generation: 0.010378,  model checking: 0.000400):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005},
Q_f={q_gen_4994},
Delta=
{
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<a>() -> q_gen_4993
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 4
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 4
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 4
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 7
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7
(leq([b, a])) -> BOT -> 5
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> nil  ;  _ft -> cons(a, nil)  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 15, which took 0.011140 s (model generation: 0.010555,  model checking: 0.000585):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005},
Q_f={q_gen_4994},
Delta=
{
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<a>() -> q_gen_4993
<b>() -> q_gen_4993
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 4
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 4
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 7
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 7
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7
(leq([b, a])) -> BOT -> 5
}
Sat witness: Found: ((insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]), {
_zs -> cons(a, cons(a, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 16, which took 0.013307 s (model generation: 0.012419,  model checking: 0.000888):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005},
Q_f={q_gen_4994},
Delta=
{
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<a>() -> q_gen_4993
<b>() -> q_gen_4993
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 6
() -> insert([x, nil, cons(x, nil)]) -> 6
() -> leq([a, y]) -> 6
() -> leq([b, b]) -> 4
() -> sort([nil, nil]) -> 4
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 7
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 5
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 7
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 7
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7
(leq([b, a])) -> BOT -> 5
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(b, nil)  ;  h1 -> b  ;  l2 -> cons(b, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 17, which took 0.014266 s (model generation: 0.012979,  model checking: 0.001287):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<a>() -> q_gen_4993
<b>() -> q_gen_4993
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 7
() -> insert([x, nil, cons(x, nil)]) -> 7
() -> leq([a, y]) -> 7
() -> leq([b, b]) -> 5
() -> sort([nil, nil]) -> 5
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 7
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 6
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 7
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 7
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10
(leq([b, a])) -> BOT -> 6
}
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 18, which took 0.015022 s (model generation: 0.014426,  model checking: 0.000596):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<a>() -> q_gen_4993
<b>() -> q_gen_4993
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 7
() -> insert([x, nil, cons(x, nil)]) -> 7
() -> leq([a, y]) -> 7
() -> leq([b, b]) -> 6
() -> sort([nil, nil]) -> 6
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 7
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 7
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 7
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 10
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10
(leq([b, a])) -> BOT -> 7
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> nil  ;  _ft -> cons(b, nil)  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 19, which took 0.015978 s (model generation: 0.015273,  model checking: 0.000705):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<a>() -> q_gen_4993
<b>() -> q_gen_4993
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 7
() -> insert([x, nil, cons(x, nil)]) -> 7
() -> leq([a, y]) -> 7
() -> leq([b, b]) -> 7
() -> sort([nil, nil]) -> 7
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 7
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 10
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 8
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 10
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10
(leq([b, a])) -> BOT -> 8
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(b, nil)  ;  _pt -> nil  ;  _qt -> cons(a, nil)  ;  l -> nil
})

-------------------------------------------
Step 20, which took 0.016595 s (model generation: 0.016238,  model checking: 0.000357):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5011, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<b, b>() -> q_gen_5005
<a, a>() -> q_gen_5011
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5011, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<a>() -> q_gen_4993
<b>() -> q_gen_4993
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 7
() -> insert([x, nil, cons(x, nil)]) -> 7
() -> leq([a, y]) -> 7
() -> leq([b, b]) -> 7
() -> sort([nil, nil]) -> 7
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 10
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 10
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 8
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 10
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 10
(leq([b, a])) -> BOT -> 8
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> nil  ;  h1 -> a  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 21, which took 0.017266 s (model generation: 0.015326,  model checking: 0.001940):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 8
() -> insert([x, nil, cons(x, nil)]) -> 8
() -> leq([a, y]) -> 8
() -> leq([b, b]) -> 8
() -> sort([nil, nil]) -> 8
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 10
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 10
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 9
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 13
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 11
(leq([b, a])) -> BOT -> 9
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(a, nil)  ;  _ft -> cons(b, cons(b, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 22, which took 0.019962 s (model generation: 0.018046,  model checking: 0.001916):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5014},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 9
() -> insert([x, nil, cons(x, nil)]) -> 9
() -> leq([a, y]) -> 9
() -> leq([b, b]) -> 9
() -> sort([nil, nil]) -> 9
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 13
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 11
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 10
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 13
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 11
(leq([b, a])) -> BOT -> 10
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(b, nil)  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 23, which took 0.021044 s (model generation: 0.018632,  model checking: 0.002412):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5014},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 10
() -> insert([x, nil, cons(x, nil)]) -> 10
() -> leq([a, y]) -> 10
() -> leq([b, b]) -> 10
() -> sort([nil, nil]) -> 10
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 13
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 12
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 11
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 16
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 12
(leq([b, a])) -> BOT -> 11
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(b, nil)  ;  _ft -> cons(a, cons(b, nil))  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 24, which took 0.023309 s (model generation: 0.018629,  model checking: 0.004680):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5029, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5029, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5029
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_5029, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 11
() -> insert([x, nil, cons(x, nil)]) -> 11
() -> leq([a, y]) -> 11
() -> leq([b, b]) -> 11
() -> sort([nil, nil]) -> 11
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 16
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 13
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 12
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 16
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 13
(leq([b, a])) -> BOT -> 12
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(b, nil)  ;  h1 -> a  ;  l2 -> cons(b, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 25, which took 0.021917 s (model generation: 0.020118,  model checking: 0.001799):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<a, b>() -> q_gen_5002
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 12
() -> insert([x, nil, cons(x, nil)]) -> 12
() -> leq([a, y]) -> 12
() -> leq([b, b]) -> 12
() -> sort([nil, nil]) -> 12
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 16
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 13
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 15
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 16
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 13
(leq([b, a])) -> BOT -> 13
}
Sat witness: Found: ((insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]), {
_zs -> cons(b, cons(a, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 26, which took 0.025914 s (model generation: 0.022533,  model checking: 0.003381):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5029, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5029, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5029
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_5029, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 13
() -> insert([x, nil, cons(x, nil)]) -> 13
() -> leq([a, y]) -> 13
() -> leq([b, b]) -> 13
() -> sort([nil, nil]) -> 13
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 16
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 14
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 16
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 14
(leq([b, a])) -> BOT -> 14
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(b, nil)  ;  _ft -> cons(b, cons(b, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 27, which took 0.024068 s (model generation: 0.022771,  model checking: 0.001297):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<b, a>() -> q_gen_5013
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 14
() -> insert([x, nil, cons(x, nil)]) -> 14
() -> leq([a, y]) -> 14
() -> leq([b, b]) -> 14
() -> sort([nil, nil]) -> 14
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 16
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 14
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 16
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 17
(leq([b, a])) -> BOT -> 15
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 28, which took 0.025870 s (model generation: 0.024916,  model checking: 0.000954):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5014},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5015, q_gen_5016},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_4998
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<a, b>() -> q_gen_5016
<b, a>() -> q_gen_5016
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 14
() -> insert([x, nil, cons(x, nil)]) -> 14
() -> leq([a, y]) -> 14
() -> leq([b, b]) -> 14
() -> sort([nil, nil]) -> 14
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 16
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 17
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 16
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 17
(leq([b, a])) -> BOT -> 15
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(b, cons(b, nil))  ;  _pt -> cons(b, nil)  ;  _qt -> cons(a, nil)  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 29, which took 0.028256 s (model generation: 0.025195,  model checking: 0.003061):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 15
() -> insert([x, nil, cons(x, nil)]) -> 15
() -> leq([a, y]) -> 15
() -> leq([b, b]) -> 15
() -> sort([nil, nil]) -> 15
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 19
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 17
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 17
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 17
(leq([b, a])) -> BOT -> 16
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(a, nil)  ;  h1 -> b  ;  l2 -> cons(a, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 30, which took 0.031549 s (model generation: 0.028165,  model checking: 0.003384):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 16
() -> insert([x, nil, cons(x, nil)]) -> 16
() -> leq([a, y]) -> 16
() -> leq([b, b]) -> 16
() -> sort([nil, nil]) -> 16
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 19
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 18
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 18
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 18
(leq([b, a])) -> BOT -> 17
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> nil  ;  _ft -> cons(a, nil)  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 31, which took 0.031666 s (model generation: 0.028801,  model checking: 0.002865):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 17
() -> insert([x, nil, cons(x, nil)]) -> 17
() -> leq([a, y]) -> 17
() -> leq([b, b]) -> 17
() -> sort([nil, nil]) -> 17
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 19
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 21
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 19
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 19
(leq([b, a])) -> BOT -> 18
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(a, nil)  ;  _pt -> nil  ;  _qt -> cons(a, cons(b, nil))  ;  l -> nil
})

-------------------------------------------
Step 32, which took 0.034589 s (model generation: 0.029998,  model checking: 0.004591):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5014},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5015, q_gen_5016},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_4998
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<a, b>() -> q_gen_5016
<b, a>() -> q_gen_5016
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 18
() -> insert([x, nil, cons(x, nil)]) -> 18
() -> leq([a, y]) -> 18
() -> leq([b, b]) -> 18
() -> sort([nil, nil]) -> 18
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 22
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 21
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 20
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 20
(leq([b, a])) -> BOT -> 19
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(a, nil)  ;  h1 -> a  ;  l2 -> cons(a, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 33, which took 0.031495 s (model generation: 0.030538,  model checking: 0.000957):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5010, q_gen_5021, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5010
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5010
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5010) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5021
<cons, cons, cons>(q_gen_5026, q_gen_5021) -> q_gen_5021
<cons, nil, cons>(q_gen_5005, q_gen_5010) -> q_gen_5021
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5021
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5021
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5031, q_gen_5032},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4998
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_4998
<a, a>() -> q_gen_4999
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 21
() -> insert([x, nil, cons(x, nil)]) -> 19
() -> leq([a, y]) -> 19
() -> leq([b, b]) -> 19
() -> sort([nil, nil]) -> 19
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 22
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 21
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 20
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 20
(leq([b, a])) -> BOT -> 19
}
Sat witness: Found: (() -> append([nil, l2, l2]), {
l2 -> cons(b, nil)
})

-------------------------------------------
Step 34, which took 0.033352 s (model generation: 0.030789,  model checking: 0.002563):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5014},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5015, q_gen_5016},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_4998
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<a, b>() -> q_gen_5016
<b, a>() -> q_gen_5016
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 21
() -> insert([x, nil, cons(x, nil)]) -> 20
() -> leq([a, y]) -> 20
() -> leq([b, b]) -> 20
() -> sort([nil, nil]) -> 20
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 22
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 24
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 21
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 21
(leq([b, a])) -> BOT -> 20
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(b, cons(a, nil))  ;  _pt -> cons(a, nil)  ;  _qt -> cons(a, cons(b, nil))  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 35, which took 0.037797 s (model generation: 0.034065,  model checking: 0.003732):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 22
() -> insert([x, nil, cons(x, nil)]) -> 21
() -> leq([a, y]) -> 21
() -> leq([b, b]) -> 21
() -> sort([nil, nil]) -> 21
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 22
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 24
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 22
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 22
(leq([b, a])) -> BOT -> 21
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(a, nil)  ;  _ft -> cons(a, cons(b, nil))  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 36, which took 0.042875 s (model generation: 0.034225,  model checking: 0.008650):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 22
() -> insert([x, nil, cons(x, nil)]) -> 22
() -> leq([a, y]) -> 22
() -> leq([b, b]) -> 22
() -> sort([nil, nil]) -> 22
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 25
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 24
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 23
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 23
(leq([b, a])) -> BOT -> 22
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(b, cons(b, cons(b, nil)))  ;  h1 -> a  ;  l2 -> cons(b, nil)  ;  t1 -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 37, which took 0.044151 s (model generation: 0.040317,  model checking: 0.003834):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5010, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5010
<cons, cons>(q_gen_5005, q_gen_5010) -> q_gen_5010
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5010
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5010) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5010) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 23
() -> insert([x, nil, cons(x, nil)]) -> 23
() -> leq([a, y]) -> 23
() -> leq([b, b]) -> 23
() -> sort([nil, nil]) -> 23
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 25
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 27
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 24
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 24
(leq([b, a])) -> BOT -> 23
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(a, cons(b, nil))  ;  _pt -> cons(a, nil)  ;  _qt -> cons(a, cons(a, nil))  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 38, which took 0.045357 s (model generation: 0.044076,  model checking: 0.001281):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<b, a>() -> q_gen_5013
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 24
() -> insert([x, nil, cons(x, nil)]) -> 24
() -> leq([a, y]) -> 24
() -> leq([b, b]) -> 24
() -> sort([nil, nil]) -> 24
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 25
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 27
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 24
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 27
(leq([b, a])) -> BOT -> 24
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 39, which took 0.047590 s (model generation: 0.045116,  model checking: 0.002474):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5014},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5015, q_gen_5016, q_gen_5054},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_5016, q_gen_5015) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_4998
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<cons, cons>(q_gen_5054, q_gen_5015) -> q_gen_5015
<a, b>() -> q_gen_5016
<b, a>() -> q_gen_5016
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 25
() -> insert([x, nil, cons(x, nil)]) -> 25
() -> leq([a, y]) -> 25
() -> leq([b, b]) -> 25
() -> sort([nil, nil]) -> 25
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 25
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 27
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 25
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 27
(leq([b, a])) -> BOT -> 25
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(b, nil)  ;  _ft -> cons(a, cons(a, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 40, which took 0.051164 s (model generation: 0.049157,  model checking: 0.002007):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 25
() -> insert([x, nil, cons(x, nil)]) -> 25
() -> leq([a, y]) -> 25
() -> leq([b, b]) -> 25
() -> sort([nil, nil]) -> 25
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 25
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 27
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 28
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 27
(leq([b, a])) -> BOT -> 26
}
Sat witness: Found: ((insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]), {
_zs -> cons(b, cons(b, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 41, which took 0.048987 s (model generation: 0.048577,  model checking: 0.000410):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5010, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5010) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5010
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5010
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5010) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5010) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 25
() -> insert([x, nil, cons(x, nil)]) -> 25
() -> leq([a, y]) -> 25
() -> leq([b, b]) -> 25
() -> sort([nil, nil]) -> 25
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 28
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 27
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 28
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 27
(leq([b, a])) -> BOT -> 26
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(a, nil)  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> cons(a, nil)
})

-------------------------------------------
Step 42, which took 0.054280 s (model generation: 0.052750,  model checking: 0.001530):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 26
() -> insert([x, nil, cons(x, nil)]) -> 26
() -> leq([a, y]) -> 26
() -> leq([b, b]) -> 26
() -> sort([nil, nil]) -> 26
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 28
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 27
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 28
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 30
(leq([b, a])) -> BOT -> 27
}
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 43, which took 0.055411 s (model generation: 0.052764,  model checking: 0.002647):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 27
() -> insert([x, nil, cons(x, nil)]) -> 27
() -> leq([a, y]) -> 27
() -> leq([b, b]) -> 27
() -> sort([nil, nil]) -> 27
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 28
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 30
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 28
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 30
(leq([b, a])) -> BOT -> 28
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(a, cons(b, nil))  ;  _pt -> cons(b, nil)  ;  _qt -> cons(a, cons(a, nil))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 44, which took 0.058305 s (model generation: 0.057280,  model checking: 0.001025):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5010, q_gen_5011, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5048, q_gen_5051},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<nil, nil>() -> q_gen_5004
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5010) -> q_gen_5010
<cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_5010
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5010
<a, a>() -> q_gen_5011
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5010) -> q_gen_4994
<cons, nil, cons>(q_gen_5011, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5011, q_gen_5010) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, cons, cons>(q_gen_5026, q_gen_5048) -> q_gen_5048
<cons, nil, cons>(q_gen_5011, q_gen_5010) -> q_gen_5048
<nil, cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_5048
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5048
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 30
() -> insert([x, nil, cons(x, nil)]) -> 28
() -> leq([a, y]) -> 28
() -> leq([b, b]) -> 28
() -> sort([nil, nil]) -> 28
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 28
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 30
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 28
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 30
(leq([b, a])) -> BOT -> 28
}
Sat witness: Found: (() -> append([nil, l2, l2]), {
l2 -> cons(a, nil)
})

-------------------------------------------
Step 45, which took 0.059815 s (model generation: 0.058767,  model checking: 0.001048):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5015, q_gen_5016},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_5016, q_gen_5015) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_5015
<cons, cons>(q_gen_4999, q_gen_5015) -> q_gen_5015
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_5015
<a, b>() -> q_gen_5016
<b, a>() -> q_gen_5016
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 30
() -> insert([x, nil, cons(x, nil)]) -> 28
() -> leq([a, y]) -> 28
() -> leq([b, b]) -> 28
() -> sort([nil, nil]) -> 28
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 28
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 30
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 28
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 30
(leq([b, a])) -> BOT -> 29
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(b, nil)  ;  _ft -> cons(b, cons(b, nil))  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 46, which took 0.071321 s (model generation: 0.062413,  model checking: 0.008908):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5016, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_4998
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_4998
<b, b>() -> q_gen_4999
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_4998) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 30
() -> insert([x, nil, cons(x, nil)]) -> 28
() -> leq([a, y]) -> 28
() -> leq([b, b]) -> 28
() -> sort([nil, nil]) -> 28
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 31
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 30
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 29
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 30
(leq([b, a])) -> BOT -> 29
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(b, cons(a, nil))  ;  h1 -> a  ;  l2 -> cons(b, cons(a, nil))  ;  t1 -> nil
})

-------------------------------------------
Step 47, which took 0.076903 s (model generation: 0.068854,  model checking: 0.008049):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5016, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_4998
<b, b>() -> q_gen_4999
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_4998) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 30
() -> insert([x, nil, cons(x, nil)]) -> 29
() -> leq([a, y]) -> 29
() -> leq([b, b]) -> 29
() -> sort([nil, nil]) -> 29
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 31
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 33
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 30
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 31
(leq([b, a])) -> BOT -> 30
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(b, cons(b, nil))  ;  _pt -> cons(b, nil)  ;  _qt -> cons(a, cons(a, nil))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 48, which took 0.085267 s (model generation: 0.081759,  model checking: 0.003508):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 31
() -> insert([x, nil, cons(x, nil)]) -> 30
() -> leq([a, y]) -> 30
() -> leq([b, b]) -> 30
() -> sort([nil, nil]) -> 30
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 31
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 33
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 31
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 34
(leq([b, a])) -> BOT -> 31
}
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 49, which took 0.073435 s (model generation: 0.070977,  model checking: 0.002458):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 31
() -> insert([x, nil, cons(x, nil)]) -> 31
() -> leq([a, y]) -> 31
() -> leq([b, b]) -> 31
() -> sort([nil, nil]) -> 31
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 31
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 33
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 31
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 34
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 34
(leq([b, a])) -> BOT -> 32
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(a, nil)  ;  _ft -> cons(a, cons(a, nil))  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 50, which took 0.075925 s (model generation: 0.071493,  model checking: 0.004432):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 31
() -> insert([x, nil, cons(x, nil)]) -> 31
() -> leq([a, y]) -> 31
() -> leq([b, b]) -> 31
() -> sort([nil, nil]) -> 31
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 34
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 33
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 32
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 34
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 34
(leq([b, a])) -> BOT -> 32
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(a, nil)  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 51, which took 0.080891 s (model generation: 0.072950,  model checking: 0.007941):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5016, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_4998
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4998
<b, b>() -> q_gen_4999
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_4998) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 32
() -> insert([x, nil, cons(x, nil)]) -> 32
() -> leq([a, y]) -> 32
() -> leq([b, b]) -> 32
() -> sort([nil, nil]) -> 32
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 34
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 36
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 33
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 34
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 34
(leq([b, a])) -> BOT -> 33
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(a, cons(a, nil))  ;  _pt -> cons(b, nil)  ;  _qt -> cons(a, nil)  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 52, which took 0.082686 s (model generation: 0.074830,  model checking: 0.007856):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<a>() -> q_gen_5025
<b>() -> q_gen_5025
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<a, b, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5015, q_gen_5016, q_gen_5054},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5015) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4998
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_5015
<cons, cons>(q_gen_5054, q_gen_4998) -> q_gen_5015
<cons, cons>(q_gen_5054, q_gen_5015) -> q_gen_5015
<a, b>() -> q_gen_5016
<b, a>() -> q_gen_5016
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 33
() -> insert([x, nil, cons(x, nil)]) -> 33
() -> leq([a, y]) -> 33
() -> leq([b, b]) -> 33
() -> sort([nil, nil]) -> 33
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 34
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 36
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 34
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 37
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 35
(leq([b, a])) -> BOT -> 34
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(b, nil)  ;  _ft -> cons(a, cons(b, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 53, which took 0.083492 s (model generation: 0.082558,  model checking: 0.000934):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5011, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5041, q_gen_5050, q_gen_5051},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5004
<cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<b, b>() -> q_gen_5005
<a, a>() -> q_gen_5011
<a, b>() -> q_gen_5011
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_4994
<cons, cons, cons>(q_gen_5041, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_4994
<cons, nil, cons>(q_gen_5011, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5011, q_gen_5037) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, a, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, b, a>() -> q_gen_5041
<cons, cons, cons>(q_gen_5041, q_gen_5050) -> q_gen_5050
<cons, nil, cons>(q_gen_5011, q_gen_5037) -> q_gen_5050
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 36
() -> insert([x, nil, cons(x, nil)]) -> 34
() -> leq([a, y]) -> 34
() -> leq([b, b]) -> 34
() -> sort([nil, nil]) -> 34
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 34
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 36
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 34
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 37
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 35
(leq([b, a])) -> BOT -> 34
}
Sat witness: Found: (() -> append([nil, l2, l2]), {
l2 -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 54, which took 0.083801 s (model generation: 0.079088,  model checking: 0.004713):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5010, q_gen_5011, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5041, q_gen_5050, q_gen_5051},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5010) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5010
<cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_5010
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5010
<a, a>() -> q_gen_5011
<a, b>() -> q_gen_5011
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_4994
<cons, cons, cons>(q_gen_5041, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5010) -> q_gen_4994
<cons, nil, cons>(q_gen_5011, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5010) -> q_gen_4994
<nil, cons, cons>(q_gen_5011, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5011, q_gen_5010) -> q_gen_4994
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<a, a, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, b, a>() -> q_gen_5041
<cons, cons, cons>(q_gen_5041, q_gen_5050) -> q_gen_5050
<cons, nil, cons>(q_gen_5011, q_gen_5010) -> q_gen_5050
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 36
() -> insert([x, nil, cons(x, nil)]) -> 34
() -> leq([a, y]) -> 34
() -> leq([b, b]) -> 34
() -> sort([nil, nil]) -> 34
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 37
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 36
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 35
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 37
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 35
(leq([b, a])) -> BOT -> 35
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(b, nil)  ;  h1 -> a  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 55, which took 0.081083 s (model generation: 0.074690,  model checking: 0.006393):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5009, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052},
Q_f={q_gen_4994, q_gen_5009},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5009) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_5009
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_5009
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5009
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 36
() -> insert([x, nil, cons(x, nil)]) -> 35
() -> leq([a, y]) -> 35
() -> leq([b, b]) -> 35
() -> sort([nil, nil]) -> 35
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 37
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 39
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 36
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 37
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 36
(leq([b, a])) -> BOT -> 36
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(b, cons(b, nil))  ;  _pt -> cons(a, nil)  ;  _qt -> cons(a, nil)  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 56, which took 0.089639 s (model generation: 0.086504,  model checking: 0.003135):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5047, q_gen_5051, q_gen_5052},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5047) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5047) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5047
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5047
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5016, q_gen_5031, q_gen_5032},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_4998
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 37
() -> insert([x, nil, cons(x, nil)]) -> 36
() -> leq([a, y]) -> 36
() -> leq([b, b]) -> 36
() -> sort([nil, nil]) -> 36
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 37
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 39
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 37
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 40
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 37
(leq([b, a])) -> BOT -> 37
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(b, nil)  ;  _ft -> cons(b, cons(a, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 57, which took 0.092288 s (model generation: 0.088804,  model checking: 0.003484):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5047, q_gen_5051, q_gen_5052},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5047) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5047) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5047
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5047
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5014},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5016, q_gen_5031, q_gen_5032},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_4998
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 37
() -> insert([x, nil, cons(x, nil)]) -> 37
() -> leq([a, y]) -> 37
() -> leq([b, b]) -> 37
() -> sort([nil, nil]) -> 37
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 40
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 39
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 38
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 40
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 38
(leq([b, a])) -> BOT -> 38
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(a, cons(b, cons(a, nil)))  ;  h1 -> b  ;  l2 -> cons(b, cons(b, nil))  ;  t1 -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 58, which took 0.125574 s (model generation: 0.117574,  model checking: 0.008000):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5036, q_gen_5037, q_gen_5051, q_gen_5052},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<a, b>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5036) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5036) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5036
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5036
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 38
() -> insert([x, nil, cons(x, nil)]) -> 38
() -> leq([a, y]) -> 38
() -> leq([b, b]) -> 38
() -> sort([nil, nil]) -> 38
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 40
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 42
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 39
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 40
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 39
(leq([b, a])) -> BOT -> 39
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(a, nil)  ;  _pt -> nil  ;  _qt -> cons(b, nil)  ;  l -> nil
})

-------------------------------------------
Step 59, which took 0.098837 s (model generation: 0.091686,  model checking: 0.007151):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5016, q_gen_5031, q_gen_5032},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 39
() -> insert([x, nil, cons(x, nil)]) -> 39
() -> leq([a, y]) -> 39
() -> leq([b, b]) -> 39
() -> sort([nil, nil]) -> 39
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 40
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 42
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 40
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 43
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 40
(leq([b, a])) -> BOT -> 40
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(a, cons(a, nil))  ;  _ft -> cons(b, cons(b, cons(b, nil)))  ;  y -> b  ;  z -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 60, which took 0.774660 s (model generation: 0.112464,  model checking: 0.662196):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4998) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4998
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_4998
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 40
() -> insert([x, nil, cons(x, nil)]) -> 40
() -> leq([a, y]) -> 40
() -> leq([b, b]) -> 40
() -> sort([nil, nil]) -> 40
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 43
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 42
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 41
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 43
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 41
(leq([b, a])) -> BOT -> 41
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(b, cons(b, nil))  ;  h1 -> a  ;  l2 -> cons(b, nil)  ;  t1 -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 61, which took 0.164289 s (model generation: 0.155998,  model checking: 0.008291):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<a, b>() -> q_gen_4997
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_5054, q_gen_4998) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4998
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4998
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_4998
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4998
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 41
() -> insert([x, nil, cons(x, nil)]) -> 41
() -> leq([a, y]) -> 41
() -> leq([b, b]) -> 41
() -> sort([nil, nil]) -> 41
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 43
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 45
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 42
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 43
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 42
(leq([b, a])) -> BOT -> 42
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(b, cons(b, nil))  ;  _pt -> cons(a, nil)  ;  _qt -> cons(a, nil)  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 62, which took 0.159995 s (model generation: 0.155535,  model checking: 0.004460):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5002
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 42
() -> insert([x, nil, cons(x, nil)]) -> 42
() -> leq([a, y]) -> 42
() -> leq([b, b]) -> 42
() -> sort([nil, nil]) -> 42
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 43
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 45
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 43
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 46
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 43
(leq([b, a])) -> BOT -> 43
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(a, nil)  ;  _ft -> cons(a, cons(b, nil))  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 63, which took 0.200335 s (model generation: 0.192896,  model checking: 0.007439):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5036, q_gen_5037, q_gen_5041, q_gen_5051, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5004
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5036) -> q_gen_4994
<cons, cons, cons>(q_gen_5041, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5041, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5041, q_gen_5036) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5036
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5036
<a, b, a>() -> q_gen_5041
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 43
() -> insert([x, nil, cons(x, nil)]) -> 43
() -> leq([a, y]) -> 43
() -> leq([b, b]) -> 43
() -> sort([nil, nil]) -> 43
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 46
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 45
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 44
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 46
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 44
(leq([b, a])) -> BOT -> 44
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(a, cons(b, nil))  ;  h1 -> b  ;  l2 -> cons(b, nil)  ;  t1 -> cons(a, cons(a, nil))
})

-------------------------------------------
Step 64, which took 0.306669 s (model generation: 0.297366,  model checking: 0.009303):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5036, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5036) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5026, q_gen_5036) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5036
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5036
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5036
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

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

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 44
() -> insert([x, nil, cons(x, nil)]) -> 44
() -> leq([a, y]) -> 44
() -> leq([b, b]) -> 44
() -> sort([nil, nil]) -> 44
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 46
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 48
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 45
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 46
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 45
(leq([b, a])) -> BOT -> 45
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(b, cons(b, nil))  ;  _pt -> cons(a, nil)  ;  _qt -> cons(a, cons(a, nil))  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 65, which took 0.220493 s (model generation: 0.218714,  model checking: 0.001779):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5017, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<a, b>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5017
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5017
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5017
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5017
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5017
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5017
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5016, q_gen_5031, q_gen_5032},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 45
() -> insert([x, nil, cons(x, nil)]) -> 45
() -> leq([a, y]) -> 45
() -> leq([b, b]) -> 45
() -> sort([nil, nil]) -> 45
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 46
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 48
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 45
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 46
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 48
(leq([b, a])) -> BOT -> 46
}
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 66, which took 0.231402 s (model generation: 0.230151,  model checking: 0.001251):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5017, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<a, b>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5017
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5017
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5017
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5017
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5017
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5016, q_gen_5031, q_gen_5032},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 45
() -> insert([x, nil, cons(x, nil)]) -> 45
() -> leq([a, y]) -> 45
() -> leq([b, b]) -> 45
() -> sort([nil, nil]) -> 45
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 46
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 48
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 48
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 46
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 48
(leq([b, a])) -> BOT -> 46
}
Sat witness: Found: ((insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]), {
_zs -> cons(a, nil)  ;  x -> b  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 67, which took 0.225054 s (model generation: 0.214629,  model checking: 0.010425):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5018, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 46
() -> insert([x, nil, cons(x, nil)]) -> 46
() -> leq([a, y]) -> 46
() -> leq([b, b]) -> 46
() -> sort([nil, nil]) -> 46
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 46
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 48
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 48
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 48
(leq([b, a])) -> BOT -> 47
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(a, cons(a, nil))  ;  _ft -> cons(a, cons(b, cons(b, nil)))  ;  y -> a  ;  z -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 68, which took 1.019244 s (model generation: 0.296849,  model checking: 0.722395):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5018, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<a, b>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 46
() -> insert([x, nil, cons(x, nil)]) -> 46
() -> leq([a, y]) -> 46
() -> leq([b, b]) -> 46
() -> sort([nil, nil]) -> 46
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 49
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 48
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 48
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 48
(leq([b, a])) -> BOT -> 47
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(a, cons(a, nil))  ;  h1 -> a  ;  l2 -> cons(a, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 69, which took 0.295582 s (model generation: 0.288296,  model checking: 0.007286):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5015, q_gen_5016, q_gen_5032},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5015) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_4999, q_gen_5015) -> q_gen_5015
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5015
<cons, cons>(q_gen_5032, q_gen_5015) -> q_gen_5015
<b, a>() -> q_gen_5016
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 47
() -> insert([x, nil, cons(x, nil)]) -> 47
() -> leq([a, y]) -> 47
() -> leq([b, b]) -> 47
() -> sort([nil, nil]) -> 47
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 49
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 48
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 51
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 49
(leq([b, a])) -> BOT -> 48
}
Sat witness: Found: ((insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]), {
_zs -> cons(a, cons(b, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 70, which took 0.468367 s (model generation: 0.465318,  model checking: 0.003049):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5015, q_gen_5016, q_gen_5031, q_gen_5032},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5032, q_gen_5015) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_4999, q_gen_5015) -> q_gen_5031
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 48
() -> insert([x, nil, cons(x, nil)]) -> 48
() -> leq([a, y]) -> 48
() -> leq([b, b]) -> 48
() -> sort([nil, nil]) -> 48
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 49
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 51
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 51
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 49
(leq([b, a])) -> BOT -> 49
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(a, nil)  ;  _pt -> nil  ;  _qt -> cons(a, cons(a, nil))  ;  l -> nil
})

-------------------------------------------
Step 71, which took 0.494643 s (model generation: 0.490602,  model checking: 0.004041):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5036, q_gen_5037, q_gen_5041, q_gen_5051, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5004
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5036) -> q_gen_4994
<cons, cons, cons>(q_gen_5041, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5041, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5041, q_gen_5036) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5036
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5036
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5036
<a, b, a>() -> q_gen_5041
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, b>() -> q_gen_5013
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5015, q_gen_5016, q_gen_5031, q_gen_5032},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5032, q_gen_5015) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<b, a>() -> q_gen_5016
<cons, cons>(q_gen_4999, q_gen_5015) -> q_gen_5031
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 49
() -> insert([x, nil, cons(x, nil)]) -> 49
() -> leq([a, y]) -> 49
() -> leq([b, b]) -> 49
() -> sort([nil, nil]) -> 49
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 49
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 51
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 51
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 52
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 50
(leq([b, a])) -> BOT -> 50
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(a, nil)  ;  _ft -> cons(b, cons(b, nil))  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 72, which took 0.402758 s (model generation: 0.401232,  model checking: 0.001526):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5036, q_gen_5037, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5036) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, cons, cons>(q_gen_5026, q_gen_5036) -> q_gen_5036
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5036
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5036
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5036
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5015, q_gen_5016, q_gen_5032},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5015) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_4999, q_gen_5015) -> q_gen_5015
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5015
<cons, cons>(q_gen_5032, q_gen_5015) -> q_gen_5015
<b, a>() -> q_gen_5016
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 49
() -> insert([x, nil, cons(x, nil)]) -> 49
() -> leq([a, y]) -> 49
() -> leq([b, b]) -> 49
() -> sort([nil, nil]) -> 49
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 52
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 51
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 51
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 52
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 50
(leq([b, a])) -> BOT -> 50
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(a, cons(b, nil))  ;  h1 -> a  ;  l2 -> cons(b, nil)  ;  t1 -> cons(a, nil)
})

-------------------------------------------
Step 73, which took 0.828224 s (model generation: 0.826925,  model checking: 0.001299):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5041, q_gen_5050, q_gen_5051, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_4994
<cons, cons, cons>(q_gen_5041, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5041, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5041, q_gen_5050) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, b, a>() -> q_gen_5041
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5018, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<a, b>() -> q_gen_5002
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4998
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_4998
<cons, cons>(q_gen_5054, q_gen_4998) -> q_gen_4998
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 50
() -> insert([x, nil, cons(x, nil)]) -> 50
() -> leq([a, y]) -> 50
() -> leq([b, b]) -> 50
() -> sort([nil, nil]) -> 50
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 52
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 51
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 51
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 52
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 53
(leq([b, a])) -> BOT -> 51
}
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 74, which took 0.346027 s (model generation: 0.337711,  model checking: 0.008316):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5050, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5050) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_5050
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5050
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5018, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<b, a>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<a, b>() -> q_gen_5002
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4998, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988, q_gen_4998},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4998) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4998
<cons, cons>(q_gen_4999, q_gen_4998) -> q_gen_4998
<cons, cons>(q_gen_5032, q_gen_4998) -> q_gen_4998
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4998
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 51
() -> insert([x, nil, cons(x, nil)]) -> 51
() -> leq([a, y]) -> 51
() -> leq([b, b]) -> 51
() -> sort([nil, nil]) -> 51
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 52
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 54
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 52
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 52
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 53
(leq([b, a])) -> BOT -> 52
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(b, cons(a, nil))  ;  _pt -> cons(b, nil)  ;  _qt -> cons(a, cons(b, nil))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 75, which took 0.444170 s (model generation: 0.435073,  model checking: 0.009097):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5050, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5050) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_5050
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5050
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5018, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 52
() -> insert([x, nil, cons(x, nil)]) -> 52
() -> leq([a, y]) -> 52
() -> leq([b, b]) -> 52
() -> sort([nil, nil]) -> 52
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 52
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 54
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 52
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 55
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 53
(leq([b, a])) -> BOT -> 53
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(a, cons(a, nil))  ;  _ft -> cons(a, cons(a, cons(b, nil)))  ;  y -> a  ;  z -> cons(a, cons(a, nil))
})

-------------------------------------------
Step 76, which took 0.458342 s (model generation: 0.451000,  model checking: 0.007342):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5050, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5050) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_5050
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_5050
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5050
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5018, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 52
() -> insert([x, nil, cons(x, nil)]) -> 52
() -> leq([a, y]) -> 52
() -> leq([b, b]) -> 52
() -> sort([nil, nil]) -> 52
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 55
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 54
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 53
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 55
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 53
(leq([b, a])) -> BOT -> 53
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(b, cons(b, nil))  ;  h1 -> a  ;  l2 -> cons(a, nil)  ;  t1 -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 77, which took 0.629377 s (model generation: 0.615586,  model checking: 0.013791):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5041, q_gen_5050, q_gen_5051, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_4994
<cons, cons, cons>(q_gen_5041, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5041, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5041, q_gen_5050) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, b, a>() -> q_gen_5041
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5050
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5018, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5054},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_4988
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<a, b>() -> q_gen_5032
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 53
() -> insert([x, nil, cons(x, nil)]) -> 53
() -> leq([a, y]) -> 53
() -> leq([b, b]) -> 53
() -> sort([nil, nil]) -> 53
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 55
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 57
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 54
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 55
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 54
(leq([b, a])) -> BOT -> 54
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(a, cons(a, nil))  ;  _pt -> cons(a, nil)  ;  _qt -> cons(a, cons(a, cons(a, nil)))  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 78, which took 0.617052 s (model generation: 0.599113,  model checking: 0.017939):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5041, q_gen_5050, q_gen_5051, q_gen_5080, q_gen_5115},
Q_f={q_gen_4994},
Delta=
{
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5115
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_4994
<cons, cons, cons>(q_gen_5041, q_gen_5023) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, cons>(q_gen_5051, q_gen_5115) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5041, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5041, q_gen_5050) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, a, a>() -> q_gen_5026
<b, a, b>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<a, b, a>() -> q_gen_5041
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5014, q_gen_5018},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5014
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5014
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5014
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5014
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5014
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5014
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5015, q_gen_5016, q_gen_5032},
Q_f={q_gen_4988},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<cons, cons>(q_gen_5016, q_gen_5015) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<a, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_4999, q_gen_5015) -> q_gen_5015
<cons, cons>(q_gen_5016, q_gen_4988) -> q_gen_5015
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5015
<cons, cons>(q_gen_5032, q_gen_5015) -> q_gen_5015
<b, a>() -> q_gen_5016
<a, b>() -> q_gen_5032
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 54
() -> insert([x, nil, cons(x, nil)]) -> 54
() -> leq([a, y]) -> 54
() -> leq([b, b]) -> 54
() -> sort([nil, nil]) -> 54
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 55
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 57
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 55
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 58
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 55
(leq([b, a])) -> BOT -> 55
}
Sat witness: Found: ((insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]), {
_et -> cons(a, nil)  ;  _ft -> cons(b, cons(b, nil))  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 79, which took 0.582219 s (model generation: 0.565754,  model checking: 0.016465):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5050, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5050) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_5050
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5050
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5018, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5053, q_gen_5054},
Q_f={q_gen_4988, q_gen_5053},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5053) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5053) -> q_gen_5031
<a, b>() -> q_gen_5032
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5053
<cons, cons>(q_gen_4999, q_gen_5053) -> q_gen_5053
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_5053
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 55
() -> insert([x, nil, cons(x, nil)]) -> 55
() -> leq([a, y]) -> 55
() -> leq([b, b]) -> 55
() -> sort([nil, nil]) -> 55
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 58
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 57
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 56
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 58
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 56
(leq([b, a])) -> BOT -> 56
}
Sat witness: Found: ((append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]), {
_jt -> cons(b, cons(a, nil))  ;  h1 -> b  ;  l2 -> cons(a, nil)  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 80, which took 0.855686 s (model generation: 0.678151,  model checking: 0.177535):

Model:
|_
{
append -> 
{{{
Q={q_gen_4994, q_gen_5004, q_gen_5005, q_gen_5023, q_gen_5024, q_gen_5025, q_gen_5026, q_gen_5037, q_gen_5050, q_gen_5051, q_gen_5052, q_gen_5080},
Q_f={q_gen_4994},
Delta=
{
<cons>(q_gen_5051, q_gen_5024) -> q_gen_5024
<nil>() -> q_gen_5024
<b>() -> q_gen_5025
<a>() -> q_gen_5051
<cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_5004
<cons, cons>(q_gen_5080, q_gen_5004) -> q_gen_5004
<nil, nil>() -> q_gen_5004
<a, a>() -> q_gen_5005
<b, b>() -> q_gen_5005
<cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5037
<nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5037
<nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5037
<a, b>() -> q_gen_5080
<cons, cons, cons>(q_gen_5026, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_4994) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5023) -> q_gen_4994
<cons, cons, cons>(q_gen_5052, q_gen_5050) -> q_gen_4994
<cons, nil, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, cons, cons>(q_gen_5005, q_gen_5004) -> q_gen_4994
<nil, nil, nil>() -> q_gen_4994
<cons, cons, cons>(q_gen_5026, q_gen_4994) -> q_gen_5023
<cons, nil, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5005, q_gen_5037) -> q_gen_5023
<nil, cons, cons>(q_gen_5080, q_gen_5037) -> q_gen_5023
<nil, nil, cons>(q_gen_5025, q_gen_5024) -> q_gen_5023
<a, b, a>() -> q_gen_5026
<b, b, b>() -> q_gen_5026
<cons, cons, cons>(q_gen_5026, q_gen_5050) -> q_gen_5050
<cons, nil, cons>(q_gen_5080, q_gen_5004) -> q_gen_5050
<nil, nil, cons>(q_gen_5051, q_gen_5024) -> q_gen_5050
<a, a, a>() -> q_gen_5052
<b, a, b>() -> q_gen_5052
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: left
}}}
  ;  insert -> 
{{{
Q={q_gen_4991, q_gen_4992, q_gen_4993, q_gen_4996, q_gen_4997, q_gen_5002, q_gen_5008, q_gen_5013, q_gen_5018, q_gen_5030},
Q_f={q_gen_4991},
Delta=
{
<nil>() -> q_gen_4992
<b>() -> q_gen_4993
<a>() -> q_gen_5008
<cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4996
<cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_4996
<nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4996
<a, b>() -> q_gen_4997
<b, b>() -> q_gen_4997
<a, a>() -> q_gen_5002
<b, a>() -> q_gen_5013
<cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5018
<cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_5018
<cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_5018
<nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_5018
<a, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<a, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<a, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<b, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_4991
<b, cons, cons>(q_gen_5002, q_gen_5018) -> q_gen_4991
<b, cons, cons>(q_gen_5013, q_gen_4996) -> q_gen_4991
<b, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_4991
<b, nil, cons>(q_gen_5008, q_gen_4992) -> q_gen_4991
<a, cons, cons>(q_gen_4997, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
<a, cons, cons>(q_gen_5002, q_gen_4996) -> q_gen_5030
<a, cons, cons>(q_gen_5013, q_gen_5018) -> q_gen_5030
<a, nil, cons>(q_gen_4993, q_gen_4992) -> q_gen_5030
<b, cons, cons>(q_gen_4997, q_gen_5018) -> q_gen_5030
}

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

Datatype: <elt, elt>
Convolution form: left
}}}
  ;  sort -> 
{{{
Q={q_gen_4988, q_gen_4999, q_gen_5031, q_gen_5032, q_gen_5053, q_gen_5054},
Q_f={q_gen_4988, q_gen_5053},
Delta=
{
<cons, cons>(q_gen_4999, q_gen_4988) -> q_gen_4988
<nil, nil>() -> q_gen_4988
<b, a>() -> q_gen_4999
<b, b>() -> q_gen_4999
<cons, cons>(q_gen_5032, q_gen_4988) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5032, q_gen_5053) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5031) -> q_gen_5031
<cons, cons>(q_gen_5054, q_gen_5053) -> q_gen_5031
<a, b>() -> q_gen_5032
<cons, cons>(q_gen_4999, q_gen_5031) -> q_gen_5053
<cons, cons>(q_gen_4999, q_gen_5053) -> q_gen_5053
<cons, cons>(q_gen_5054, q_gen_4988) -> q_gen_5053
<a, a>() -> q_gen_5054
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 56
() -> insert([x, nil, cons(x, nil)]) -> 56
() -> leq([a, y]) -> 56
() -> leq([b, b]) -> 56
() -> sort([nil, nil]) -> 56
(append([t1, l2, _jt])) -> append([cons(h1, t1), l2, cons(h1, _jt)]) -> 58
(append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]) -> 60
(insert([x, z, _zs]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _zs)]) -> 57
(insert([y, _et, _ft]) /\ sort([z, _et])) -> sort([cons(y, z), _ft]) -> 58
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 57
(leq([b, a])) -> BOT -> 57
}
Sat witness: Found: ((append([cons(a, nil), _pt, _qt]) /\ sort([l, _pt]) /\ sort([cons(a, l), _ot])) -> eq_eltlist([_ot, _qt]), {
_ot -> cons(a, cons(b, nil))  ;  _pt -> cons(a, nil)  ;  _qt -> cons(a, cons(a, cons(a, nil)))  ;  l -> cons(b, nil)
})

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