Use of =.. predicate to perform symbolic manipulation of furmulas in Prolog - prolog

Question

I am learning Prolog for an universitary university exam using SWI Prolog and I have some doubts about how it work this exercise that use the univ =.. =.. predicate to perform symbolic manipulation of furmulas formulas where a frequent operation is to substituite substitute some subexpression by another expression.
It is perform defining the following relation:
substituite(SubTerm, Term, SubTerm1, Term1)
that it is TRUE if Term1 rappresent represents Term expression in which all the occurrences of SubTerm are substituited by SubTerm1.
For example if I have:
substituite(sin(x), 2*(sin(x)), t, F).
Then: F = 2*t*f(t) because all the sin(x) occurrences are substituited by t
This is the solution (founbd on Bratko book) but I am not so sure about my interpretation:
% substitute( Subterm, Term, Subterm1, Term1)
% Term1 is Term with all occurrences (by matching)
% of Subterm are replaced by Subterm1.
% Test: ?- substitute( b, f(a,b,c), e, F).
% Test: ?- substitute( b, f(a,X,c), e, F).
% Test: ?- substitute( b, f(a,X,Y), e, F).
% Test: ?- substitute( a+b, f( a, A+B), v, F).
% Test: ?- substitute(b,B,e,F).
% Test: ?- substitute(b,b,e,F).
% Test: ?- substitute(b,a,e,F).
% Logic, there are three cases:
% If Subterm = Term then Term1 = Subterm1
% otherwise if Term is 'atomic' (not a structure)
% then Term1 = Term (nothing to be substituted)
% otherwise the substitution is to be carried
% out on the arguments of Term.
/* Case 1: SubTerm = Term --> SubTerm1 = Term1 */
substitute(Term, Term, Term1, Term1) :- !.
% Case 2: Se Term è atomico non c'è niente da sostituire
substitute( _, Term, _, Term) :- atomic(Term), !.
/* Case 3:
substitute(Sub, Term, Sub1, Term1) :-
Term =.. [F|Args], % Term è composto da: F è il FUNTORE PRINCIPALE ed Args è la lista dei suoi argomenti
substlist(Sub, Args, Sub1, Args1), % Sostituisce Sub1 al posto di Sub nella lista degli argomenti Args generando Args1
Term1 =.. [F|Args1]. % Term1 è dato dal FUNTORE PRINCIPALE F e dalla nuova lista degli argomenti Args1
/* sublist: sostituisce all'interno della lista degli argomenti: */
substlist(_, [], _, []).
substlist(Sub, [Term|Terms], Sub1, [Term1|Terms1]) :-
/* L'elemento in testa Term1 corrisponde all'eventuale sostituzione */
substitute(Sub, Term, Sub1, Term1),
/* Il problema è già risolto per le sottoliste e Terms1 rappresenta la sottolista Terms in cui tutte le occorrenze di Sub
sono già state sostituite con Sub1:
*/
substlist(Sub, Terms, Sub1, Terms1).
The first rule rappresent represents the particular case in which SubTerm = Term so the final Term1=SubTerm1 (because I substituite substitute whole term)
The second rule rappresent represents the particular case in which Term is an atom so, regardless of the values ​​of SubTerm and SubTerm1, I do not perform any substitution
I think that up to here it is simple and my reasoning it is correct...next to it begin the more difficult part and I am not so sure...
The rule:
substitute(Sub, Term, Sub1, Term1) :-
Term =.. [F|Args],
substlist(Sub, Args, Sub1, Args1),
Term1 =.. [F|Args1].
rappresent represents a generic case in which I have an expression rappresented represented by Term, its possible subexpression rappresented represented by Sub, a new subexpression Sub1 that eventually should be substituted when you meet an occurrence of Sub and the expression Term1 that rappresent Term expression in which all the occurrences of SubTerm are substituited by SubTerm1.
So I can read it declaratively in this whay way:
It is TRUE that Term1 rappresent represents Term expression in which all the occurrences of SubTerm are substituited by SubTerm1 if there are TRUE the following facts:
1) The original expression Term can be decomposed in a list that have in the head its main functor F (the first operator executed in the expression evalutation) and later a sublist Args that rappresent the arguments of this functor F (I think that, in some case, Args can contain also other functor that, in this computational step, don't are the main functor...so in these case there are still some subproblem to solve)
2) It is true that substlist(Sub, Args, Sub1, Args1) that means that this is true that Args1 rappresent Args in which all the argument equals to Sub subexpression are replaced by Sub1 subexpression.
3) Finally it must be true that the new Term1 is the result of the univ =.. predicate beetwen the main functor F and the new arguments list Args1 (I think that =.. recombine the main functor F with the new arguments list
To perfrom the substitution in the arguments list it is used the substlist relation that it is divided into:
A BASE CASE:
substlist(_, [], _, []).
that simply say: if there is nothing in the arguments list, there is nothing to replace
A GENERAL CASE:
substlist(Sub, [Term|Terms], Sub1, [Term1|Terms1]) :-
/* L'elemento in testa Term1 corrisponde all'eventuale sostituzione */
substitute(Sub, Term, Sub1, Term1),
/* Il problema è già risolto per le sottoliste e Terms1 rappresenta la sottolista Terms in cui tutte le occorrenze di Sub
sono già state sostituite con Sub1:
*/
substlist(Sub, Terms, Sub1, Terms1).
And this is the more difficult part to understand for me, I see it in the following way, declarative reading:
It is TRUE that [Term1|Terms1] rappresent the list of arguments [Term|Terms] in which all the Sub term are replaced by Sub1 if it is true that:
1) substitute(Sub, Term, Sub1, Term1): that means that it is TRUE that Term1 (the head of the new arguments list it is Term (the head of the old arguments list) in which if Term == Sub ---> Term1 == Sub1
2)substlist(Sub, Terms, Sub1, Terms1) that means all the subproblem are solved, I think that this is an important point because the argument list Term is the argument list of a current main functor F but can contain other sub functors inside it and each of these rappresent a subproblem that have to be solved befor perform the Sub-->Sub1 replacements in this step.
But I am not so sure about this last thing...
someone can help me to deeply understand it
Tnx
Andrea

