From Newsgroup: comp.lang.prolog

Hi,

Who will win the new Prolog race?
SWI or Scryer? Is it enough that SWI-Prolog
has teamed up with Ciao Prolog?

What about resources that really can
code a Prolog systems. SWI-Prolog is
now doomed to have professional moron

Julio Di Egidio on board. Not sure whether
he will ever become a heavy committer to
SWI-Prolog source. But who knows, we should

also give Julio Di Egidio a chance. My
gut feeling at the moment:

- SWI-Prolog:
Pull Requests 10 Open / 560 Closed

- Scryer Prolog:
Pull Requests 40 Open / 751 Closed

In the past I would measure active committers.
But the new "liveness" indicator of a Prolog
system could be indeed Pull Requests.

So who will win?

P.S.: Data sources:

https://github.com/mthom/scryer-prolog/pulls

https://github.com/SWI-Prolog/swipl-devel/pulls

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.prolog

Hi,

The only problem is Rust is shiiiit.
At least some argument about precise
garbage collection induced by immediate

malloc / free doesn't strike me as
convincing. Many modern programming
languages don't use the malloc / free

paradigma for memory management. You
don't get automatically pause free
systems when relying on malloc / free.

It can be even worse. I have seen browsers
that take a while to close a window
because they did synchrously release all

the resources of a window. So there
is a fallacy involved in all believes that
immediate malloc / free leads to pause

free systems, it can be even worse.

Bye

Mild Shock schrieb:

Hi,

Who will win the new Prolog race?
SWI or Scryer? Is it enough that SWI-Prolog
has teamed up with Ciao Prolog?

What about resources that really can
code a Prolog systems. SWI-Prolog is
now doomed to have professional moron

Julio Di Egidio on board. Not sure whether
he will ever become a heavy committer to
SWI-Prolog source. But who knows, we should

also give Julio Di Egidio a chance. My
gut feeling at the moment:

- SWI-Prolog:
-a Pull Requests 10 Open / 560 Closed

- Scryer Prolog:
-a Pull Requests 40 Open / 751 Closed

In the past I would measure active committers.
But the new "liveness" indicator of a Prolog
system could be indeed Pull Requests.

So who will win?

P.S.: Data sources:

https://github.com/mthom/scryer-prolog/pulls

https://github.com/SWI-Prolog/swipl-devel/pulls

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.prolog

Hi,

Yesterday I did again some testing of the
unification algorithm. Somehow Scryer is
also a moving target, so my measurement for

Scryer Prolog has somehow changed. Possibly
because I changed the test cases a little bit,
used the (\+ \+) to have different scenarios.

But with the new hybrid prototype from
yesterday it shows for bisimulation (=)/2
resp (==)/2 and the N = 1rCO048rCO576 test case:

Hybrid Solution

Test Java JavaScript Python Scryer
(=)/2 99 115 469 132
(==)/2 68 71 140 127

Ok, the Python almost beats Rust, was
exaggerating for the effect, and only
for (==)/2, we have still 140 > 127.

And otherwise for (=)/2 its drastic 469 > 132.
Not sure what is going on in the (=)/2,
why Python is so slow. On the other hand

Java and JavaScript run away from Rust,
are better in my implementation if bisimulation
and Jaffar's Unification, not significantly,

but noticeable I suspect.

Bye

Mild Shock schrieb:

Hi,

The only problem is Rust is shiiiit.
At least some argument about precise
garbage collection induced by immediate

malloc / free doesn't strike me as
convincing. Many modern programming
languages don't use the malloc / free

paradigma for memory management. You
don't get automatically pause free
systems when relying on malloc / free.

It can be even worse. I have seen browsers
that take a while to close a window
because they did synchrously release all

the resources of a window. So there
is a fallacy involved in all believes that
immediate malloc / free leads to pause

free systems, it can be even worse.

Bye

Mild Shock schrieb:

Hi,

