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


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, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)])
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))])}
(insert([_yi, _zi, _aj]) /\ insert([_yi, _zi, _bj])) -> eq_eltlist([_aj, _bj])
)
(sort, F:
{() -> sort([nil, nil])
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj])}
(sort([_ej, _fj]) /\ sort([_ej, _gj])) -> eq_eltlist([_fj, _gj])
)
(append, F:
{() -> append([nil, l2, l2])
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)])}
(append([_ij, _jj, _kj]) /\ append([_ij, _jj, _lj])) -> eq_eltlist([_kj, _lj])
)
}

properties:
{(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj])}


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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 0
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 0
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 0
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 0
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 0
(leq([b, a])) -> BOT -> 0
}


Solving took 60.000382 seconds.
DontKnow. Stopped because: timeout
Working model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2003, q_gen_2004, q_gen_2005, q_gen_2009, q_gen_2010, q_gen_2011, q_gen_2021, q_gen_2027, q_gen_2028, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2042, q_gen_2045, q_gen_2046, q_gen_2049, q_gen_2054, q_gen_2055, q_gen_2056, q_gen_2057, q_gen_2058, q_gen_2062, q_gen_2063, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2072, q_gen_2073, q_gen_2074, q_gen_2077, q_gen_2078, q_gen_2079, q_gen_2080, q_gen_2081, q_gen_2085, q_gen_2087, q_gen_2088, q_gen_2089, q_gen_2090, q_gen_2091, q_gen_2092, q_gen_2093, q_gen_2094, q_gen_2095, q_gen_2096, q_gen_2098, q_gen_2099, q_gen_2100, q_gen_2101, q_gen_2106, q_gen_2107, q_gen_2108, q_gen_2109, q_gen_2114, q_gen_2117, q_gen_2118, q_gen_2119, q_gen_2120, q_gen_2123, q_gen_2124, q_gen_2125, q_gen_2126, q_gen_2128, q_gen_2138, q_gen_2139, q_gen_2140, q_gen_2144, q_gen_2146, q_gen_2147, q_gen_2148, q_gen_2149, q_gen_2150},
Q_f={},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2010
<a, a>() -> q_gen_2011
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2057
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2080
<a, b>() -> q_gen_2081
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2090
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2124
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_2003
<nil, cons, cons>(q_gen_2011, q_gen_2010) -> q_gen_2009
<cons, nil, cons>(q_gen_2011, q_gen_2004) -> q_gen_2021
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2027
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_2028
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<b, b, b>() -> q_gen_2032
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, nil, cons>(q_gen_2011, q_gen_2041) -> q_gen_2042
<cons, cons, cons>(q_gen_2046, q_gen_2029) -> q_gen_2045
<a, b, a>() -> q_gen_2046
<cons, nil, cons>(q_gen_2005, q_gen_2010) -> q_gen_2049
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_2054
<cons, cons, cons>(q_gen_2032, q_gen_2056) -> q_gen_2055
<cons, nil, cons>(q_gen_2005, q_gen_2057) -> q_gen_2056
<cons, cons, cons>(q_gen_2046, q_gen_1994) -> q_gen_2058
<nil, cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2062
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_2063
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<b, a, b>() -> q_gen_2066
<cons, cons, cons>(q_gen_2073, q_gen_2064) -> q_gen_2072
<a, a, a>() -> q_gen_2073
<cons, cons, cons>(q_gen_2073, q_gen_2029) -> q_gen_2074
<nil, cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_2077
<cons, cons, cons>(q_gen_2046, q_gen_2079) -> q_gen_2078
<nil, cons, cons>(q_gen_2081, q_gen_2080) -> q_gen_2079
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2085
<cons, cons, cons>(q_gen_2066, q_gen_2085) -> q_gen_2087
<cons, cons, cons>(q_gen_2066, q_gen_2089) -> q_gen_2088
<cons, nil, cons>(q_gen_2005, q_gen_2090) -> q_gen_2089
<cons, cons, cons>(q_gen_2066, q_gen_2092) -> q_gen_2091
<nil, cons, cons>(q_gen_2081, q_gen_2090) -> q_gen_2092
<cons, cons, cons>(q_gen_2066, q_gen_2094) -> q_gen_2093
<cons, cons, cons>(q_gen_2066, q_gen_2095) -> q_gen_2094
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2095
<cons, cons, cons>(q_gen_2073, q_gen_1994) -> q_gen_2096
<nil, cons, cons>(q_gen_2011, q_gen_2080) -> q_gen_2098
<cons, cons, cons>(q_gen_2073, q_gen_2100) -> q_gen_2099
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2100
<cons, cons, cons>(q_gen_2066, q_gen_2107) -> q_gen_2106
<cons, nil, cons>(q_gen_2011, q_gen_2080) -> q_gen_2107
<cons, cons, cons>(q_gen_2046, q_gen_2109) -> q_gen_2108
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2109
<cons, cons, cons>(q_gen_2032, q_gen_2042) -> q_gen_2114
<cons, cons, cons>(q_gen_2046, q_gen_2074) -> q_gen_2117
<cons, cons, cons>(q_gen_2046, q_gen_2119) -> q_gen_2118
<cons, cons, cons>(q_gen_2073, q_gen_2042) -> q_gen_2119
<cons, cons, cons>(q_gen_2046, q_gen_2064) -> q_gen_2120
<nil, cons, cons>(q_gen_2005, q_gen_2124) -> q_gen_2123
<cons, cons, cons>(q_gen_2046, q_gen_2126) -> q_gen_2125
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2126
<cons, cons, cons>(q_gen_2073, q_gen_2109) -> q_gen_2128
<cons, cons, cons>(q_gen_2032, q_gen_2085) -> q_gen_2138
<cons, cons, cons>(q_gen_2032, q_gen_2089) -> q_gen_2139
<cons, cons, cons>(q_gen_2046, q_gen_2100) -> q_gen_2140
<cons, cons, cons>(q_gen_2073, q_gen_2098) -> q_gen_2144
<cons, cons, cons>(q_gen_2032, q_gen_2147) -> q_gen_2146
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2147
<cons, cons, cons>(q_gen_2046, q_gen_2149) -> q_gen_2148
<cons, cons, cons>(q_gen_2032, q_gen_2150) -> q_gen_2149
<cons, nil, cons>(q_gen_2005, q_gen_2080) -> q_gen_2150
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1995, q_gen_1996, q_gen_1997, q_gen_2001, q_gen_2002, q_gen_2007, q_gen_2008, q_gen_2012, q_gen_2013, q_gen_2014, q_gen_2017, q_gen_2018, q_gen_2019, q_gen_2020, q_gen_2022, q_gen_2023, q_gen_2024, q_gen_2025, q_gen_2033, q_gen_2038, q_gen_2039, q_gen_2044, q_gen_2047, q_gen_2050, q_gen_2051, q_gen_2052, q_gen_2060, q_gen_2067, q_gen_2068, q_gen_2069, q_gen_2070, q_gen_2082, q_gen_2083, q_gen_2084, q_gen_2102, q_gen_2110, q_gen_2111, q_gen_2115, q_gen_2121, q_gen_2127, q_gen_2129, q_gen_2130, q_gen_2131, q_gen_2141, q_gen_2143},
Q_f={},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2020
<cons, cons>(q_gen_2024, q_gen_2018) -> q_gen_2023
<a, b>() -> q_gen_2024
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2039
<cons, cons>(q_gen_2002, q_gen_2052) -> q_gen_2051
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2052
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2069
<cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2084
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2111
<cons, cons>(q_gen_2002, q_gen_2131) -> q_gen_2130
<cons, cons>(q_gen_2002, q_gen_2084) -> q_gen_2131
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1995
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2001
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2007
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2012
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2017
<b, cons, cons>(q_gen_2002, q_gen_2020) -> q_gen_2019
<b, cons, cons>(q_gen_1997, q_gen_2023) -> q_gen_2022
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2025
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2033
<b, cons, cons>(q_gen_2002, q_gen_2039) -> q_gen_2038
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2044
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2047
<a, cons, cons>(q_gen_2002, q_gen_2051) -> q_gen_2050
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2060
<a, cons, cons>(q_gen_2013, q_gen_2023) -> q_gen_2067
<b, cons, cons>(q_gen_2002, q_gen_2069) -> q_gen_2068
<a, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2070
<b, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2082
<b, cons, cons>(q_gen_2002, q_gen_2084) -> q_gen_2083
<b, cons, cons>(q_gen_1997, q_gen_2069) -> q_gen_2102
<b, cons, cons>(q_gen_1997, q_gen_2111) -> q_gen_2110
<a, cons, cons>(q_gen_2013, q_gen_2084) -> q_gen_2115
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2121
<a, cons, cons>(q_gen_2013, q_gen_2039) -> q_gen_2127
<a, cons, cons>(q_gen_2013, q_gen_2130) -> q_gen_2129
<a, cons, cons>(q_gen_2002, q_gen_2111) -> q_gen_2141
<a, cons, cons>(q_gen_2002, q_gen_2052) -> q_gen_2143
}

