[Prolog] esercizio clausole di horn

[exzR]

ciao a tutti, ho trovato questo esercizio di Prolog, ho letto che non si possono richiedere le soluzioni complete degli esercizi, pero' vorrei chiedere una mano a capire in che direzione andare per farlo. l'esercizio è questo

Supponete di avere una rappresentazione di clausole in forma normale congiunta in Prolog.

and ([or(...), or(...), or(...), ..., or(...)])

dove ogni or contiene una lista di letterali positivi della forma p o q (...) o negativi della forma not(P) o not(Q[...]).

Scrivere un predicato horn che è vero se la fbf ha tutti gli or che sono clausole di Horn.


Esempi:
horn(and([or(p)])).
true

horn(and[]).
true

horn(and([or([not(p)]))])).



è un'esercizio di un vecchio tema d'esame che sto cercando di risolvere in vista di un nuovo appello.

oltre che dichiarare i primi predicati dicendo che
horn(and([]) :- true.
horn(or([])) :- true.

non riesco a capire come fare riconoscere le or in modo ricorsivo (suppongo utilizzando la lista nel formato [X | Xs] dove X è la testa e Xs la coda).

Ripeto, non importa la soluzione ma vorrei soltanto capire in che direzione mandare i miei sforzi per risolvere tale problema, dato che essendo un esercizio da esame scritto, non dovrebbero essere troppe righe di codice.

grazie mille a tutti

[oNaSsIs]

Premesso che in Prolog sono piuttosto arrugginito, però non credo ci sia molto da aggiungere. Nel senso che tu stesso hai indicato la strada da seguire. Dovresti scorrere in maniera ricorsiva la lista e questo puoi farlo nel seguente modo.

and([]).
and([or(_)|Xs]) :- and(Xs).
Così facendo scorri la lista finché non arrivi alla fine oppure incontri un predicato diverso dall'or. Nel primo caso ottieni True, mentre nel secondo False.

Per assicurarti che l'or() contenga solo atomi oppure not() devi complicare leggermente le cose.

[exzR]

ciao, intanto grazie mille, non so perchè ma trovo proprio difficile programmare con la logica di lisp e delle unificazioni...
per ora ho modificato leggerme il codice e sto andando avanti. grazie mille per l'aiuto

horn(and([])).
horn(or([])).
horn(not([])).

horn(and([or(_) | Xs])) :-
atomic(Xs),
not(Xs),
horn(and(Xs)).

[oNaSsIs]

Figurati. Comunque hai ancora da lavorare, il codice che hai postato presenta ancora degli errori. ;)