Who will win the new Prolog race?
SWI or Scryer? Is it enough that SWI-Prolog
has teamed up with Ciao Prolog?

What about resources that really can
code a Prolog systems. SWI-Prolog is
now doomed to have professional moron

Julio Di Egidio on board. Not sure whether
he will ever become a heavy committer to
SWI-Prolog source. But who knows, we should

also give Julio Di Egidio a chance. My
gut feeling at the moment:

- SWI-Prolog:
-a-a Pull Requests 10 Open / 560 Closed

- Scryer Prolog:
-a-a Pull Requests 40 Open / 751 Closed

In the past I would measure active committers.
But the new "liveness" indicator of a Prolog
system could be indeed Pull Requests.

So who will win?

P.S.: Data sources:

https://github.com/mthom/scryer-prolog/pulls

https://github.com/SWI-Prolog/swipl-devel/pulls

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.prolog

Hi,

Now I have the feeling that Trealla implements
the extreme of Jaffar's Unification, to the extend
that it keeps and trails functor linking? Was

studying the source of Trealla . Have also the
impression that it uses a very large native stack.
Is this trailing what gave it the name Trealla,

despite the geographic beach location with such a name ?
BTW: I have new benchmark results (*) = Dogelog:

Test | Java (*) | JavaScript (*) | Python (*) | Scryer | Trealla
-- | -- | -- | -- | -- | --
(=)/2 | 184 | 514 | 1750 | 210 | 53
unify_with_occurs_check/2 | 213 | 601 | 2344 | N/A | 53
(==)/2 | 95 | 227 | 1265 | 250 | 65
compare/3 | 86 | 221 | 1328 | 250 | 65
copy_term/2 | 409 | 589 | 2579 | 108 | N/A
term_variables/2 | 168 | 318 | 1469 | 166 | 90
ground/1 | 40 | 120 | 516 | 70 | 121
acyclic_term/1 | 129 | 290 | 1281 | 386 | N/A
numbervars/3 | 170 | 327 | 1516 | 164 | 100

Pitty `copy_term/2` and `acyclic_term/1` do not
yet work with a hydra example.

I am using a hydra variant, which puts less
pressure on the memory, but does benchmark
the built-ins in a loop, so that I see some

numbers. My problem was that Trealla was
below the 1 ms mesurememt:
```
hydra(0, _) :- !.
hydra(N, h(X, X)) :- N > 0, N0 is N-1, hydra(N0, X).

hydra(0, A, A) :- !.
hydra(N, h(X, X), A) :- N > 0, N0 is N-1, hydra(N0, X, A).

/* Binary Built-ins */
bench :-
hydra(65536, X), hydra(65536, Y, Y),
time((between(1,64,_), X = Y, fail; true)),
time((between(1,64,_), unify_with_occurs_check(X, Y), fail; true)),
time((between(1,64,_), X == Y, fail; true)),
time((between(1,64,_), compare(_, X, Y), fail; true)), fail; true.

/* Unary Built-ins */
bench2 :-
hydra(65536, X), hydra(65536, Y, Y),
time((between(1,64,_), copy_term(X-Y,_), fail; true)),
time((between(1,64,_), term_variables(X-Y,_), fail; true)),
time((between(1,64,_), ground(X-Y), fail; true)),
time((between(1,64,_), acyclic_term(X-Y), fail; true)),
fail; true.

/* Misc Built-ins */
bench3 :-
hydra(65536, X), hydra(65536, Y, Y),
time((between(1,64,_), numbervars(X-Y,0,_), fail; true)),
fail; true.
```
Bye

Mild Shock schrieb:

Hi,

Who will win the new Prolog race?
SWI or Scryer? Is it enough that SWI-Prolog
has teamed up with Ciao Prolog?

What about resources that really can
code a Prolog systems. SWI-Prolog is
now doomed to have professional moron