Datatype: <elt, eltlist, eltlist>
Convolution form: right
}}}
  ;  leq -> 
{{{
Q={q_gen_1989, q_gen_1990, q_gen_2000, q_gen_2006},
Q_f={},
Delta=
{
<b, b>() -> q_gen_1989
<a, b>() -> q_gen_1990
<b, a>() -> q_gen_2000
<a, a>() -> q_gen_2006
}

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2026, q_gen_2034, q_gen_2035, q_gen_2036, q_gen_2037, q_gen_2043, q_gen_2048, q_gen_2053, q_gen_2059, q_gen_2061, q_gen_2071, q_gen_2075, q_gen_2076, q_gen_2086, q_gen_2097, q_gen_2103, q_gen_2104, q_gen_2105, q_gen_2112, q_gen_2113, q_gen_2116, q_gen_2122, q_gen_2132, q_gen_2133, q_gen_2134, q_gen_2135, q_gen_2136, q_gen_2137, q_gen_2142, q_gen_2145},
Q_f={},
Delta=
{
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_2026
<cons, cons>(q_gen_2037, q_gen_2035) -> q_gen_2034
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2035
<b, a>() -> q_gen_2036
<a, a>() -> q_gen_2037
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_2043
<cons, cons>(q_gen_2036, q_gen_1998) -> q_gen_2048
<cons, cons>(q_gen_2036, q_gen_2043) -> q_gen_2053
<cons, cons>(q_gen_2037, q_gen_1998) -> q_gen_2059
<cons, cons>(q_gen_2016, q_gen_2035) -> q_gen_2061
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2071
<cons, cons>(q_gen_2037, q_gen_2043) -> q_gen_2075
<cons, cons>(q_gen_1999, q_gen_1998) -> q_gen_2076
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2086
<cons, cons>(q_gen_2016, q_gen_2043) -> q_gen_2097
<cons, cons>(q_gen_1999, q_gen_2043) -> q_gen_2103
<cons, cons>(q_gen_1999, q_gen_2105) -> q_gen_2104
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_2105
<cons, cons>(q_gen_1999, q_gen_2113) -> q_gen_2112
<cons, cons>(q_gen_1999, q_gen_2035) -> q_gen_2113
<cons, cons>(q_gen_2037, q_gen_2086) -> q_gen_2116
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2122
<cons, cons>(q_gen_1999, q_gen_2133) -> q_gen_2132
<cons, cons>(q_gen_2037, q_gen_2134) -> q_gen_2133
<cons, cons>(q_gen_2036, q_gen_2035) -> q_gen_2134
<cons, cons>(q_gen_2037, q_gen_2136) -> q_gen_2135
<cons, cons>(q_gen_2036, q_gen_2137) -> q_gen_2136
<cons, cons>(q_gen_2037, q_gen_2076) -> q_gen_2137
<cons, cons>(q_gen_2037, q_gen_2061) -> q_gen_2142
<cons, cons>(q_gen_2036, q_gen_2076) -> q_gen_2145
}

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

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

-------------------
STEPS:
-------------------------------------------
Step 0, which took 0.006139 s (model generation: 0.005082,  model checking: 0.001057):

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

}

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

}

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

}

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

}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 1
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 1
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 1
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.004740 s (model generation: 0.004654,  model checking: 0.000086):

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

}

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

}

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

}

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

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 1
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 1
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 1
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.004764 s (model generation: 0.004645,  model checking: 0.000119):

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

}

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

}

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

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

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 1
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 1
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 1
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.005283 s (model generation: 0.004837,  model checking: 0.000446):

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

}

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

}

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

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

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 1
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 1
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 1
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.005333 s (model generation: 0.004906,  model checking: 0.000427):

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

}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

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

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 1
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 1
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 1
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.007404 s (model generation: 0.005603,  model checking: 0.001801):

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

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

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

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 1
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 1
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 1
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.005181 s (model generation: 0.005024,  model checking: 0.000157):

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

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

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

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 1
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 1
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 1
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> nil  ;  _dj -> cons(b, nil)  ;  y -> b  ;  z -> nil
})

