Prolog递归方括号

Question

Given the code below, I am trying to call the last rule: trans([[p],[q],[r]]).

This should then recursively call trans([P]), write, trans([P],[Q]]).

However it appears to be calling trans([P]), write, trans([P,Q]).

Is there a way to override the reserved square bracket? Is there a better way to enable the recursion?

trans([P]) :- atom(P), write(P).
trans([~P]) :- write('Not '), trans([P]).

trans([P,Q]) :- trans(P), write(' or '), trans(Q).
trans([P,Q,R]) :- trans([P]), write(' or '), trans([Q,R]).
trans([P,Q,R,S]) :- trans([P]), write(' or '), trans([Q,R,S]).


trans([[P],[Q]]) :- trans([P]), write(' and '), trans([Q]).
trans([[P,Q],[R]]) :- trans([P,Q]), write(' and '), trans([R]).
trans([[P],[Q,R]]) :- trans([P]), write(' and '), trans([Q,R]).
trans([[P,Q],[R,S]]) :- trans([P,Q]), write(' and '), trans([R,S]).

trans([[P],[Q],[R]]) :- trans([P]), write(' and '), trans([[Q],[R]]).

Terminal Output:

?- trans([[p],[q],[r]]).
p and q or r
true ;
q and r
true .

Answer 1

Perhaps something like this. There's a bit of splitting out of clauses to make the parenthesis come out nice.

% Handle the top, conjunction level

trans([H]) :-                  % A single atomic conjunctive term
    atom(H), write(H).
trans([H]) :-                  % A single non-atomic conjunctive term
    trans_dis(H).
trans([H1,H2|T]) :-            % Multiple conjunctive terms
    trans_conj([H1,H2|T]).

trans_conj([H1,H2|T]) :-       % Multiple conjunctive terms
    trans_conj([H1]), write(' and '), trans_conj([H2|T]).
trans_conj([H]) :-             % Single atomic conjunctive term
    atom(H), write(H).
trans_conj([[H]]) :-           % Last conjunctive term, single disjunction
    trans_dis([H]).
trans_conj([[H1,H2|T]]) :-     % Last conjunctive term, multiple disjunctions
    write('('), trans_dis([H1,H2|T]), write(')').

% Handle the disjunctions level

trans_dis([H]) :-              % Single disjunctive term
    atom(H), write(H).
trans_dis([~H]) :-             % Single negated disjunctive term
    atom(H), write('not '), write(H).
trans_dis([H1,H2|T]) :-        % Multiple disjunctive terms
    trans_dis([H1]), write(' or '), trans_dis([H2|T]).

Some test results:

| ?- trans([p]).
p

true ? a

no
| ?- trans([[p]]).
p

true ? a

no
| ?-  trans([p,q]).
p and q

true ? a

no
| ?-  trans([[p,q]]).
p or q

true ? a

no
| ?-  trans([[p],[q]]).
p and q

true ? a

no
| ?- trans([[p,r],[q]]).
(p or r) and q

true ? a

no
| ?- trans([[p,r],[q,s]]).
(p or r) and (q or s)

| ?- trans([[a,~b,c],[d,e],[f]]).
(a or not b or c) and (d or e) and f

true ? a

(1 ms) no

Answer 2

You query:

?- trans([[p],[q],[r]]).

gets instantiated with

trans([P,Q,R]) :- trans([P]), write(' or '), trans([Q,R]).

(or: the 4th clause of trans/1 ). You want it to instantiate with

trans([[P],[Q],[R]]) :- trans([P]), write(' and '), trans([[Q],[R]]).

(or: the 10th clause of trans/1 ).

The reason why this happens is that trans([[p],[q],[r]]) unifies with [P,Q,R] according to the following substitution: P = [p] , Q = [q] , and R = [r] .

Proper use of recursion

Your code looks a little verbose for Prolog code. I therefore give a possible rewrite here that uses recursion proper.

Instead of:

trans([P,Q]) :- trans(P), write(' or '), trans(Q).
trans([P,Q,R]) :- trans([P]), write(' or '), trans([Q,R]).
trans([P,Q,R,S]) :- trans([P]), write(' or '), trans([Q,R,S]).

you can also write:

trans([]).
trans([H|T]):-
  trans(H),
  trans(T).

... and that works for any list argument that is given to trans/1 .

Distinguish disjunction from conjunction

You are not making the distinction between conjunction and disjunction correctly yet, you may want to try out:

trans(and([]).
trans(and([H])):-
  trans(H).
trans(and([H|T])):-
  trans(H),
  write(' and '),
  trans(and(T)).

trans(or([])).
trans(or([H])):-
  trans(H).
trans(or([H|T])):-
  trans(P),
  write(' or '),
  trans(or(T)).