Julio Di Egidio on board. Not sure whether
he will ever become a heavy committer to
SWI-Prolog source. But who knows, we should

also give Julio Di Egidio a chance. My
gut feeling at the moment:

- SWI-Prolog:
-a Pull Requests 10 Open / 560 Closed

- Scryer Prolog:
-a Pull Requests 40 Open / 751 Closed

In the past I would measure active committers.
But the new "liveness" indicator of a Prolog
system could be indeed Pull Requests.

So who will win?

P.S.: Data sources:

https://github.com/mthom/scryer-prolog/pulls

https://github.com/SWI-Prolog/swipl-devel/pulls

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.prolog

Hi,

Information for Boris the Loris, chief grammar
Nazi of SWI-Prolog discourse. Here is a summary
of my No Fuzz(y) declaration for the

Trealla & Co. benchmarking from my previous post:

- No fuzzy logic involved.
Its all binary.

- No fuzzy testing involved.
Its all manual testing.

- No fuzz testing involved.
See above fuzzy testig.

- No fuzzing test involved.
See above fuzzy testig.

What about the American Fuzzy Lop (AFL),
a free software fuzzer:

https://en.wikipedia.org/wiki/American_Fuzzy_Lop_%28software%29

Or was a breed of rabbit, by the
the name American Fuzzy Lop involved?

https://en.wikipedia.org/wiki/American_Fuzzy_Lop

No neither of the 2 AFLs were involved.

Bye

Mild Shock schrieb:

Hi,

Now I have the feeling that Trealla implements
the extreme of Jaffar's Unification, to the extend
that it keeps and trails functor linking? Was

studying the source of Trealla . Have also the
impression that it uses a very large native stack.
Is this trailing what gave it the name Trealla,

despite the geographic beach location with such a name ?
BTW: I have new benchmark results (*) = Dogelog:

Test | Java (*) | JavaScript (*) | Python (*) | Scryer | Trealla
-- | -- | -- | -- | -- | --
(=)/2 | 184 | 514 | 1750 | 210 | 53
unify_with_occurs_check/2 | 213 | 601 | 2344 | N/A | 53
(==)/2 | 95 | 227 | 1265 | 250 | 65
compare/3 | 86 | 221 | 1328 | 250 | 65
copy_term/2 | 409 | 589 | 2579 | 108 | N/A
term_variables/2 | 168 | 318 | 1469 | 166 | 90
ground/1 | 40 | 120 | 516 | 70 | 121
acyclic_term/1 | 129 | 290 | 1281 | 386 | N/A
numbervars/3 | 170 | 327 | 1516 | 164 | 100

Pitty `copy_term/2` and `acyclic_term/1` do not
yet work with a hydra example.

I am using a hydra variant, which puts less
pressure on the memory, but does benchmark
the built-ins in a loop, so that I see some

numbers. My problem was that Trealla was
below the 1 ms mesurememt:
```
hydra(0, _) :- !.
hydra(N, h(X, X)) :- N > 0, N0 is N-1, hydra(N0, X).

hydra(0, A, A) :- !.
hydra(N, h(X, X), A) :- N > 0, N0 is N-1, hydra(N0, X, A).

/* Binary Built-ins */
bench :-
-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a time((between(1,64,_), X = Y, fail; true)),
-a-a time((between(1,64,_), unify_with_occurs_check(X, Y), fail; true)),
-a-a time((between(1,64,_), X == Y, fail; true)),
-a-a time((between(1,64,_), compare(_, X, Y), fail; true)), fail; true.

/* Unary Built-ins */
bench2 :-
-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a time((between(1,64,_), copy_term(X-Y,_), fail; true)),
-a-a time((between(1,64,_), term_variables(X-Y,_), fail; true)),
-a-a time((between(1,64,_), ground(X-Y), fail; true)),
-a-a time((between(1,64,_), acyclic_term(X-Y), fail; true)),
-a-a fail; true.

/* Misc Built-ins */
bench3 :-
-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a time((between(1,64,_), numbervars(X-Y,0,_), fail; true)),
-a-a fail; true.
```
Bye