-------------------------------------------
Step 7, which took 0.005837 s (model generation: 0.005573,  model checking: 0.000264):

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

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 1
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 1
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 4
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]), {
_xi -> cons(b, nil)  ;  x -> b  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 8, which took 0.006578 s (model generation: 0.006272,  model checking: 0.000306):

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

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 4
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 2
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 4
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> nil  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 9, which took 0.005115 s (model generation: 0.005075,  model checking: 0.000040):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 4
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 2
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 4
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.006266 s (model generation: 0.005123,  model checking: 0.001143):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 4
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 3
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 4
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.005220 s (model generation: 0.004759,  model checking: 0.000461):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 4
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 4
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 4
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.006239 s (model generation: 0.005506,  model checking: 0.000733):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<a>() -> q_gen_1993
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 4
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 4
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 4
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.006043 s (model generation: 0.005566,  model checking: 0.000477):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<a>() -> q_gen_1993
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 4
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 4
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 4
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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.006226 s (model generation: 0.005959,  model checking: 0.000267):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<a>() -> q_gen_1993
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 4
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 4
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 4
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> nil  ;  _dj -> cons(b, nil)  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 15, which took 0.007870 s (model generation: 0.006550,  model checking: 0.001320):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<a>() -> q_gen_1993
<b>() -> q_gen_1993
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, b>() -> q_gen_1999
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 4
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 4
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 7
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]), {
_xi -> cons(a, cons(a, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 16, which took 0.007164 s (model generation: 0.006375,  model checking: 0.000789):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<a>() -> q_gen_1993
<b>() -> q_gen_1993
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, b>() -> q_gen_1999
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 4
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 7
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 7
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 7
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 7
(leq([b, a])) -> BOT -> 5
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(b, nil)  ;  _nj -> nil  ;  _oj -> cons(a, nil)  ;  l -> nil
})

-------------------------------------------
Step 17, which took 0.007248 s (model generation: 0.007081,  model checking: 0.000167):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2011, q_gen_2021},
Q_f={q_gen_1994},
Delta=
{
<cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<a, a>() -> q_gen_2011
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2011, q_gen_2004) -> q_gen_2021
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<a>() -> q_gen_1993
<b>() -> q_gen_1993
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, b>() -> q_gen_1999
<b, b>() -> q_gen_1999
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 7
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 7
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 7
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> nil  ;  h1 -> a  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 18, which took 0.008325 s (model generation: 0.007029,  model checking: 0.001296):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 7
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 7
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 7
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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 19, which took 0.007290 s (model generation: 0.007054,  model checking: 0.000236):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<a, b>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 7
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 7
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 7
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, nil)  ;  _dj -> cons(b, cons(b, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 20, which took 0.009445 s (model generation: 0.008287,  model checking: 0.001158):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005},
Q_f={q_gen_1994},
Delta=
{
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<a, b>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_1998
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 10
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 8
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 8
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, nil)  ;  h1 -> b  ;  l2 -> cons(b, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 21, which took 0.011637 s (model generation: 0.008673,  model checking: 0.002964):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2030, q_gen_2031, q_gen_2032},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<a, b>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_1998
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 10
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 9
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 9
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, nil)  ;  _dj -> cons(a, cons(a, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 22, which took 0.011254 s (model generation: 0.009979,  model checking: 0.001275):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2030, q_gen_2031, q_gen_2032},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2002
<b, a>() -> q_gen_2002
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 10
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 9
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 12
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 13
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 11
(leq([b, a])) -> BOT -> 10
}
Sat witness: Found: ((insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]), {
_xi -> cons(b, cons(b, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 23, which took 0.011010 s (model generation: 0.009818,  model checking: 0.001192):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2030, q_gen_2031, q_gen_2032},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2002
<b, a>() -> q_gen_2002
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 13
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 10
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 12
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 13
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 11
(leq([b, a])) -> BOT -> 11
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, nil)  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 24, which took 0.010677 s (model generation: 0.010192,  model checking: 0.000485):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2030, q_gen_2031, q_gen_2032},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2002
<b, a>() -> q_gen_2002
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 13
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 13
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 12
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 13
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 11
(leq([b, a])) -> BOT -> 11
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, nil)  ;  _nj -> nil  ;  _oj -> cons(a, cons(b, nil))  ;  l -> nil
})

-------------------------------------------
Step 25, which took 0.012820 s (model generation: 0.011780,  model checking: 0.001040):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2030, q_gen_2031, q_gen_2032},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2013, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, a>() -> q_gen_2016
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 13
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 13
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 12
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 13
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 14
(leq([b, a])) -> BOT -> 12
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 26, which took 0.013387 s (model generation: 0.011719,  model checking: 0.001668):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2030, q_gen_2031, q_gen_2032},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2002
<b, a>() -> q_gen_2002
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, a>() -> q_gen_2016
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 13
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 13
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 13
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 16
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 14
(leq([b, a])) -> BOT -> 13
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> nil  ;  _dj -> cons(a, nil)  ;  y -> a  ;  z -> nil
})

-------------------------------------------
Step 27, which took 0.014097 s (model generation: 0.011074,  model checking: 0.003023):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<a, b>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1998
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_1998
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 16
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 14
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 14
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 16
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 14
(leq([b, a])) -> BOT -> 14
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, nil)  ;  h1 -> a  ;  l2 -> cons(b, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 28, which took 0.013976 s (model generation: 0.011314,  model checking: 0.002662):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<a, b>() -> q_gen_1997
<b, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1998
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_1998
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 16
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 17
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 15
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 16
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 15
(leq([b, a])) -> BOT -> 15
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(b, cons(b, nil))  ;  _nj -> cons(b, nil)  ;  _oj -> cons(a, cons(b, nil))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 29, which took 0.012159 s (model generation: 0.011293,  model checking: 0.000866):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2010, q_gen_2027, q_gen_2030, q_gen_2031, q_gen_2032},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2010
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2010
<cons, cons, cons>(q_gen_2032, q_gen_2027) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2010) -> q_gen_2027
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2027
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2027
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2002
<b, a>() -> q_gen_2002
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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)]) -> 15
() -> leq([a, y]) -> 15
() -> leq([b, b]) -> 15
() -> sort([nil, nil]) -> 15
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 16
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 17
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 15
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 16
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 15
(leq([b, a])) -> BOT -> 15
}
Sat witness: Found: (() -> append([nil, l2, l2]), {
l2 -> cons(b, nil)
})

-------------------------------------------
Step 30, which took 0.013293 s (model generation: 0.010615,  model checking: 0.002678):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2010, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2010
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2010
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2010) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2002
<b, a>() -> q_gen_2002
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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)]) -> 16
() -> leq([a, y]) -> 16
() -> leq([b, b]) -> 16
() -> sort([nil, nil]) -> 16
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 16
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 17
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 16
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 16
(leq([b, a])) -> BOT -> 16
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, nil)  ;  _dj -> cons(a, cons(b, nil))  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 31, which took 0.013860 s (model generation: 0.012009,  model checking: 0.001851):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2010, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2010
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2010
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2010) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2002
<b, a>() -> q_gen_2002
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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)]) -> 16
() -> leq([a, y]) -> 16
() -> leq([b, b]) -> 16
() -> sort([nil, nil]) -> 16
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 19
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 17
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 17
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 17
(leq([b, a])) -> BOT -> 17
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(a, nil)  ;  h1 -> b  ;  l2 -> nil  ;  t1 -> cons(a, nil)
})

