Como se ejecutan los automatas en Prolog

Este es el código con las funciones de transición y transición extendida para los automátas finitos deterministas, no deterministas y con transiciones de cadenas vacías.

% hola.pl
% programa Prolog para probar automatas
%
% escrito en clase como ejemplo

delta(q0,h,q1).
delta(q1,o,q2).
delta(q2,l,q3).
delta(q3,a,q4).
delta(q4,a,q4).
delta(q0,h,q5).
delta(q5,i,q6).

delta_techo(E0,[A],Ef) :- delta(E0,A,Ef).
delta_techo(E0,[A|W], Ef):-
    delta(E0,A,Ei), delta_techo(Ei,W, Ef).

% de acuerdo al texto de la prof. H. Yelitza Contreras

% autómata finito determinista

delta_t(Q0, [A|W], Qf) :-
    delta(Q0, A, Q1), delta_t(Q1, W, Qf).
delta_t(Q, [], Q).

% autómata finito no determinista

% así se escribiría el ejemplo anterior
%delta_n(q0,h,[q1,q5]).
%delta_n(q1,o,[q2]).
%delta_n(q2,l,[q3]).
%delta_n(q3,a,[q4]).
%delta_n(q5,i,[q6]).

%
delta_n(q0, 0, [q0,q1]).
delta_n(q0, 1, [q0]).
delta_n(q1, 1, [q2]).

delta_n([], _, []).
delta_n([Qo|R], A, RR) :-
    not(delta_n(Qo, A, _)), delta_n(R, A, RR).
delta_n([Qo|RQs], A, S) :-
    delta_n(Qo, A, Qss),
    delta_n(RQs, A, NQs), une(Qss, NQs, S).

delta_t_nd_inicia(Q, W, F) :- delta_t_nd([Q], W, F).

delta_t_nd(Qs, [], Qs).
delta_t_nd(Q0s, [A|W], QsF) :-
    delta_n(Q0s, A, Qsigs), delta_t_nd(Qsigs, W, QsF).

une([], A, A).
une([U|X], Y, [U|Z]) :- not(pertenece(U,Y)), une(X,Y,Z).
une([U|X], Y, Z) :- pertenece(U,Y), une(X,Y,Z).

pertenece(E,[E|_]).
pertenece(E,[_|R]) :- pertenece(E,R).

% autómata finito no determinista con transiciones lambda

% la definicion de lambda_clausura

lambda_clausura(Q, Clausura) :-
    delta_l(Q,'\lambda', Ps),
    lambda_clausura_lista(Ps, Clausura_de_Ps),
    une([Q], Ps, Pss), une(Pss, Clausura_de_Ps, Clausura).
lambda_clausura(Q, [Q]) :- atom(Q).

lambda_clausura_lista([Q], C) :- lambda_clausura(Q,C), !.
lambda_clausura_lista([P|RPs], Clausura ):-
    lambda_clausura(P, Clausura_de_P),  
        lambda_clausura_lista(RPs, Clausura_Resto),
    une(Clausura_de_P, Clausura_Resto, Clausura).

% modifica los métodos de delta_t_nd para usar lambda_clausura

delta_t_l_inicia(Q, W, F) :- delta_t_l([Q], W, F).

delta_t_l(Qs, [], Qs).
delta_t_l(Q0s, [A|W], Clausura) :-
    lambda_clausura_lista(Q0s, Clausura_Q0s),
    delta_l(Clausura_Q0s, A, Qsigs),
    delta_t_l(Qsigs, W, QsF),
        lambda_clausura_lista(QsF, Clausura).

delta_l([], _, []).
delta_l([Qo|R], A, RR) :-
    not(delta_l(Qo, A, _)),
    delta_l(R, A, RR).
delta_l([Qo|RQs], A, S) :-
    delta_l(Qo, A, Qss), delta_l(RQs, A, NQs),
    une(Qss, NQs, S).


% representa el automata con transiciones de cadena vacía

delta_l(q0, 0, [q0]).
delta_l(q0, '\lambda', [q1]).
delta_l(q1, 1, [q1]).
delta_l(q1, '\lambda', [q2]).
delta_l(q2, 2, [q2]).

% salida del ejemplo en la figura 2.8
%
%[debug]  ?- delta_t_l_inicia(q0, [0,2], L).
%   Call: (8) delta_t_l([q0], [0, 2], _G391) ? leap
%   Call: (9) lambda_clausura_lista([q0], _G474) ? leap
%   Call: (11) lambda_clausura_lista([q1], _G477) ? leap
%   Call: (13) lambda_clausura_lista([q2], _G480) ? leap
%   Exit: (13) lambda_clausura_lista([q2], [q2]) ? leap
%   Exit: (11) lambda_clausura_lista([q1], [q1, q2]) ? leap
%   Exit: (9) lambda_clausura_lista([q0], [q0, q1, q2]) ? leap
%   Call: (9) delta_t_l([q0], [2], _G552) ? leap
%   Call: (10) lambda_clausura_lista([q0], _G551) ? leap
%   Call: (12) lambda_clausura_lista([q1], _G554) ? leap
%   Call: (14) lambda_clausura_lista([q2], _G557) ? leap
%   Exit: (14) lambda_clausura_lista([q2], [q2]) ? leap
%   Exit: (12) lambda_clausura_lista([q1], [q1, q2]) ? leap
%   Exit: (10) lambda_clausura_lista([q0], [q0, q1, q2]) ? leap
%   Call: (10) delta_t_l([q2], [], _G629) ? leap
%   Exit: (10) delta_t_l([q2], [], [q2]) ? leap
%   Call: (10) lambda_clausura_lista([q2], _G628) ? leap
%   Exit: (10) lambda_clausura_lista([q2], [q2]) ? leap
%   Exit: (9) delta_t_l([q0], [2], [q2]) ? leap
%   Call: (9) lambda_clausura_lista([q2], _G391) ? leap
%   Exit: (9) lambda_clausura_lista([q2], [q2]) ? leap
%   Exit: (8) delta_t_l([q0], [0, 2], [q2]) ? leap
% L = [q2] .


% fin del programa