Mild Shock schrieb:

Hi,

Who will win the new Prolog race?
SWI or Scryer? Is it enough that SWI-Prolog
has teamed up with Ciao Prolog?

What about resources that really can
code a Prolog systems. SWI-Prolog is
now doomed to have professional moron

Julio Di Egidio on board. Not sure whether
he will ever become a heavy committer to
SWI-Prolog source. But who knows, we should

also give Julio Di Egidio a chance. My
gut feeling at the moment:

- SWI-Prolog:
-a-a Pull Requests 10 Open / 560 Closed

- Scryer Prolog:
-a-a Pull Requests 40 Open / 751 Closed

In the past I would measure active committers.
But the new "liveness" indicator of a Prolog
system could be indeed Pull Requests.

So who will win?

P.S.: Data sources:

https://github.com/mthom/scryer-prolog/pulls

https://github.com/SWI-Prolog/swipl-devel/pulls

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.prolog

Hi,

Was Boris living under a rock, maybe on
the moon in a secret Nazi Facility?

Who knows, maybe he was in another facility,
some kind of mental asylum, until he was

hired by SWI-Prolog. How many Fuzzy Testing
tools are there? Actually plenty:

http://fuzzing-survey.org/

Some excerpt:

Creal
FishFuzz
ParmeSan
WindRanger
loFuzz
UAFL
HAFL
MobFuzz
WINNIE
CAFL
DynSQL
MirageFuzz
IRFU
PhyFu
NestFuzz
AMPFuzz
MC2
AIFORE
IPEA-Fuzz
FuzzlnMem
CarpetFuzz
JIGSAW
YARPGen
PDGF
BEACON
Mallory
Fuzz
LLM-Fuzzer
FAST
DAFL
OddFuzz
KRAKEN
CDFUZ7
MALinten+
ChatAFL
TWINFUZ7
DeepGo
xFUZZ
FreeWavm
Halo
Select
Titan
Etc...

Bye

Mild Shock schrieb:

Hi,

Information for Boris the Loris, chief grammar
Nazi of SWI-Prolog discourse. Here is a summary
of my No Fuzz(y) declaration for the

Trealla & Co. benchmarking from my previous post:

- No fuzzy logic involved.
-a Its all binary.

- No fuzzy testing involved.
-a Its all manual testing.

- No fuzz testing involved.
-a See above fuzzy testig.

- No fuzzing test involved.
-a See above fuzzy testig.

What about the American Fuzzy Lop (AFL),
a free software fuzzer:

https://en.wikipedia.org/wiki/American_Fuzzy_Lop_%28software%29

Or was a breed of rabbit, by the
the name American Fuzzy Lop involved?

https://en.wikipedia.org/wiki/American_Fuzzy_Lop

No neither of the 2 AFLs were involved.

Bye

Mild Shock schrieb:

Hi,

Now I have the feeling that Trealla implements
the extreme of Jaffar's Unification, to the extend
that it keeps and trails functor linking? Was

studying the source of Trealla . Have also the
impression that it uses a very large native stack.
Is this trailing what gave it the name Trealla,

despite the geographic beach location with such a name ?
BTW: I have new benchmark results (*) = Dogelog:

Test | Java (*) | JavaScript (*) | Python (*) | Scryer | Trealla
-- | -- | -- | -- | -- | --
(=)/2 | 184 | 514 | 1750 | 210 | 53
unify_with_occurs_check/2 | 213 | 601 | 2344 | N/A | 53
(==)/2 | 95 | 227 | 1265 | 250 | 65
compare/3 | 86 | 221 | 1328 | 250 | 65
copy_term/2 | 409 | 589 | 2579 | 108 | N/A
term_variables/2 | 168 | 318 | 1469 | 166 | 90
ground/1 | 40 | 120 | 516 | 70 | 121
acyclic_term/1 | 129 | 290 | 1281 | 386 | N/A
numbervars/3 | 170 | 327 | 1516 | 164 | 100