-------------------------------------------
Step 32, which took 0.014472 s (model generation: 0.012514,  model checking: 0.001958):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2014},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2002
<b, a>() -> q_gen_2002
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 19
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 20
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 18
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 18
(leq([b, a])) -> BOT -> 18
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(a, nil))  ;  _nj -> cons(b, nil)  ;  _oj -> cons(a, cons(b, nil))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 33, which took 0.013479 s (model generation: 0.012016,  model checking: 0.001463):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 19
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 20
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 18
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 19
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 21
(leq([b, a])) -> BOT -> 19
}
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 34, which took 0.016822 s (model generation: 0.012588,  model checking: 0.004234):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 19
() -> insert([x, nil, cons(x, nil)]) -> 19
() -> leq([a, y]) -> 19
() -> leq([b, b]) -> 19
() -> sort([nil, nil]) -> 19
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 19
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 20
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 19
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 21
(leq([b, a])) -> BOT -> 20
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(a, nil)  ;  _dj -> cons(a, cons(a, nil))  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 35, which took 0.018844 s (model generation: 0.013484,  model checking: 0.005360):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 19
() -> insert([x, nil, cons(x, nil)]) -> 19
() -> leq([a, y]) -> 19
() -> leq([b, b]) -> 19
() -> sort([nil, nil]) -> 19
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 22
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 20
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 20
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 21
(leq([b, a])) -> BOT -> 20
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, cons(b, cons(b, nil)))  ;  h1 -> b  ;  l2 -> cons(b, nil)  ;  t1 -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 36, which took 0.019146 s (model generation: 0.014616,  model checking: 0.004530):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 20
() -> insert([x, nil, cons(x, nil)]) -> 20
() -> leq([a, y]) -> 20
() -> leq([b, b]) -> 20
() -> sort([nil, nil]) -> 20
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 22
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 23
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 21
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 22
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 21
(leq([b, a])) -> BOT -> 21
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(b, nil))  ;  _nj -> cons(b, nil)  ;  _oj -> cons(a, nil)  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 37, which took 0.028232 s (model generation: 0.015237,  model checking: 0.012995):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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)]) -> 21
() -> leq([a, y]) -> 21
() -> leq([b, b]) -> 21
() -> sort([nil, nil]) -> 21
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 22
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 23
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 22
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 22
(leq([b, a])) -> BOT -> 22
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, nil)  ;  _dj -> cons(b, cons(a, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 38, which took 0.029553 s (model generation: 0.020198,  model checking: 0.009355):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 25
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 23
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 23
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 23
(leq([b, a])) -> BOT -> 23
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(a, nil)  ;  h1 -> b  ;  l2 -> cons(a, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 39, which took 0.044191 s (model generation: 0.026228,  model checking: 0.017963):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, a>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 25
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 26
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 24
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 24
(leq([b, a])) -> BOT -> 24
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(b, cons(a, nil))  ;  _nj -> cons(b, nil)  ;  _oj -> cons(a, cons(b, nil))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 40, which took 0.038840 s (model generation: 0.037522,  model checking: 0.001318):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 25
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 26
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 24
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 27
(leq([b, a])) -> BOT -> 25
}
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 41, which took 0.021145 s (model generation: 0.020209,  model checking: 0.000936):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 25
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 26
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 27
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 25
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 27
(leq([b, a])) -> BOT -> 25
}
Sat witness: Found: ((insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]), {
_xi -> cons(a, cons(b, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 42, which took 0.023606 s (model generation: 0.021762,  model checking: 0.001844):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 25
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 26
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 27
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 27
(leq([b, a])) -> BOT -> 26
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(a, nil)  ;  _dj -> cons(b, cons(b, nil))  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 43, which took 0.025523 s (model generation: 0.022576,  model checking: 0.002947):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 28
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 26
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 27
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(a, nil)  ;  h1 -> a  ;  l2 -> cons(a, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 44, which took 0.023914 s (model generation: 0.022797,  model checking: 0.001117):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 28
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 29
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 27
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 28
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 27
(leq([b, a])) -> BOT -> 27
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(a, nil))  ;  _nj -> cons(a, nil)  ;  _oj -> cons(a, cons(b, nil))  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 45, which took 0.057186 s (model generation: 0.025604,  model checking: 0.031582):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<a, a>() -> q_gen_1999
<b, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_1998) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_2015
<a, b>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 28
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 29
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 28
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 28
(leq([b, a])) -> BOT -> 28
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, nil)  ;  _dj -> cons(b, cons(b, nil))  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 46, which took 0.062078 s (model generation: 0.031723,  model checking: 0.030355):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037, q_gen_2043},
Q_f={q_gen_1988, q_gen_2043},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2043) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2043) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_2043
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 28
() -> insert([x, nil, cons(x, nil)]) -> 28
() -> leq([a, y]) -> 28
() -> leq([b, b]) -> 28
() -> sort([nil, nil]) -> 28
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 31
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 29
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 29
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 29
(leq([b, a])) -> BOT -> 29
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, cons(a, nil))  ;  h1 -> a  ;  l2 -> cons(b, cons(a, nil))  ;  t1 -> nil
})

-------------------------------------------
Step 47, which took 0.037920 s (model generation: 0.034844,  model checking: 0.003076):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<a, b>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2035, q_gen_2036},
Q_f={q_gen_1988, q_gen_2035},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2035) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_2035) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2035
<a, a>() -> q_gen_2036
<b, a>() -> q_gen_2036
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 29
() -> insert([x, nil, cons(x, nil)]) -> 29
() -> leq([a, y]) -> 29
() -> leq([b, b]) -> 29
() -> sort([nil, nil]) -> 29
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 31
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 29
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 32
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 30
(leq([b, a])) -> BOT -> 30
}
Sat witness: Found: ((insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]), {
_xi -> cons(b, cons(b, nil))  ;  x -> b  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 48, which took 0.039143 s (model generation: 0.038896,  model checking: 0.000247):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2065, q_gen_2066},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<a, b>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 29
() -> insert([x, nil, cons(x, nil)]) -> 29
() -> leq([a, y]) -> 29
() -> leq([b, b]) -> 29
() -> sort([nil, nil]) -> 29
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 31
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 32
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 32
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 31
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 30
(leq([b, a])) -> BOT -> 30
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, nil)  ;  _nj -> nil  ;  _oj -> cons(b, nil)  ;  l -> nil
})

-------------------------------------------
Step 49, which took 0.042327 s (model generation: 0.039268,  model checking: 0.003059):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2065, q_gen_2066, q_gen_2081},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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)]) -> 30
() -> leq([a, y]) -> 30
() -> leq([b, b]) -> 30
() -> sort([nil, nil]) -> 30
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 31
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 32
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 32
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 34
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 31
(leq([b, a])) -> BOT -> 31
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(a, nil)  ;  _dj -> cons(b, cons(b, nil))  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 50, which took 0.051394 s (model generation: 0.039072,  model checking: 0.012322):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2081},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037, q_gen_2043},
Q_f={q_gen_1988, q_gen_2043},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2043) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2043) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2043
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_2043
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 34
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 32
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 32
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 34
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 32
(leq([b, a])) -> BOT -> 32
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, cons(b, nil))  ;  h1 -> b  ;  l2 -> cons(a, nil)  ;  t1 -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 51, which took 0.096880 s (model generation: 0.060826,  model checking: 0.036054):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2081},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2013
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1998) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_1998
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1998
<b, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_1998) -> q_gen_2015
<a, b>() -> q_gen_2016
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 34
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 35
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 33
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 34
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 33
(leq([b, a])) -> BOT -> 33
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(b, cons(b, nil))  ;  _nj -> cons(a, nil)  ;  _oj -> cons(a, cons(a, nil))  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 52, which took 0.070401 s (model generation: 0.061777,  model checking: 0.008624):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2081},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1998) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1998
<b, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_1998) -> q_gen_2015
<a, b>() -> q_gen_2016
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 34
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 35
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 34
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 37
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 34
(leq([b, a])) -> BOT -> 34
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, nil)  ;  _dj -> cons(a, cons(b, nil))  ;  y -> a  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 53, which took 0.059399 s (model generation: 0.049494,  model checking: 0.009905):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2081},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037, q_gen_2043},
Q_f={q_gen_1988, q_gen_2043},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2043) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2043) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_2043
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 34
() -> insert([x, nil, cons(x, nil)]) -> 34
() -> leq([a, y]) -> 34
() -> leq([b, b]) -> 34
() -> sort([nil, nil]) -> 34
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 37
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 35
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 35
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, cons(b, cons(b, nil)))  ;  h1 -> b  ;  l2 -> cons(a, cons(a, cons(a, nil)))  ;  t1 -> cons(b, nil)
})

