>> Heck, I don't think it even got `shorter` right; it gave

shorter(A,B):-llength(A,C),llength(B,D),s(C,D).

>> which means len(A) + 1 == len(B), not len(A) < len(B), and AFAICT it can't
learn len(A) < len(B), not because the program isn't expressible with the
primitives you gave, but because it just doesn't reason that far.

Oops. Haha well spotted @^_^

This is correct for </2:

?- list_mil_problem([llength/2,shorter/2,ordered/3]).
Positive examples
-----------------
llength([],0).
llength([a],s(0)).
shorter([a],[b,c]).
shorter([1,2],[3,4,5]).
ordered([a],[b,c],[d,e,f]).

Negative examples
-----------------
:-ordered([a],[b],[c]).
:-ordered([a,b,c],[a,b],[c]).

Background knowledge
--------------------
tail/2:
tail([A|B],B).

p/2:
p(s(A),0):-ground_peano(A).
p(s(A),A).
p(s(A),s(B)):-ground_peano(A),p(A,B).

s/2:
s(0,s(A)):-ground_peano(A).
s(A,s(A)).
s(s(A),s(B)):-ground_peano(B),s(A,B).

ground_peano/1:
ground_peano(A):-ground(A),\+is_list(A).

Metarules
---------
abduce metarule 'P(X,Y)'.
list_rec_func metarule 'P(x,y):- Q(x,z),R(y,u),P(z,u)'.
list_comp metarule 'P(x,y):- Q(x,z), R(y,u), S(z,u)'.
triadic_chain metarule 'P(x,z,y):- Q(x,z), R(z,y)'.
true.

?- time(learn_dynamic([llength/2,shorter/2,ordered/3])).
llength([],0).
llength(A,B):-tail(A,C),p(B,D),llength(C,D).
shorter(A,B):-llength(A,C),llength(B,D),s(C,D).
ordered(A,B,C):-shorter(A,B),shorter(B,C).
% 29,554 inferences, 0.000 CPU in 0.011 seconds (0% CPU, Infinite Lips)
true.

Paste that in a file and consult it to test it:

?- ordered:ordered([1],[1,2,3],[1,2,3,4,5,6,7,8]).
true .

Regarding reasoning "that far" Louise can learn the complete successor /
predecessor relation (</2 and >/2) on its own and only from the primitives
s(N,s(N)) and p(s(N), N):

?- list_mil_problem([s/2,p/2]).
Positive examples
-----------------
s(0,s(A)).
s(0,s(0)).
s(s(0),s(s(s(s(0))))).
p(s(A),0).
p(s(0),0).
p(s(s(s(s(0)))),s(0)).

Negative examples
-----------------
[]

Background knowledge
--------------------
s_/2:
s_(A,s(A)).

p_/2:
p_(s(A),A).

Metarules
---------
identity metarule 'P(x,y):- Q(x,y)'.
chain metarule 'P(x,y):- Q(x,z), R(z,y)'.
true.

?- learn(s/2).
s(0,s(A)).
s(A,B):-s_(A,B).
s(A,B):-s_(A,C),s(C,B).
true.

?- learn(p/2).
p(s(A),0).
p(A,B):-p_(A,B).
p(A,B):-p_(A,C),p(C,B).
true.

However, in the ordered/3 problem I define p/2 and s/2 by hand so that I can
put in ground_peano/1 to avoid infinite recursion when Louise tries to pass
two lists to s/2 or p/2 (at that point, their termination conditions never
obtain, so they keep recursing).

You can chalk the potential for infinite recursion up as a limitation, you're
very welcome- but there are techniques to avoid this and guarantee termination
(Knuth-Bendix ordering of the Herbrand base, see ref [1]) which I haven't come
round to implementing yet (because they are not necessary given a bit of
common sense in defining BK, as above). On the other hand that's actually a
feature, in the sense that earlier systems required more specific language
bias than the metarules, that would avoid this kind of type-unsafety, but also
demanded more expert knowledge from the user. In any case, there's outs.

>> You've just kicked the can down the road; what you've given there cannot
solve, for instance, the same problem but with <= instead of <.

That's a different problem. Off we go:

?- list_mil_problem([llength/2,shorter/2,ordered_leq/3]).
Positive examples
-----------------
llength([],0).
llength([a],s(0)).
shorter([a],[b,c]).
shorter([1,2],[3,4,5]).
ordered_leq([a],[b],[d]).
ordered_leq([a],[b,c],[d,e,f]).
ordered_leq([a],[c],[e,f,g,h,i]).

Negative examples
-----------------
:-ordered([a,b,c],[a,b],[c]).

Background knowledge
--------------------
tail/2:
tail([A|B],B).

p/2:
p(s(A),0):-ground_peano(A).
p(s(A),A).
p(s(A),s(B)):-ground_peano(A),p(A,B).

s/2:
s(0,s(A)):-ground_peano(A).
s(A,s(A)).
s(s(A),s(B)):-ground_peano(B),s(A,B).

leq/2:
leq(A,A):-ground_peano(A).
leq(A,B):-s(A,B).

ground_peano/1:
ground_peano(A):-ground(A),\+is_list(A).

Metarules
---------
abduce metarule 'P(X,Y)'.
list_rec_func metarule 'P(x,y):- Q(x,z),R(y,u),P(z,u)'.
list_comp metarule 'P(x,y):- Q(x,z), R(y,u), S(z,u)'.
triadic_chain metarule 'P(x,z,y):- Q(x,z), R(z,y)'.
true.

?- learn_dynamic([llength/2,shorter/2,ordered_leq/3]).
llength([],0).
llength(A,B):-tail(A,C),p(B,D),llength(C,D).
shorter(A,B):-llength(A,C),llength(B,D),leq(C,D).
ordered_leq(A,B,C):-shorter(A,B),shorter(B,C).
true.

Or I could have added an eq(X,X) predicate instead of leq/2.

Note that I didn't declare leq/2 as BK for shorter/2 this time around:

?- background_knowledge(shorter/2, BK).
BK = [s/2].

I didn't even change its examples:

?- positive_example(shorter/2, E).
E = shorter([a], [b, c]) ;
E = shorter([1, 2], [3, 4, 5]).

It picked it up on its own, because it's the best way to define shorter/2 as a
sub-program for ordered_leq/3. Aaaw. Isn't it smart?

Pastebins for the source files:

ordered/3 and ordered_leq/3: https://pastebin.com/6NH0VTKK

s/2 and p/2: https://pastebin.com/0d0YWMfV

You'll let me know if I've done something else dumb, yes? :)

________________________

[1] https://www.doc.ic.ac.uk/~atn/papers/metagol_mlj.pdf

See section 4.1 "Ordering the Herbrand Base".

Edit: You know, it just struck me but when you say that only ML has ever
worked out of all AI, that probably means you don't recognise Louise as a
machine learning system... because it's not deep learning. That's just another
instance of the strange synechdoche I was talking about in my first comment in
this thread, where to some peoples' knowledge only deep learning is machine
learning because that's all some people know of machine learning. A bit like
thinking that chicken is the only thing one can eat because all one has ever
had is chicken.