Pitty `copy_term/2` and `acyclic_term/1` do not
yet work with a hydra example.

I am using a hydra variant, which puts less
pressure on the memory, but does benchmark
the built-ins in a loop, so that I see some

numbers. My problem was that Trealla was
below the 1 ms mesurememt:
```
hydra(0, _) :- !.
hydra(N, h(X, X)) :- N > 0, N0 is N-1, hydra(N0, X).

hydra(0, A, A) :- !.
hydra(N, h(X, X), A) :- N > 0, N0 is N-1, hydra(N0, X, A).

/* Binary Built-ins */
bench :-
-a-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a-a time((between(1,64,_), X = Y, fail; true)),
-a-a-a time((between(1,64,_), unify_with_occurs_check(X, Y), fail; true)), >> -a-a-a time((between(1,64,_), X == Y, fail; true)),
-a-a-a time((between(1,64,_), compare(_, X, Y), fail; true)), fail; true.

/* Unary Built-ins */
bench2 :-
-a-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a-a time((between(1,64,_), copy_term(X-Y,_), fail; true)),
-a-a-a time((between(1,64,_), term_variables(X-Y,_), fail; true)),
-a-a-a time((between(1,64,_), ground(X-Y), fail; true)),
-a-a-a time((between(1,64,_), acyclic_term(X-Y), fail; true)),
-a-a-a fail; true.

/* Misc Built-ins */
bench3 :-
-a-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a-a time((between(1,64,_), numbervars(X-Y,0,_), fail; true)),
-a-a-a fail; true.
```
Bye

Mild Shock schrieb:

Hi,

Who will win the new Prolog race?
SWI or Scryer? Is it enough that SWI-Prolog
has teamed up with Ciao Prolog?

What about resources that really can
code a Prolog systems. SWI-Prolog is
now doomed to have professional moron

Julio Di Egidio on board. Not sure whether
he will ever become a heavy committer to
SWI-Prolog source. But who knows, we should

also give Julio Di Egidio a chance. My
gut feeling at the moment:

- SWI-Prolog:
-a-a Pull Requests 10 Open / 560 Closed

- Scryer Prolog:
-a-a Pull Requests 40 Open / 751 Closed

In the past I would measure active committers.
But the new "liveness" indicator of a Prolog
system could be indeed Pull Requests.

So who will win?

P.S.: Data sources:

https://github.com/mthom/scryer-prolog/pulls

https://github.com/SWI-Prolog/swipl-devel/pulls

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.prolog

Hi,

Maybe Boris the Loris is even not a Nazi-Retard.
Maybe he is a payed Troll on Putins payroll?

Similarly Julio Di Egidio, all his posts indicate
some radical anti-capitalist stance, mostlikely

just a romantic communist that exist in the thousands
in Italy, and other south European countries.

Bye

Mild Shock schrieb:

Hi,

Was Boris living under a rock, maybe on
the moon in a secret Nazi Facility?

Who knows, maybe he was in another facility,
some kind of mental asylum, until he was

hired by SWI-Prolog. How many Fuzzy Testing
tools are there? Actually plenty:

http://fuzzing-survey.org/

Some excerpt:

Creal
FishFuzz
ParmeSan
WindRanger
loFuzz
UAFL
HAFL
MobFuzz
WINNIE
CAFL
DynSQL
MirageFuzz
IRFU
PhyFu
NestFuzz
AMPFuzz
MC2
AIFORE
IPEA-Fuzz
FuzzlnMem
CarpetFuzz
JIGSAW
YARPGen
PDGF
BEACON
Mallory
Fuzz
LLM-Fuzzer
FAST
DAFL
OddFuzz
KRAKEN
CDFUZ7
MALinten+
ChatAFL
TWINFUZ7
DeepGo
xFUZZ
FreeWavm
Halo
Select
Titan
Etc...

