Prolog "cyclic"

         
/**
* Warranty & Liability
* To the extent permitted by applicable law and unless explicitly
* otherwise agreed upon, XLOG Technologies AG makes no warranties
* regarding the provided information. XLOG Technologies AG assumes
* no liability that any problems might be solved with the information
* provided by XLOG Technologies AG.
*
* Rights & License
* All industrial property rights regarding the information - copyright
* and patent rights in particular - are the sole property of XLOG
* Technologies AG. If the company was not the originator of some
* excerpts, XLOG Technologies AG has at least obtained the right to
* reproduce, change and translate the information.
*
* Reproduction is restricted to the whole unaltered document. Reproduction
* of the information is only allowed for non-commercial uses. Selling,
* giving away or letting of the execution of the library is prohibited.
* The library can be distributed as part of your applications and libraries
* for execution provided this comment remains unchanged.
*
* Restrictions
* Only to be distributed with programs that add significant and primary
* functionality to the library. Not to be distributed with additional
* software intended to replace any components of the library.
*
* Trademarks
* Jekejeke is a registered trademark of XLOG Technologies AG.
*/
:- ensure_loaded(library(hiord)).
/**
* term_minimal(X, T):
* The predicate succeeds in T with a minimized identical replica of
* the term X. Knuth Algorithm E with (==)/2 and not showing loops.
*/
% term_minimal(+Term, -Term)
term_minimal(X, Y) :- acyclic_term(X), !,
Y = X.
term_minimal(X, Y) :-
sys_term_minimal(X, Y, [], _).
% sys_term_minimal(+Term, -Term, +List, -List)
sys_term_minimal(X, Z, L, L) :- compound(X),
member(Y-Z, L), X == Y, !.
sys_term_minimal(X, Y, L, R) :- compound(X), !,
X =.. [F|P],
foldl(sys_term_minimal, P, Q, [X-Y|L], R),
Y =.. [F|Q].
sys_term_minimal(X, X, L, L).
/**
* term_decompose(X, T):
* The predicate succeeds in T with an acyclic representation of
* the term X. Knuth Algorithm E with same_term/2 and showing loops.
*/
% term_decompose(+Term, -List)
term_decompose(X, R) :- acyclic_term(X), !,
R = [X].
term_decompose(X, R) :-
ir_list_decompose([X], R).
/*******************************************************************/
/* Top-Level Support */
/*******************************************************************/
/**
* map_compact(L, R):
* The predicate succeeds in R with the portrayed, decomposed and
* compacted substitution list L. Portraying provides both
* minimization and user-friendly forms.
*/
% map_compact(+Map, -Map)
map_compact(L, R) :-
foldl(sys_portray_term, L, H, [], _),
maplist(sys_subst_clobber, H, I),
ir_list_decompose(I, J),
sys_subst_inline(J, J, K),
maplist(sys_subst_upheld, K, R).
% sys_subst_inline(+Map, +Map, -Map)
sys_subst_inline([], _, []).
sys_subst_inline([V=T|L], M, [V=S|R]) :- compound(T), !,
T =.. [F|P],
maplist(sys_subst_common(M), P, Q),
S =.. [F|Q],
sys_subst_inline(L, M, R).
sys_subst_inline([X|L], M, [X|R]) :-
sys_subst_inline(L, M, R).
% sys_subst_common(+Map, +Term, -Term)
sys_subst_common(M, T, V) :- compound(T),
member(V=S, M), S == T, !.
sys_subst_common(M, T, S) :- compound(T), !,
T =.. [F|P],
maplist(sys_subst_common(M), P, Q),
S =.. [F|Q].
sys_subst_common(_, T, T).
% sys_subst_clobber(+Pair, -Pair)
sys_subst_clobber(V=T, X) :- acyclic_term(T), !, X = '$LET'(V,T).
sys_subst_clobber(X, X).
% sys_subst_upheld(+Map, -Map)
sys_subst_upheld('$LET'(V,T), X) :- !, X = (V=T).
sys_subst_upheld(X, X).
/*******************************************************************/
/* Foreign Predicates */
/*******************************************************************/
% unify_with_occurs_check(S, T): [ISO 8.2.2]
% defined in foreign(fastlib)
% occurs_check(S, T): [ISO 7.3.3]
% defined in foreign(fastlib)
% acyclic_term(T): [TC2 8.3.11]
% defined in foreign(hoplib)
% ir_list_decompose(L, R):
% defined in foreign(hoplib)
:- ensure_loaded(foreign(hoplib)).