-------------------------------------------
Step 54, which took 0.091428 s (model generation: 0.082348,  model checking: 0.009080):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2046, q_gen_2081},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2046, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2046, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<a, b, a>() -> q_gen_2046
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037, q_gen_2043},
Q_f={q_gen_1988, q_gen_2043},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2043) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
<cons, cons>(q_gen_2016, q_gen_2043) -> q_gen_2043
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_2043
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 35
() -> insert([x, nil, cons(x, nil)]) -> 35
() -> leq([a, y]) -> 35
() -> leq([b, b]) -> 35
() -> sort([nil, nil]) -> 35
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 37
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 38
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 36
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(b, cons(a, nil))  ;  _nj -> cons(a, nil)  ;  _oj -> cons(a, nil)  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 55, which took 0.125905 s (model generation: 0.118437,  model checking: 0.007468):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2003, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2081},
Q_f={q_gen_1994, q_gen_2003},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2003) -> q_gen_2003
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_2003
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2003
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, a, a>() -> q_gen_2032
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2035, q_gen_2036},
Q_f={q_gen_1988, q_gen_2035},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2035) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_2035) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2035
<a, a>() -> q_gen_2036
<b, a>() -> q_gen_2036
}

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

}
--
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)]) -> 36
() -> leq([a, y]) -> 36
() -> leq([b, b]) -> 36
() -> sort([nil, nil]) -> 36
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 37
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 38
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 37
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(a, nil)  ;  _dj -> cons(a, cons(a, nil))  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 56, which took 0.833527 s (model generation: 0.120390,  model checking: 0.713137):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2065, q_gen_2066, q_gen_2081},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 40
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 38
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 38
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(a, cons(a, nil))  ;  h1 -> a  ;  l2 -> cons(a, nil)  ;  t1 -> nil
})

-------------------------------------------
Step 57, which took 0.128602 s (model generation: 0.121096,  model checking: 0.007506):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2065, q_gen_2066, q_gen_2081},
Q_f={q_gen_1994},
Delta=
{
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2030
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 40
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 41
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 39
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(a, nil))  ;  _nj -> cons(a, nil)  ;  _oj -> cons(a, nil)  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 58, which took 0.147038 s (model generation: 0.135014,  model checking: 0.012024):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2003, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2065, q_gen_2073, q_gen_2081},
Q_f={q_gen_1994, q_gen_2003},
Delta=
{
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2030
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2073, q_gen_2003) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2003) -> q_gen_2003
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_2003
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2003
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2003
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<a, a, a>() -> q_gen_2073
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018, q_gen_2024},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, b>() -> q_gen_2024
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
<b, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 40
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 41
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 40
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, cons(a, nil))  ;  _dj -> cons(b, cons(a, cons(b, nil)))  ;  y -> b  ;  z -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 59, which took 0.164874 s (model generation: 0.155146,  model checking: 0.009728):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2073, q_gen_2081},
Q_f={q_gen_1994, q_gen_2064},
Delta=
{
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2030
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2073, q_gen_2064) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2073
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 43
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 41
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 41
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(a, cons(a, nil))  ;  h1 -> b  ;  l2 -> cons(a, nil)  ;  t1 -> cons(a, nil)
})

-------------------------------------------
Step 60, which took 0.148024 s (model generation: 0.147335,  model checking: 0.000689):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2010, q_gen_2011, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2073, q_gen_2081},
Q_f={q_gen_1994},
Delta=
{
<cons>(q_gen_2031, q_gen_2030) -> q_gen_2030
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2010
<a, a>() -> q_gen_2011
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2010) -> q_gen_1994
<cons, nil, cons>(q_gen_2011, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2011, q_gen_2010) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2011, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_2029
<nil, cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2011, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<a, a, a>() -> q_gen_2073
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
}

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

}
--
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)]) -> 41
() -> leq([a, y]) -> 41
() -> leq([b, b]) -> 41
() -> sort([nil, nil]) -> 41
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 43
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 41
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 41
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 43
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 41
(leq([b, a])) -> BOT -> 41
}
Sat witness: Found: (() -> append([nil, l2, l2]), {
l2 -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 61, which took 0.157547 s (model generation: 0.149241,  model checking: 0.008306):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2003, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2065, q_gen_2073, q_gen_2081},
Q_f={q_gen_1994, q_gen_2003},
Delta=
{
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2030
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2003) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_2003
<cons, cons, cons>(q_gen_2073, q_gen_2003) -> q_gen_2003
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_2003
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2003
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2003
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<a, a, a>() -> q_gen_2073
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
}

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

}
--
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)]) -> 41
() -> leq([a, y]) -> 41
() -> leq([b, b]) -> 41
() -> sort([nil, nil]) -> 41
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 43
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 44
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 42
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(b, nil))  ;  _nj -> cons(b, nil)  ;  _oj -> cons(a, cons(b, cons(a, nil)))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 62, which took 0.166134 s (model generation: 0.156615,  model checking: 0.009519):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2010, q_gen_2011, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994, q_gen_2040},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons>(q_gen_2031, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_2010
<cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2010
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2010
<a, a>() -> q_gen_2011
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<cons, nil, cons>(q_gen_2011, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2011, q_gen_2010) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_2029
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2011, q_gen_2010) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2010) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, nil, cons>(q_gen_2005, q_gen_2010) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_2040
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2040
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2016
<a, a>() -> q_gen_2037
}

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

}
--
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)]) -> 42
() -> leq([a, y]) -> 42
() -> leq([b, b]) -> 42
() -> sort([nil, nil]) -> 42
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 43
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 44
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 43
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(a, nil)  ;  _dj -> cons(a, cons(b, nil))  ;  y -> b  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 63, which took 0.185721 s (model generation: 0.173376,  model checking: 0.012345):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2003, q_gen_2004, q_gen_2005, q_gen_2010, q_gen_2011, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2042, q_gen_2073, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994, q_gen_2003},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons>(q_gen_2031, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_2010
<cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2010
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2010
<a, a>() -> q_gen_2011
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2073, q_gen_2042) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2010) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2003) -> q_gen_2003
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_2003
<cons, nil, cons>(q_gen_2011, q_gen_2004) -> q_gen_2003
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2003
<nil, cons, cons>(q_gen_2011, q_gen_2010) -> q_gen_2003
<nil, cons, cons>(q_gen_2081, q_gen_2010) -> q_gen_2003
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2003
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2042
<cons, cons, cons>(q_gen_2032, q_gen_2042) -> q_gen_2042
<cons, cons, cons>(q_gen_2073, q_gen_1994) -> q_gen_2042
<cons, cons, cons>(q_gen_2073, q_gen_2003) -> q_gen_2042
<cons, nil, cons>(q_gen_2011, q_gen_2010) -> q_gen_2042
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2042
<nil, cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2042
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2042
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2042
<a, a, a>() -> q_gen_2073
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 46
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 44
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 44
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(a, nil)  ;  h1 -> a  ;  l2 -> nil  ;  t1 -> nil
})