Bye

Mild Shock schrieb:

Hi,

Information for Boris the Loris, chief grammar
Nazi of SWI-Prolog discourse. Here is a summary
of my No Fuzz(y) declaration for the

Trealla & Co. benchmarking from my previous post:

- No fuzzy logic involved.
-a-a Its all binary.

- No fuzzy testing involved.
-a-a Its all manual testing.

- No fuzz testing involved.
-a-a See above fuzzy testig.

- No fuzzing test involved.
-a-a See above fuzzy testig.

What about the American Fuzzy Lop (AFL),
a free software fuzzer:

https://en.wikipedia.org/wiki/American_Fuzzy_Lop_%28software%29

Or was a breed of rabbit, by the
the name American Fuzzy Lop involved?

https://en.wikipedia.org/wiki/American_Fuzzy_Lop

No neither of the 2 AFLs were involved.

Bye

Mild Shock schrieb:

Hi,

Now I have the feeling that Trealla implements
the extreme of Jaffar's Unification, to the extend
that it keeps and trails functor linking? Was

studying the source of Trealla . Have also the
impression that it uses a very large native stack.
Is this trailing what gave it the name Trealla,

despite the geographic beach location with such a name ?
BTW: I have new benchmark results (*) = Dogelog:

Test | Java (*) | JavaScript (*) | Python (*) | Scryer | Trealla
-- | -- | -- | -- | -- | --
(=)/2 | 184 | 514 | 1750 | 210 | 53
unify_with_occurs_check/2 | 213 | 601 | 2344 | N/A | 53
(==)/2 | 95 | 227 | 1265 | 250 | 65
compare/3 | 86 | 221 | 1328 | 250 | 65
copy_term/2 | 409 | 589 | 2579 | 108 | N/A
term_variables/2 | 168 | 318 | 1469 | 166 | 90
ground/1 | 40 | 120 | 516 | 70 | 121
acyclic_term/1 | 129 | 290 | 1281 | 386 | N/A
numbervars/3 | 170 | 327 | 1516 | 164 | 100

Pitty `copy_term/2` and `acyclic_term/1` do not
yet work with a hydra example.

I am using a hydra variant, which puts less
pressure on the memory, but does benchmark
the built-ins in a loop, so that I see some

numbers. My problem was that Trealla was
below the 1 ms mesurememt:
```
hydra(0, _) :- !.
hydra(N, h(X, X)) :- N > 0, N0 is N-1, hydra(N0, X).

hydra(0, A, A) :- !.
hydra(N, h(X, X), A) :- N > 0, N0 is N-1, hydra(N0, X, A).

/* Binary Built-ins */
bench :-
-a-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a-a time((between(1,64,_), X = Y, fail; true)),
-a-a-a time((between(1,64,_), unify_with_occurs_check(X, Y), fail; true)), >>> -a-a-a time((between(1,64,_), X == Y, fail; true)),
-a-a-a time((between(1,64,_), compare(_, X, Y), fail; true)), fail; true. >>>
/* Unary Built-ins */
bench2 :-
-a-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a-a time((between(1,64,_), copy_term(X-Y,_), fail; true)),
-a-a-a time((between(1,64,_), term_variables(X-Y,_), fail; true)),
-a-a-a time((between(1,64,_), ground(X-Y), fail; true)),
-a-a-a time((between(1,64,_), acyclic_term(X-Y), fail; true)),
-a-a-a fail; true.

/* Misc Built-ins */
bench3 :-
-a-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a-a time((between(1,64,_), numbervars(X-Y,0,_), fail; true)),
-a-a-a fail; true.
```
Bye

Mild Shock schrieb:

Hi,

