From Newsgroup: comp.lang.prolog

Hi,

What you are adressing here, in purely
symbolic form, without some helpful natural
language rephrasing:

Let (H, <) be the standard total oder an the
Prolog finite terms. Let R be the set of rational
term. H c R. Then there is total order
extention (R, <') of (H, <).

Is the problem of a compare/3 for rational trees,
that is a extension of the compare/3 for finite aka
acyclic terms with the submodel property. This is
quite possible, for example representation

based compare/3 that uses a collation key:

S @<' T :<=> rep(S) @< rep(T)

It has trivially acyclic comparison as a submodel,
when rep(S) = S for acyclic terms S. The inverse
rep^-1 itself is the homomorphism, its even an
embedding, since identity would be injective.

You might even forget about the plot, and endlessly
go down the rabbit hole of mathematics, and write a
100 pages paper, and prove Fermat’s Last Theorem
in passing again.

I can only assume mathematics currently hates
computer science because of AI.

Bye

Mild Shock schrieb:

Hi,

Create a ChatGPT for cyclic terms? It seems
that the SWI-Prolog discourse contains a lot
of recent exploration of about cyclic terms.
Yet humans don’t remember them,

or are too lazy to recall them, look them
up again. Maybe to offload some of the cognitive
load and have a easier way forward, one might
use GPT builder and

create a cyclic term assistant. One could
then ask the artificial intelligece (AI) for
the following things:

- Automated Testing:
  please perform some monkey testing
  on my news compare/3 idea

- Automated Proving:
  please suggest a proof for my newest
  lemma about compare/3

- Code Refactor:
  please refactor my code, I would like to
  use (==)/2 instead of same_time/2

- Auto Comment:
  please auto comment my code, I was too
  lazy to write comments

- What else?
  ChatGPT itself gave me a list when I ask
  what will be between now and AGI. Could
  look it up, as a few interesting items as well
  mainly targeting automated summarizing ideas.

Is SWI-Prolog discourse part of the SWI-Prolog
assistant building process. Its less a static
resource, has ongoing discussions. Needs periodic
retraining of the AI.

Also the above vision includes some scenarios
where the Assistant would be better integrated
into an IDE, but these Assistants have usually
more expensive price plans.

Will this IDE be XPCE, who knows?

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.prolog

Hi,

I don't know, but 100x times slower than
SWI-Prolog doesn't sound good for Scryer Prolog.
And the 10x times slower than SWI-Prolog

are also not nice for Trealla Prolog. But I
guess Trealla uses C code programming that
has passed the time of test. What is Scryer

using? Well they do not use something that
is far away from the Strudel Coding Style for
Music, namely I find things like:

let arity = self.code[current_pred_start..current_pred_end]
.iter()
.flat_map(Instruction::registers)
.flat_map(|r| match r {
RegType::Temp(t) => Some(t),
_ => None,
})
.max()
.unwrap_or(0);
https://github.com/mthom/scryer-prolog/issues/3175

These things usually don't perform well. Even
if they process tuple oriented and not
set oriented, still the programming style

induces a lot of overhead, unless the compiler
does agressively massage the code. Possibly
only Haskell can do, since its longer in the

bussiness. Not sure about Rust. Basically an iter()
is a constructor and an arrow function is a constructor,
and they create objects! Also the argument threading

can be less efficient than a code block with
registers and a traditional loop. A flat
map is even a special kind of a horror among

pipeline elements, since it usually needs a
little state. Maybe using the novel C+20 Pipes
would help. They are quite charming, even passing

sentinells around. LoL

Bye

Mild Shock schrieb:

Hi,

The same example values also create fishy 🐟
sorting using native sorting in Scryer Prolog:

/* Scryer Prolog 0.9.4-417 */
?- values([z,x,y], A), sort(A, B),
   values([x,y,z], C), sort(C, D), B == D.
   false. /* fishy 🐟 */

Or using native sorting in SWI-Prolog:

/* SWI-Prolog 9.3.25 */
?- values([z,x,y], A), sort(A, B),
   values([x,y,z], C), sort(C, D), B == D.
false. /* fishy 🐟 */

Bye

Mild Shock schrieb:

I checked that your examples are not counter
examples for my compare_with_stack/3.

What makes you think the values I show, X, Y
and Z, are possible in a total linear ordering?
The values also break predsort/3, you can easily
verify that sort([x,y,z]) =\= sort([y,x,z]):

value(x, X) :- X = X-0-9-7-6-5-4-3-2-1.
value(y, Y) :- Y = Y-7-5-8-2-4-1.
value(z, Z) :- H = H-9-7-6-5-4-3-2-1-0, Z = H-9-7-6-5-4-3-2-1.

values(L, R) :- maplist(value, L, R).

?- values([x,y,z], A), predsort(compare_with_stack, A, B),
    values([y,x,z], C), predsort(compare_with_stack, C, D),
    B == D.
false.

But expectation would be sort([x,y,z]) ==
sort([y,x,z]) since sort/2 should be immune
to permutation. If this isn’t enough proof that
there is something fishy in compare_with_stack/3 ,

well then I don’t know, maybe the earth is indeed flat?

--- Synchronet 3.21a-Linux NewsLink 1.2