-------------------------------------------
Step 64, which took 0.220779 s (model generation: 0.213679,  model checking: 0.007100):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2003, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2065, q_gen_2073, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994, q_gen_2003},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2004
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2073, q_gen_2003) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2003) -> q_gen_2003
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_2003
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2003
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2003
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2003
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2073, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<a, a, a>() -> q_gen_2073
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 46
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 47
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 45
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, nil)  ;  _nj -> nil  ;  _oj -> cons(a, cons(a, nil))  ;  l -> nil
})

-------------------------------------------
Step 65, which took 0.152870 s (model generation: 0.152170,  model checking: 0.000700):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2010, q_gen_2011, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2054, q_gen_2073, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<a>() -> q_gen_2031
<b>() -> q_gen_2031
<cons>(q_gen_2031, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_2010
<cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2010
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2010
<a, a>() -> q_gen_2011
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2073, q_gen_2054) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2010) -> q_gen_1994
<cons, nil, cons>(q_gen_2011, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2010) -> q_gen_1994
<nil, cons, cons>(q_gen_2011, q_gen_2010) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2011, q_gen_2010) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2010) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2054
<cons, cons, cons>(q_gen_2032, q_gen_2054) -> q_gen_2054
<cons, cons, cons>(q_gen_2073, q_gen_1994) -> q_gen_2054
<cons, cons, cons>(q_gen_2073, q_gen_2029) -> q_gen_2054
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2054
<nil, cons, cons>(q_gen_2011, q_gen_2004) -> q_gen_2054
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2054
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2054
<a, a, a>() -> q_gen_2073
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2035, q_gen_2036},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2035) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2035) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2035
<b, a>() -> q_gen_2036
}

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

}
--
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)]) -> 45
() -> leq([a, y]) -> 45
() -> leq([b, b]) -> 45
() -> sort([nil, nil]) -> 45
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 46
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 47
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 45
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 46
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 45
(leq([b, a])) -> BOT -> 45
}
Sat witness: Found: (() -> append([nil, l2, l2]), {
l2 -> cons(a, nil)
})

-------------------------------------------
Step 66, which took 0.148887 s (model generation: 0.136015,  model checking: 0.012872):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_2040
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2040
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2040
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2034, q_gen_2036},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2034) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_1999, q_gen_2034) -> q_gen_2034
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2034
<b, a>() -> q_gen_2036
}

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

}
--
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)]) -> 46
() -> leq([a, y]) -> 46
() -> leq([b, b]) -> 46
() -> sort([nil, nil]) -> 46
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 46
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 47
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 46
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 46
(leq([b, a])) -> BOT -> 46
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, cons(b, nil))  ;  _dj -> cons(b, cons(b, cons(a, nil)))  ;  y -> b  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 67, which took 0.434668 s (model generation: 0.182664,  model checking: 0.252004):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_2040
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2040
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2040
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018, q_gen_2024},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, b>() -> q_gen_2024
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
<b, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
}

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

}
--
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)]) -> 46
() -> leq([a, y]) -> 46
() -> leq([b, b]) -> 46
() -> sort([nil, nil]) -> 46
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 49
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 47
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 47
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 47
(leq([b, a])) -> BOT -> 47
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(a, cons(b, nil))  ;  h1 -> b  ;  l2 -> cons(b, nil)  ;  t1 -> cons(a, nil)
})

-------------------------------------------
Step 68, which took 0.399710 s (model generation: 0.133025,  model checking: 0.266685):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2040
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2040
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018, q_gen_2024},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, b>() -> q_gen_2024
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
<b, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 49
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 50
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 48
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 49
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 48
(leq([b, a])) -> BOT -> 48
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(a, nil))  ;  _nj -> cons(a, nil)  ;  _oj -> cons(a, cons(a, cons(a, nil)))  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 69, which took 0.208502 s (model generation: 0.144245,  model checking: 0.064257):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2040
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2040
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018, q_gen_2024},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, b>() -> q_gen_2024
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
<b, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 49
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 50
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 49
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 52
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 49
(leq([b, a])) -> BOT -> 49
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, cons(a, nil))  ;  _dj -> cons(a, cons(b, cons(b, nil)))  ;  y -> a  ;  z -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 70, which took 0.215095 s (model generation: 0.203347,  model checking: 0.011748):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2040
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 52
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 50
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 50
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(a, cons(a, cons(b, nil)))  ;  h1 -> a  ;  l2 -> cons(b, cons(a, nil))  ;  t1 -> cons(a, cons(a, nil))
})

-------------------------------------------
Step 71, which took 0.204909 s (model generation: 0.153933,  model checking: 0.050976):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2058, q_gen_2065, q_gen_2073, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2073, q_gen_2040) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, a, b>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2032, q_gen_2058) -> q_gen_2058
<cons, cons, cons>(q_gen_2073, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2073, q_gen_2029) -> q_gen_2058
<cons, cons, cons>(q_gen_2073, q_gen_2058) -> q_gen_2058
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2058
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2058
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2058
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2058
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2058
<a, a, a>() -> q_gen_2073
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 52
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 53
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 51
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 52
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 51
(leq([b, a])) -> BOT -> 51
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(b, nil))  ;  _nj -> cons(b, nil)  ;  _oj -> cons(a, cons(a, nil))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 72, which took 0.246489 s (model generation: 0.228239,  model checking: 0.018250):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2064
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2064
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 52
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 53
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 52
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 55
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 52
(leq([b, a])) -> BOT -> 52
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(a, nil)  ;  _dj -> cons(a, cons(b, nil))  ;  y -> a  ;  z -> cons(a, nil)
})

-------------------------------------------
Step 73, which took 0.499949 s (model generation: 0.234249,  model checking: 0.265700):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2058, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2058) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2032, q_gen_2058) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2058
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2058
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2058
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2058
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018, q_gen_2024},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, b>() -> q_gen_2024
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
<b, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 55
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 53
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 53
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, cons(b, nil))  ;  h1 -> a  ;  l2 -> cons(b, cons(b, nil))  ;  t1 -> nil
})