Who will win the new Prolog race?
SWI or Scryer? Is it enough that SWI-Prolog
has teamed up with Ciao Prolog?

What about resources that really can
code a Prolog systems. SWI-Prolog is
now doomed to have professional moron

Julio Di Egidio on board. Not sure whether
he will ever become a heavy committer to
SWI-Prolog source. But who knows, we should

also give Julio Di Egidio a chance. My
gut feeling at the moment:

- SWI-Prolog:
-a-a Pull Requests 10 Open / 560 Closed

- Scryer Prolog:
-a-a Pull Requests 40 Open / 751 Closed

In the past I would measure active committers.
But the new "liveness" indicator of a Prolog
system could be indeed Pull Requests.

So who will win?

P.S.: Data sources:

https://github.com/mthom/scryer-prolog/pulls

https://github.com/SWI-Prolog/swipl-devel/pulls

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.prolog

Hi,

Tricky problem, how validate unify_with_occurs_check/2 ?
If the two arguments S and T are acyclic terms, the
unify_with_occurs_check/2 can be simulated as follows:

/* simulation */
unify_with_occurs_check2(X, Y) :-
X = Y, acyclic_term(X).

It also shows that theoretically the problem can be
solved in quasi linear time, since (=)/2 is quasi linear
and acyclic_term/1 is linear.

Now I find that unify_with_occurs_check2/2 and
unify_with_occurs_check/2 do not agree in Trealla
Prolog. For this test case for example:

/* Trealla Prolog 2.83.11 */
/* built-in */
?- S = s(s(A,s(B,A)),1), T = s(s(C,C),1),
unify_with_occurs_check(S,T).
S = s(s(s(B,A),s(B,A)),1), A = s(B,A),
T = s(s(s(B,A),s(B,A)),1), C = s(B,A).

/* simulation */
?- S = s(s(A,s(B,A)),1), T = s(s(C,C),1),
unify_with_occurs_check2(S,T).
false.

One can also check with Scryer Prolog it has
also a different result for the pair S and T:

/* Scryer Prolog 0.10.0 */
/* built-in */
?- S = s(s(A,s(B,A)),1), T = s(s(C,C),1),
unify_with_occurs_check(S,T).
false.

Bye

Mild Shock schrieb:

Hi,

Now I have the feeling that Trealla implements
the extreme of Jaffar's Unification, to the extend
that it keeps and trails functor linking? Was

studying the source of Trealla . Have also the
impression that it uses a very large native stack.
Is this trailing what gave it the name Trealla,

despite the geographic beach location with such a name ?
BTW: I have new benchmark results (*) = Dogelog:

Test | Java (*) | JavaScript (*) | Python (*) | Scryer | Trealla
-- | -- | -- | -- | -- | --
(=)/2 | 184 | 514 | 1750 | 210 | 53
unify_with_occurs_check/2 | 213 | 601 | 2344 | N/A | 53
(==)/2 | 95 | 227 | 1265 | 250 | 65
compare/3 | 86 | 221 | 1328 | 250 | 65
copy_term/2 | 409 | 589 | 2579 | 108 | N/A
term_variables/2 | 168 | 318 | 1469 | 166 | 90
ground/1 | 40 | 120 | 516 | 70 | 121
acyclic_term/1 | 129 | 290 | 1281 | 386 | N/A
numbervars/3 | 170 | 327 | 1516 | 164 | 100

Pitty `copy_term/2` and `acyclic_term/1` do not
yet work with a hydra example.

I am using a hydra variant, which puts less
pressure on the memory, but does benchmark
the built-ins in a loop, so that I see some

