This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/packages/cplint/lemur/dv_lemur.pl

168 lines
5.9 KiB
Perl
Raw Normal View History

2014-10-15 14:15:46 +01:00
/*:- use_module(library(terms)).
*/
:- use_module(library(lists)).
/*define the depth of a variable appearing in a clause A B ^ : : : ^ Br as follows.
Variables appearing in the head of a clause have depth zero.
Otherwise, let Bi be the first literal containing the variable V, and let d be the maximal depth of the input variables of Bi
then the depth of V is d + 1. The depth of a clause is the maximal depth of any variable in the clause.
In questo modo possiamo lasciare il numero massimo di variabili a 4 (e cosi' impara la regola con taughtby) e riduciamo la profondita' massima delle variabili a 2 (in questo modo dovremmo imparare la regola con i due publication nel body e anche quella con taughtby).
Bisogna modificare revise.pl per controllare che gli atomi che si aggiungono nel body non abbiano variabili oltre la profondita' massima.
testa professor(_710033).
body taughtby(_710343,_710033,_710355).
Vars1 V1=_710033, V2=_710343, V3=_710355
testa professor(_710033).
body yearsinprogram(_710149,_710196).
Vars1 V1=_710033, V2=_710149, V3=_710196.
*/
:- op(500,fx,#).
:- op(500,fx,'-#').
%:-['graphics_train.l'].
%setting(maxdepth_var,1).
%funzionamento
%?- t(DV).
%DV = [[_A,1],[_B,0],[_C,0]] - lista di coppie [variabile,profondità massima]
t(DV):-% dv([advisedby(A,B)],[taughtby(C,B,D),ta(C,A,D)],DV).
dv([advisedby(A,B)],[publication(C,B),publication(C,A),professor(B),student(A)],DV).
% dv([professor(A)],[taughtby(B,A,C),taughtby(D,A,E),taughtby(D,A,E)],DV). %max_var 5
dv(H,B,DV1):- %-DV1
term_variables(H,V),
head_depth(V,DV0),
findall((MD-DV),var_depth(B,DV0,DV,0,MD),LDs), % cerchiamo tutte le possibili liste di coppie var-prof che si possono generare in base alle scelte del modeb e poi prendiamo la lista che porta al massimo della profondita' massima
get_max(LDs,-1,-,DV1).
input_variables_b(LitM,InputVars):-
LitM=..[P|Args],
length(Args,LA),
length(Args1,LA),
Lit1=..[P|Args1],
modeb(_,Lit1),
input_vars(LitM,Lit1,InputVars).
/* decommentare per testare il file da solo */
/* input_vars(Lit,Lit1,InputVars):-
Lit =.. [_|Vars],
Lit1 =.. [_|Types],
input_vars1(Vars,Types,InputVars).
input_vars1([],_,[]).
input_vars1([V|RV],[+_T|RT],[V|RV1]):-
!,
input_vars1(RV,RT,RV1).
input_vars1([_V|RV],[_|RT],RV1):-
input_vars1(RV,RT,RV1).
*/
depth_var_head(List,VarsD):- % exit:depth_var_head([professor(_G131537)],[[_G131537,0]]) ?
term_variables(List,Vars0), %List = lista atomi testa, Vars0 = lista variabili estratte dalla testa (term_variables _710033,_710237,_711016,_710969).
head_depth(Vars0,VarsD). %aggiunge la profondità 0 ad ogni variabile, creando sottoliste
head_depth([],[]).
head_depth([V|R],[[V,0]|R1]):-
head_depth(R,R1).
/*
depth_var_body(VarsH,BL,VarsD):-
term_variables(List,Vars0), %estrae la lista Vars0 di variabili degli atomi del body in List
exclude_headvar(VarsH,Vars0,VarsB), %VarsB: lista variabili v nel body per cui calcolare d(v) - diverse da quelle nella testa per cui vale 0 (Z,W,R)
set_Uv(VarsB,BL,Sets), %Sets: a ogni var v in VarsB associa il set U_v delle var!=v: lista di liste [v,(set)]
max(Sets,VarsH,VarsD). %VarsD: a ogni var v associa la profondità, usando le variabili nella testa VarsH che hanno d=0 (crea tuple (v,d))
*/
var_depth([],PrevDs1,PrevDs1,MD,MD):-!.
var_depth([L|R],PrevDs,PrevDs1,_MD,MD):- %L=body atom
% MD e' la profondita' massima a cui si e' arrivati
input_variables_b(L,InputVars), %variabili di input nell'atomo L
% write(L),format("~n variabili di input:",[]),write_list(InputVars), %L=letterale del body=ta(_710237,_710858,_711331) InputVars = variabili di input nel letterale=_710237,_710858.
term_variables(L, BodyAtomVars), %BodyAtomVars: estrae dal letterale Lit del body la lista di variabili
output_vars(BodyAtomVars,InputVars,OutputVars), %OutputVars = BodyAtomVars-InputVars
depth_InputVars(InputVars,PrevDs,0,MaxD), %MaxD: massima profondita' delle variabili di input presenti nel letterale
D is MaxD+1,
compute_depth(OutputVars,D,PrevDs,PrevDs0), %Ds: lista di liste [v,d] per tutte le variabili (assegna D a tutte le variabili)
% term_variables(PrevLits,PrevVars), %PrevVars: lista variabili nella testa
% write(BodyD),
% PrevDs1 = [BodyD|PrevDs].
var_depth(R,PrevDs0,PrevDs1,D,MD).
get_max([],_,Ds,Ds).
get_max([(MD-DsH)|T],MD0,_Ds0,Ds):-
MD>MD0,!,
get_max(T,MD,DsH,Ds).
get_max([_H|T],MD,Ds0,Ds):-
get_max(T,MD,Ds0,Ds).
output_vars(OutVars,[],OutVars):-!.
output_vars(BodyAtomVars,[I|InputVars],OutVars):- %esclude le variabili di input dalla lista di var del letterale del body
delete(BodyAtomVars, I, Residue), %cancella I da BodyAtomVars
output_vars(Residue,InputVars, OutVars).
% restituisce in D la profondita' massima delle variabili presenti nella lista passata come primo argomento
depth_InputVars([],_,D,D).
depth_InputVars([I|Input],PrevDs,D0,D):-
member_l(PrevDs,I,MD),
(MD>D0->
D1=MD
;
D1=D0
),
depth_InputVars(Input,PrevDs,D1,D).
member_l([[L,D]|P],I,D):- %resituisce in output la profondita' della variabile I
I==L,!.
member_l([_|P],I,D):-
member_l(P,I,D).
compute_depth([],_,PD,PD):-!. %LVarD
compute_depth([O|Output],D,PD,RestO):- %LVarD
member_l(PD,O,_),!, % variabile gia' presente
compute_depth(Output,D,PD,RestO).
compute_depth([O|Output],D,PD,[[O,D]|RestO]):- %LVarD
compute_depth(Output,D,PD,RestO).
%Otherwise, let Bi be the first literal containing the variable V, and let d be the maximal depth of the input variables of Bi: then the depth of V is d+1. The depth of a clause is the maximal depth of any variable in the clause.
%
%[[_A,1],[_B,0],[_C,0]]
exceed_depth([],_):-!.
exceed_depth([H|T],MD):-
nth1(2,H,Dep), %estrae la profondità
%setting(maxdepth_var,MD),
% (Dep>=MD ->
% format("*****************depth exceeded ~n")
% ;
% true
% ),
Dep<MD,
exceed_depth(T,MD).