Mild Shock
2025-01-03 21:20:38 UTC
Hi,
Just a side note, don't let you get distracted.
A side node about the chicken/egg problem, i.e.
without the curry:
- a) Eggs came first, for example Turtles had eggs
Turtles are part of an ancient reptilian
lineage ca 300 million years ago
- b) Chickens came after Turtles
Chickens, on the other hand, are much younger
in comparison, evolved from theropod dinosaurs
around 150 million years ago
Not sure whether this helps. But I think it could help
nevertheless:
- i) Logic Programming is the Egg
- ii) From the Egg Turtles or Chickens can hatch,
its very easy to program functionally or
procdurally in Prolog. Just add small DSLs:
https://en.wikipedia.org/wiki/Domain-specific_language
here is an example of a DSL for array manipulation,
and an implementation of Floyd Warshall algorithm:
:- op(100, yf, []).
:- op(800, fx, new).
:- op(800, fx, let).
:- op(800, fx, if).
warshall(N, D) :-
new D[N,N],
(between(1,N,U), between(1,N,V), let D[U,V] = 999, fail; true),
(edge(U,V,W), let D[U,V] = W, fail; true),
(vertex(V), let D[V,V] = 0, fail; true),
(between(1,N,K),
between(1,N,I),
between(1,N,J),
let H = D[I,K] + D[K,J],
(if D[I,J] > H -> let D[I,J] = H; true),
fail; true).
The definition of the DSL needs only one extension
of Prolog, i.e. nb_setarg/3 (SWI-Prolog) respectively
change_arg/3 (Dogelog Player):
new D[N,M] :-
functor(D, '', N),
D =.. [_|L],
new2(L, M).
new2([], _).
new2([X|L], N) :-
functor(X, '', N),
new2(L, N).
let V = E :- var(V), !,
let2(E,V).
let D[R,C] = E :-
let2(E,V),
arg(R, D, H),
nb_setarg(C, H, V).
let2(D[R,C], V) :- !,
arg(R, D, H),
arg(C, H, V).
let2(E+F, R) :- !,
let2(E, V),
let2(F, W),
R is V+W.
let2(V, V).
if E > F :-
let2(E, V),
let2(F, W),
V > W.
Idiot Prolog systems like Scryer Prolog or Trealla Prolog
refuse to provide such imperative gadgets, which are quite
useful. If you interpret the DSL, its already bleeing fast,
much faster than a pure implementation:
?- time((between(1,1000,_), graph(G),
floyd_warshall(4, G, M), fail; true)).
% 3,803,998 inferences, 0.156 CPU in 0.183 seconds (85% CPU, 24345587 Lips)
true.
?- time((between(1,1000,_), warshall(4,D), fail; true)).
% 1,046,998 inferences, 0.062 CPU in 0.062 seconds (100% CPU, 16751968 Lips)
true.
If you compile the DSL, you can again an itch more speed:
/* DSL compiled */
?- time((between(1,1000,_), warshall(4,D), fail; true)).
% 336,998 inferences, 0.000 CPU in 0.020 seconds (0% CPU, Infinite Lips)
true.
Bye
Just a side note, don't let you get distracted.
A side node about the chicken/egg problem, i.e.
without the curry:
- a) Eggs came first, for example Turtles had eggs
Turtles are part of an ancient reptilian
lineage ca 300 million years ago
- b) Chickens came after Turtles
Chickens, on the other hand, are much younger
in comparison, evolved from theropod dinosaurs
around 150 million years ago
Not sure whether this helps. But I think it could help
nevertheless:
- i) Logic Programming is the Egg
- ii) From the Egg Turtles or Chickens can hatch,
its very easy to program functionally or
procdurally in Prolog. Just add small DSLs:
https://en.wikipedia.org/wiki/Domain-specific_language
here is an example of a DSL for array manipulation,
and an implementation of Floyd Warshall algorithm:
:- op(100, yf, []).
:- op(800, fx, new).
:- op(800, fx, let).
:- op(800, fx, if).
warshall(N, D) :-
new D[N,N],
(between(1,N,U), between(1,N,V), let D[U,V] = 999, fail; true),
(edge(U,V,W), let D[U,V] = W, fail; true),
(vertex(V), let D[V,V] = 0, fail; true),
(between(1,N,K),
between(1,N,I),
between(1,N,J),
let H = D[I,K] + D[K,J],
(if D[I,J] > H -> let D[I,J] = H; true),
fail; true).
The definition of the DSL needs only one extension
of Prolog, i.e. nb_setarg/3 (SWI-Prolog) respectively
change_arg/3 (Dogelog Player):
new D[N,M] :-
functor(D, '', N),
D =.. [_|L],
new2(L, M).
new2([], _).
new2([X|L], N) :-
functor(X, '', N),
new2(L, N).
let V = E :- var(V), !,
let2(E,V).
let D[R,C] = E :-
let2(E,V),
arg(R, D, H),
nb_setarg(C, H, V).
let2(D[R,C], V) :- !,
arg(R, D, H),
arg(C, H, V).
let2(E+F, R) :- !,
let2(E, V),
let2(F, W),
R is V+W.
let2(V, V).
if E > F :-
let2(E, V),
let2(F, W),
V > W.
Idiot Prolog systems like Scryer Prolog or Trealla Prolog
refuse to provide such imperative gadgets, which are quite
useful. If you interpret the DSL, its already bleeing fast,
much faster than a pure implementation:
?- time((between(1,1000,_), graph(G),
floyd_warshall(4, G, M), fail; true)).
% 3,803,998 inferences, 0.156 CPU in 0.183 seconds (85% CPU, 24345587 Lips)
true.
?- time((between(1,1000,_), warshall(4,D), fail; true)).
% 1,046,998 inferences, 0.062 CPU in 0.062 seconds (100% CPU, 16751968 Lips)
true.
If you compile the DSL, you can again an itch more speed:
/* DSL compiled */
?- time((between(1,1000,_), warshall(4,D), fail; true)).
% 336,998 inferences, 0.000 CPU in 0.020 seconds (0% CPU, Infinite Lips)
true.
Bye