Answer 1

Let me start by saying that it would be nice if you kept questions short and to the point. The whole idea of Stackoverflow is that questions and answers will be later useful to others, and writing good questions is a big part of this.
Moving on: All programming languages have some right to the claim that the actual source code of a program is the most clear, complete, and exhaustive explanation (to a human) of what the program does. Prolog definitely has a right to that claim. It takes a bit of getting used to, but soon a well-written predicate does tell more about the program logic than an often futile attempt to give a precise specification / definition in an inherently ambiguous natural language, be it English, Italian, or even German.
Now to your question...
What does =../2 do? We may look here, but, in a few words, we have f(a,b, ..., x) on the left side, and [f, a, b, ..., x] on the right side of it.
Assuming recursion, lists, matching and unification don't need to be explained here, the program you have extensively studied, commented in Italian, and thoroughly explained to us in English, does one simple thing: all occurrences of Subterm in Term are substituted by Subterm1 in Term1.
This is done:
by directly replacing simple terms (atoms) by matching
by breaking down complex terms (of the form f(Args)) into a list (using =..), and then applying the algorithm recursively on the simpler terms in that list (the elements of Args). Afterwords, the list is reassembled, using =.. again.
So if you have a nested term, you still get:
?- substitute(x, f( g( h(x,y,z), h(k,l,m) ), g(x,z) ), q, T).
T = f(g(h(q, y, z), h(k, l, m)), g(q, z)) ;
false.
The only slight difficulty one might encounter here is that substitute and substlist are mutually recursive. If this is giving you that much difficulty, one thing you can try and do is to remove all comments from the predicate definitions, fit the whole program on the screen at once (or print it out), and look at it and think about it until it makes sense. It works!