numbers. My problem was that Trealla was
below the 1 ms mesurememt:
```
hydra(0, _) :- !.
hydra(N, h(X, X)) :- N > 0, N0 is N-1, hydra(N0, X).

hydra(0, A, A) :- !.
hydra(N, h(X, X), A) :- N > 0, N0 is N-1, hydra(N0, X, A).

/* Binary Built-ins */
bench :-
-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a time((between(1,64,_), X = Y, fail; true)),
-a-a time((between(1,64,_), unify_with_occurs_check(X, Y), fail; true)),
-a-a time((between(1,64,_), X == Y, fail; true)),
-a-a time((between(1,64,_), compare(_, X, Y), fail; true)), fail; true.

/* Unary Built-ins */
bench2 :-
-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a time((between(1,64,_), copy_term(X-Y,_), fail; true)),
-a-a time((between(1,64,_), term_variables(X-Y,_), fail; true)),
-a-a time((between(1,64,_), ground(X-Y), fail; true)),
-a-a time((between(1,64,_), acyclic_term(X-Y), fail; true)),
-a-a fail; true.

/* Misc Built-ins */
bench3 :-
-a-a hydra(65536, X), hydra(65536, Y, Y),
-a-a time((between(1,64,_), numbervars(X-Y,0,_), fail; true)),
-a-a fail; true.
```
Bye

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.prolog

Hi,

Yeah, Boris the Loris saw it all comming,
when he mentioned that the Prolog Community
is probably overwhelmed by Fuzzy Testing.

And I must confess, I succumbed to the guilty
pleasure of Fuzzy Testing. To find a pair S, T
I used this fuzzy testing device:

needle(S, T) :-
between(1,1000,_),
sample((pick(T), acyclic_term(T))),
sample((pick(S), acyclic_term(S))),
\+ ((unify_with_occurs_check(T, S) -> A = 1; A = 0),
(unify_with_occurs_check2(T, S) -> B = 1; B = 0),
A == B).

With this sample generator. It has slight
modification in pick/1, it starts with [T,_,_]
instead of [T], so that non-linear acyclic terms

are created, which is required that unification
leads to cricles. Only unify acyclic linear terms
with each other that have disjoint variables,

doesn't give cyclic terms. So this modification
is needed so that we find something at all:

sample(G) :-
term_variables(G, L),
repeat, maplist(pick, L),
G, !.

pick(T) :-
pick([T,_,_], T).

pick(L, T) :-
random(V), N is truncate(V*3),
(N = 0 -> T = 1;
N = 1 -> T = s(P,Q), pick([P|L], P), pick([Q|L], Q);
length(L, M),
random(W), I is truncate(W*M),
nth0(I, L, S), S = T).

Bye

Mild Shock schrieb:

Hi,

Tricky problem, how validate unify_with_occurs_check/2 ?
If the two arguments S and T are acyclic terms, the
unify_with_occurs_check/2 can be simulated as follows:

/* simulation */
unify_with_occurs_check2(X, Y) :-
-a-a X = Y, acyclic_term(X).

It also shows that theoretically the problem can be
solved in quasi linear time, since (=)/2 is quasi linear
and acyclic_term/1 is linear.

Now I find that unify_with_occurs_check2/2 and
unify_with_occurs_check/2 do not agree in Trealla
Prolog. For this test case for example:

/* Trealla Prolog 2.83.11 */
/* built-in */
?- S = s(s(A,s(B,A)),1), T = s(s(C,C),1),
-a-a unify_with_occurs_check(S,T).
-a-a S = s(s(s(B,A),s(B,A)),1), A = s(B,A),
-a-a T = s(s(s(B,A),s(B,A)),1), C = s(B,A).

/* simulation */
?- S = s(s(A,s(B,A)),1), T = s(s(C,C),1),
-a-a unify_with_occurs_check2(S,T).
-a-a false.

One can also check with Scryer Prolog it has
also a different result for the pair S and T:

/* Scryer Prolog 0.10.0 */
/* built-in */
?- S = s(s(A,s(B,A)),1), T = s(s(C,C),1),
-a-a unify_with_occurs_check(S,T).
-a-a false.

Bye

--- Synchronet 3.21a-Linux NewsLink 1.2