-------------------------------------------
Step 74, which took 0.202014 s (model generation: 0.200817,  model checking: 0.001197):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2058, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2058) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2032, q_gen_2058) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2058
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2058
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2058
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2035, q_gen_2036},
Q_f={q_gen_1988, q_gen_2035},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2035) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2035) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2035
<b, a>() -> q_gen_2036
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 55
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 53
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 53
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 55
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 56
(leq([b, a])) -> BOT -> 54
}
Sat witness: Found: ((leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]), {
x -> a  ;  y -> b  ;  z -> cons(b, nil)
})

-------------------------------------------
Step 75, which took 0.296761 s (model generation: 0.213506,  model checking: 0.083255):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2064
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 55
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 56
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 54
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 55
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 56
(leq([b, a])) -> BOT -> 54
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(a, nil))  ;  _nj -> cons(a, nil)  ;  _oj -> cons(a, cons(b, cons(a, nil)))  ;  l -> cons(a, nil)
})

-------------------------------------------
Step 76, which took 0.319987 s (model generation: 0.284479,  model checking: 0.035508):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036, q_gen_2037},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2037, q_gen_1988) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2037, q_gen_2015) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
<a, a>() -> q_gen_2037
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 55
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 56
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 55
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 58
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 56
(leq([b, a])) -> BOT -> 55
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(b, cons(a, cons(a, cons(a, nil))))  ;  _dj -> cons(a, cons(a, cons(a, cons(b, cons(b, nil)))))  ;  y -> a  ;  z -> cons(b, cons(a, cons(b, cons(b, nil))))
})

-------------------------------------------
Step 77, which took 0.533095 s (model generation: 0.262545,  model checking: 0.270550):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2058, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2058) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2032, q_gen_2058) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2058
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2058
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018, q_gen_2024},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, b>() -> q_gen_2024
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
<b, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 58
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 56
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 56
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, cons(b, nil))  ;  h1 -> b  ;  l2 -> cons(b, nil)  ;  t1 -> cons(b, cons(a, nil))
})

-------------------------------------------
Step 78, which took 0.505997 s (model generation: 0.240106,  model checking: 0.265891):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018, q_gen_2024},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, b>() -> q_gen_2024
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
<b, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
}

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

}
--
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, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 58
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 59
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 57
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 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), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(b, nil))  ;  _nj -> cons(b, nil)  ;  _oj -> cons(a, cons(a, cons(a, nil)))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 79, which took 0.507998 s (model generation: 0.243062,  model checking: 0.264936):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018, q_gen_2024},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2024, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, b>() -> q_gen_2024
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
<b, cons, cons>(q_gen_2024, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2036},
Q_f={q_gen_1988},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2015
<a, b>() -> q_gen_2016
<b, a>() -> q_gen_2036
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 57
() -> insert([x, nil, cons(x, nil)]) -> 57
() -> leq([a, y]) -> 57
() -> leq([b, b]) -> 57
() -> sort([nil, nil]) -> 57
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 58
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 59
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 58
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 61
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 58
(leq([b, a])) -> BOT -> 58
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(a, cons(b, nil))  ;  _dj -> cons(a, cons(b, cons(a, nil)))  ;  y -> a  ;  z -> cons(a, cons(b, nil))
})

-------------------------------------------
Step 80, which took 0.230316 s (model generation: 0.229055,  model checking: 0.001261):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2058, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2058) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2032, q_gen_2058) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2058
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2058
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<a, b>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2035, q_gen_2036},
Q_f={q_gen_1988, q_gen_2035},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2035) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2035) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2035
<cons, cons>(q_gen_2036, q_gen_2035) -> q_gen_2035
<b, a>() -> q_gen_2036
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 58
() -> insert([x, nil, cons(x, nil)]) -> 58
() -> leq([a, y]) -> 58
() -> leq([b, b]) -> 58
() -> sort([nil, nil]) -> 58
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 58
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 59
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 58
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 61
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 61
(leq([b, a])) -> BOT -> 59
}
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 81, which took 0.289378 s (model generation: 0.280782,  model checking: 0.008596):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2035, q_gen_2036},
Q_f={q_gen_1988, q_gen_2035},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2035) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2035) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2035) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2035
<b, a>() -> q_gen_2036
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 58
() -> insert([x, nil, cons(x, nil)]) -> 58
() -> leq([a, y]) -> 58
() -> leq([b, b]) -> 58
() -> sort([nil, nil]) -> 58
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 61
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 59
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 59
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 61
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 61
(leq([b, a])) -> BOT -> 59
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(a, cons(a, nil))  ;  h1 -> a  ;  l2 -> cons(a, cons(a, nil))  ;  t1 -> nil
})

-------------------------------------------
Step 82, which took 0.353887 s (model generation: 0.342855,  model checking: 0.011032):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2080, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2080
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2029
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2029
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2080) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2064
<cons, nil, cons>(q_gen_2005, q_gen_2080) -> q_gen_2064
<nil, cons, cons>(q_gen_2005, q_gen_2080) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2035, q_gen_2036},
Q_f={q_gen_1988, q_gen_2035},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2035) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2035) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2035
<cons, cons>(q_gen_2036, q_gen_2035) -> q_gen_2035
<b, a>() -> q_gen_2036
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 59
() -> insert([x, nil, cons(x, nil)]) -> 59
() -> leq([a, y]) -> 59
() -> leq([b, b]) -> 59
() -> sort([nil, nil]) -> 59
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 61
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 62
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 60
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 61
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 61
(leq([b, a])) -> BOT -> 60
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(b, nil))  ;  _nj -> cons(a, nil)  ;  _oj -> cons(a, cons(a, nil))  ;  l -> cons(b, nil)
})

-------------------------------------------
Step 83, which took 0.420098 s (model generation: 0.407643,  model checking: 0.012455):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_2018
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2018
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2026, q_gen_2036},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1998) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2026) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1998
<cons, cons>(q_gen_2036, q_gen_1998) -> q_gen_1998
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1998
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2026) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2026) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_2026
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2026
<b, a>() -> q_gen_2036
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 60
() -> insert([x, nil, cons(x, nil)]) -> 60
() -> leq([a, y]) -> 60
() -> leq([b, b]) -> 60
() -> sort([nil, nil]) -> 60
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 61
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 62
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 61
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 64
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 62
(leq([b, a])) -> BOT -> 61
}
Sat witness: Found: ((insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]), {
_cj -> cons(a, cons(b, nil))  ;  _dj -> cons(a, cons(b, cons(b, nil)))  ;  y -> b  ;  z -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 84, which took 0.565916 s (model generation: 0.553446,  model checking: 0.012470):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2058, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2058) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_2058) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2058
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2058
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2058
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2058
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2018
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2026, q_gen_2036},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1998) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1988
<cons, cons>(q_gen_2036, q_gen_2026) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1998
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2026) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2026) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1998) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_2026
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2026
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2026
<b, a>() -> q_gen_2036
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 61
() -> insert([x, nil, cons(x, nil)]) -> 61
() -> leq([a, y]) -> 61
() -> leq([b, b]) -> 61
() -> sort([nil, nil]) -> 61
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 64
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 62
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 62
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 64
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 62
(leq([b, a])) -> BOT -> 62
}
Sat witness: Found: ((append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]), {
_hj -> cons(b, cons(b, cons(a, nil)))  ;  h1 -> a  ;  l2 -> cons(b, cons(b, nil))  ;  t1 -> cons(b, cons(b, nil))
})

