Ha Ha, LogNonsenseTalk at its best:

> Future work
> Arm–twist Prolog implementers for better
> support for rational terms and tabling
> https://logtalk.org/papers/colp2012/coinduction_colp2012_slides.pdf

Ok, here is a suggestion. Propose a (@<)/2 for rational terms.

Then talk again.

(@<) can be useful for tabling tries. So I guess LogNonsenseTalk
work about co-induction was highly influenced by the following
seminal paper in logic programming dating back to the 70s:

How to Levitate
https://www.youtube.com/watch?v=z2I5J1ArmeM

LMAO!

Mostowski Collapse schrieb am Dienstag, 4. April 2023 um 10:05:18 UTC+2:
> Ha Ha, LogNonsenseTalk at its best:
>
> > Future work
> > Arm–twist Prolog implementers for better
> > support for rational terms and tabling
> > https://logtalk.org/papers/colp2012/coinduction_colp2012_slides.pdf
>
> Ok, here is a suggestion. Propose a (@<)/2 for rational terms.
>
> Then talk again.

Other Levitating experts on the scene: Ulrich Neumerkel
and Markus Triska. It is now the year 2023, and they
still discuss number_chars/3:

number_chars/2 sometimes yields wrong results
https://github.com/mthom/scryer-prolog/issues/1773

Whereas their Scryer Prolog cannot do correctly
(@<) on rational trees aka cyclic terms. It even never
comes to their mind, to apply KISS principle

to the number_chars/3 problem, and instead
read the requirement for what number_chars/3
accepts to read it as "integer" where:

integer (* 6.4 *)
= [ layout text sequence (* 6.4.1 *) ] ,
integer token (* 6.4.4 *) ;

Why not simply strip down the relevant production
requirement for number_chars/3 "integer token" only,
or maybe something even simpler, and forget about

all the layout nonsense? Most programming languages
do it this way. Just checkout parseInteger() or parseFloat()
across languages such as Java, JavaScript, Python etc..

No language designer is so debilated to include in the integer
or float syntax layout or comments. This happens only when
you have Levitating experts on the scene.

LoL

Mostowski Collapse schrieb am Dienstag, 4. April 2023 um 10:10:56 UTC+2:
> (@<) can be useful for tabling tries. So I guess LogNonsenseTalk
> work about co-induction was highly influenced by the following
> seminal paper in logic programming dating back to the 70s:
>
> How to Levitate
> https://www.youtube.com/watch?v=z2I5J1ArmeM
>
> LMAO!
> Mostowski Collapse schrieb am Dienstag, 4. April 2023 um 10:05:18 UTC+2:
> > Ha Ha, LogNonsenseTalk at its best:
> >
> > > Future work
> > > Arm–twist Prolog implementers for better
> > > support for rational terms and tabling
> > > https://logtalk.org/papers/colp2012/coinduction_colp2012_slides.pdf
> >
> > Ok, here is a suggestion. Propose a (@<)/2 for rational terms.
> >
> > Then talk again.

About the KISS principle:

KISS, an acronym for "Keep it simple, stupid!",
https://en.wikipedia.org/wiki/KISS_principle

Hope this Helps!

Mostowski Collapse schrieb am Dienstag, 4. April 2023 um 10:20:01 UTC+2:
> Other Levitating experts on the scene: Ulrich Neumerkel
> and Markus Triska. It is now the year 2023, and they
> still discuss number_chars/3:
>
> number_chars/2 sometimes yields wrong results
> https://github.com/mthom/scryer-prolog/issues/1773
>
> Whereas their Scryer Prolog cannot do correctly
> (@<) on rational trees aka cyclic terms. It even never
> comes to their mind, to apply KISS principle
>
> to the number_chars/3 problem, and instead
> read the requirement for what number_chars/3
> accepts to read it as "integer" where:
>
> integer (* 6.4 *)
> = [ layout text sequence (* 6.4.1 *) ] ,
> integer token (* 6.4.4 *) ;
>
> Why not simply strip down the relevant production
> requirement for number_chars/3 "integer token" only,
> or maybe something even simpler, and forget about
>
> all the layout nonsense? Most programming languages
> do it this way. Just checkout parseInteger() or parseFloat()
> across languages such as Java, JavaScript, Python etc..
>
> No language designer is so debilated to include in the integer
> or float syntax layout or comments. This happens only when
> you have Levitating experts on the scene.
>
> LoL
> Mostowski Collapse schrieb am Dienstag, 4. April 2023 um 10:10:56 UTC+2:
> > (@<) can be useful for tabling tries. So I guess LogNonsenseTalk
> > work about co-induction was highly influenced by the following
> > seminal paper in logic programming dating back to the 70s:
> >
> > How to Levitate
> > https://www.youtube.com/watch?v=z2I5J1ArmeM
> >
> > LMAO!
> > Mostowski Collapse schrieb am Dienstag, 4. April 2023 um 10:05:18 UTC+2:
> > > Ha Ha, LogNonsenseTalk at its best:
> > >
> > > > Future work
> > > > Arm–twist Prolog implementers for better
> > > > support for rational terms and tabling
> > > > https://logtalk.org/papers/colp2012/coinduction_colp2012_slides.pdf
> > >
> > > Ok, here is a suggestion. Propose a (@<)/2 for rational terms.
> > >
> > > Then talk again.

This blog post has a nice easter egg at the end.
https://www.philipzucker.com/harrop-checkpoint/
Elaborating on it I get the following:

/* File comvars2.p */
:- op(1200, xfy, =>).
:- op(1150, fx, hypo).

term_expansion((:- hypo(F/N)), (H :- shift(in(H)))) :-
functor(H, F, N).

(A => B) :-
reset(B, in(C), Cont),
(Cont == 0 -> true; (C = A; shift(in(C))), Cont).

Here is test case of embedded implication backtracking:

:- hypo p/1.

?- reset((p(1) => p(2) => p(X)), in(_), Cont), Cont==0.
X = 2,
Cont = 0 ;
X = 1,
Cont = 0 ;
false.

When I try the same with Scryer Prolog:

/* File comvars2sc.p */
:- use_module(library(cont)).

:- op(1200, xfy, =>).
:- op(1150, fx, hypo).

term_expansion((:- hypo(F/N)), (H :- shift(in(H)))) :-
functor(H, F, N).

(A => B) :-
reset(B, in(C), Cont),
(Cont = none -> true; Cont = cont(G) -> (C = A; shift(in(C))), G).

I get a segmentation fault during backtracking:

?- reset((p(1) => p(2) => p(X)), in(_), Cont), Cont==none.
X = 2, Cont = none
; Segmentation fault

Mostowski Collapse schrieb am Samstag, 22. April 2023 um 15:26:19 UTC+2:
> This blog post has a nice easter egg at the end.
> https://www.philipzucker.com/harrop-checkpoint/
> Elaborating on it I get the following:
>
> /* File comvars2.p */
> :- op(1200, xfy, =>).
> :- op(1150, fx, hypo).
>
> term_expansion((:- hypo(F/N)), (H :- shift(in(H)))) :-
> functor(H, F, N).
>
> (A => B) :-
> reset(B, in(C), Cont),
> (Cont == 0 -> true; (C = A; shift(in(C))), Cont).
>
> Here is test case of embedded implication backtracking:
>
> :- hypo p/1.
>
> ?- reset((p(1) => p(2) => p(X)), in(_), Cont), Cont==0.
> X = 2,
> Cont = 0 ;
> X = 1,
> Cont = 0 ;
> false.