-------------------------------------------
Step 85, which took 0.692792 s (model generation: 0.676017,  model checking: 0.016775):

Model:
|_
{
append -> 
{{{
Q={q_gen_1994, q_gen_2004, q_gen_2005, q_gen_2029, q_gen_2030, q_gen_2031, q_gen_2032, q_gen_2040, q_gen_2041, q_gen_2064, q_gen_2065, q_gen_2066, q_gen_2081, q_gen_2101},
Q_f={q_gen_1994},
Delta=
{
<nil>() -> q_gen_2030
<b>() -> q_gen_2031
<a>() -> q_gen_2065
<cons>(q_gen_2065, q_gen_2030) -> q_gen_2101
<cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_2004
<nil, nil>() -> q_gen_2004
<a, a>() -> q_gen_2005
<b, b>() -> q_gen_2005
<cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2041
<cons, cons>(q_gen_2081, q_gen_2004) -> q_gen_2041
<nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2041
<nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2041
<a, b>() -> q_gen_2081
<cons, cons, cons>(q_gen_2032, q_gen_2029) -> q_gen_1994
<cons, cons, cons>(q_gen_2032, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2040) -> q_gen_1994
<cons, cons, cons>(q_gen_2066, q_gen_2064) -> q_gen_1994
<cons, nil, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, cons, cons>(q_gen_2005, q_gen_2004) -> q_gen_1994
<nil, nil, cons>(q_gen_2031, q_gen_2101) -> q_gen_1994
<nil, nil, cons>(q_gen_2065, q_gen_2101) -> q_gen_1994
<nil, nil, nil>() -> q_gen_1994
<cons, nil, cons>(q_gen_2081, q_gen_2004) -> q_gen_2029
<nil, cons, cons>(q_gen_2081, q_gen_2041) -> q_gen_2029
<nil, nil, cons>(q_gen_2031, q_gen_2030) -> q_gen_2029
<a, b, a>() -> q_gen_2032
<b, b, b>() -> q_gen_2032
<cons, cons, cons>(q_gen_2032, q_gen_1994) -> q_gen_2040
<cons, nil, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<nil, cons, cons>(q_gen_2005, q_gen_2041) -> q_gen_2040
<cons, cons, cons>(q_gen_2032, q_gen_2064) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_1994) -> q_gen_2064
<cons, cons, cons>(q_gen_2066, q_gen_2029) -> q_gen_2064
<nil, nil, cons>(q_gen_2065, q_gen_2030) -> q_gen_2064
<a, a, a>() -> q_gen_2066
<b, a, b>() -> q_gen_2066
}

Datatype: <eltlist, eltlist, eltlist>
Convolution form: right
}}}
  ;  insert -> 
{{{
Q={q_gen_1991, q_gen_1992, q_gen_1993, q_gen_1996, q_gen_1997, q_gen_2002, q_gen_2008, q_gen_2013, q_gen_2014, q_gen_2018},
Q_f={q_gen_1991},
Delta=
{
<nil>() -> q_gen_1992
<b>() -> q_gen_1993
<a>() -> q_gen_2008
<cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1996
<cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1996
<cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1996
<nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1996
<a, b>() -> q_gen_1997
<b, b>() -> q_gen_1997
<a, a>() -> q_gen_2002
<b, a>() -> q_gen_2013
<nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_2018
<a, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<a, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_1991
<a, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_1991
<a, nil, cons>(q_gen_2008, q_gen_1992) -> q_gen_1991
<b, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_1991
<b, cons, cons>(q_gen_2002, q_gen_1996) -> q_gen_1991
<b, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_1991
<a, cons, cons>(q_gen_1997, q_gen_1996) -> q_gen_2014
<a, cons, cons>(q_gen_1997, q_gen_2018) -> q_gen_2014
<a, cons, cons>(q_gen_2013, q_gen_2018) -> q_gen_2014
<a, nil, cons>(q_gen_1993, q_gen_1992) -> q_gen_2014
<b, cons, cons>(q_gen_2002, q_gen_2018) -> q_gen_2014
<b, cons, cons>(q_gen_2013, q_gen_1996) -> q_gen_2014
}

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

Datatype: <elt, elt>
Convolution form: right
}}}
  ;  sort -> 
{{{
Q={q_gen_1988, q_gen_1998, q_gen_1999, q_gen_2015, q_gen_2016, q_gen_2026, q_gen_2036},
Q_f={q_gen_1988, q_gen_1998},
Delta=
{
<cons, cons>(q_gen_1999, q_gen_1998) -> q_gen_1988
<nil, nil>() -> q_gen_1988
<cons, cons>(q_gen_1999, q_gen_1988) -> q_gen_1998
<cons, cons>(q_gen_1999, q_gen_2015) -> q_gen_1998
<cons, cons>(q_gen_2036, q_gen_2015) -> q_gen_1998
<a, a>() -> q_gen_1999
<b, b>() -> q_gen_1999
<cons, cons>(q_gen_1999, q_gen_2026) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_1988) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2015) -> q_gen_2015
<cons, cons>(q_gen_2016, q_gen_2026) -> q_gen_2015
<cons, cons>(q_gen_2036, q_gen_1998) -> q_gen_2015
<a, b>() -> q_gen_2016
<cons, cons>(q_gen_2016, q_gen_1998) -> q_gen_2026
<cons, cons>(q_gen_2036, q_gen_1988) -> q_gen_2026
<cons, cons>(q_gen_2036, q_gen_2026) -> q_gen_2026
<b, a>() -> q_gen_2036
}

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

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

Teacher's answer:
New clause system:
{
() -> append([nil, l2, l2]) -> 62
() -> insert([x, nil, cons(x, nil)]) -> 62
() -> leq([a, y]) -> 62
() -> leq([b, b]) -> 62
() -> sort([nil, nil]) -> 62
(append([t1, l2, _hj])) -> append([cons(h1, t1), l2, cons(h1, _hj)]) -> 64
(append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]) -> 65
(insert([x, z, _xi]) /\ not leq([x, y])) -> insert([x, cons(y, z), cons(y, _xi)]) -> 63
(insert([y, _cj, _dj]) /\ sort([z, _cj])) -> sort([cons(y, z), _dj]) -> 64
(leq([x, y])) -> insert([x, cons(y, z), cons(x, cons(y, z))]) -> 63
(leq([b, a])) -> BOT -> 63
}
Sat witness: Found: ((append([cons(a, nil), _nj, _oj]) /\ sort([l, _nj]) /\ sort([cons(a, l), _mj])) -> eq_eltlist([_mj, _oj]), {
_mj -> cons(a, cons(b, nil))  ;  _nj -> cons(a, nil)  ;  _oj -> cons(a, cons(a, nil))  ;  l -> cons(a, nil)
})

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