Meta-Programming

cs774 (Prasad) L11MetaPgm 1

Meta-Programming

[email protected]

http://www.knoesis.org/tkprasad/

mailto:[email protected]

Meta-Programs : Program manipulating Programs

• Extend Prolog– introduce new search strategy or modify

existing search strategy– add expressive logical connective– extend/modify syntax/semantics

• Enable Debugger

• Support Theorem Provers and Rule-based Systems


Basic Meta-Interpreterprove( true ) :- !.

prove( (G1, G2) ) :- !,

prove(G1), prove(G2).

prove( G ) :-

system(G), G.

prove( G ) :-

clause(G,B), prove(B).

• System-predicate holds of built-ins.cs774 (Prasad) L11MetaPgm 3

Upgrading the Meta-Interpreter• Adding an or-operatorprove( (G1 ; G2) ) :-

prove(G1).

prove( (G1 ; G2) ) :-

prove(G2). • Changing the order of evaluation from right to left

prove( (G1, G2) ) :- !,

prove(G2), prove(G1).


Tracing Basic Meta-Interpretertracep( Goal ) :-

tracep(Goal, 0).

tracep( true, Dpth ) :- !.

tracep((G1, G2),Dpth ):-!,

tracep(G1, Dpth), tracep(G2, Dpth).


(cont’d)tracep( G, D ) :-

display(’Call:’, G, D),

clause(G,B),

D1 is D+1,

tracep(B, D1),

display(’Exit:’, G, D),

display_redo(G, D).

tracep( G, D ) :-

display(’Fail:’, G, D), fail.


(cont’d)display( Msg, G, D ) :-

tab(D), write(Msg),

write(G), nl.

display_redo( G, D ) :-

true

;

display(’Redo:’, G, D), fail.


(Trace Output)4 ?- tracep(member(5,[1,5,3])).

Call:member(5, [1, 5, 3])

Call:member(5, [5, 3])

Exit:member(5, [5, 3])

Exit:member(5, [1, 5, 3])

true ;

Redo:member(5, [1, 5, 3])

Redo:member(5, [5, 3])

Call:member(5, [3])

Call:member(5, [])

Fail:member(5, [])

Fail:member(5, [3])

Fail:member(5, [5, 3])

Fail:member(5, [1, 5, 3])

false.


Other AI Applications

• Forward chaining or Bottom-up computation

• From facts to all conclusions

• Heuristic search (incl. breadth-first search)

• Diagnosis; Explanation generation• Determine the set of facts, which when assumed,

proves the goal

• Abductive reasoning


Meta-level Definition

not(A) :- call(A), !, fail.

not(A).• Meta-variables range over terms encoding a

goal.

?-setof(X, G, L).• X and L are object variables, while G is

meta-variable.


Program Manipulation Example

• Write a meta-program to collect all variables in a formula A.

constant(A) :-

atom(A); integer(A) ; float(A).

collect_var(A,Q-Q) :-

constant(A).

collect_var(A,[A|Q]-Q) :-

var(A).cs774 (Prasad) L11MetaPgm 11

(cont’d)collect_var(A,Q) :-

A =.. [P|As],

collect_vars(As,Q).

collect_vars([],Q-Q) :- !.

collect_vars([A|As], Q-Qt) :-

collect_var(A, Q-Qs),

collect_vars(As, Qs-Qt).

?-collect_var(p(X,Y), L).

L= [X,Y| _1]-_1• Difference lists for efficient appendcs774 (Prasad) L11MetaPgm 12

Theorem Proving Applications and others

• Proving equivalence of boolean expressions, arithmetic expressions, etc

• Normalization of expressions

• Refutation theorem proving

• Goal reordering based on binding information for efficient execution of query

• Pretty Printing


Equational Reasoning: Example• Prove two terms are equivalent given that the operators

satisfy certain equality constraints.

• Associativity:

(a + b) + c = a + (b + c)

(a * b) * c = a * (b * c)• Commutativity:

(a + b) =(b + a)

(a * b) =(b * a)

• cs774 (Prasad) L11MetaPgm 14

(cont’d)• Identity:

(a + 0) = a = (0 + a)

(a * 1) = a = (1 * a)• Zero:

(a * 0) = 0 = (0 * a)• Distributive Law:

(a + b) * c =(a * c + b * c)


Digression : Normal Form

• Equality constraints induce an equivalence relation on terms (e.g., arithmetic expressions)

• An equivalence relation partitions the set of terms into equivalence classes

• A normal form of a term is the representative of the equivalence class to which the term belongs.


Normalization Procedure

• Associative operation : Ignore nestings– collapse term trees to lists

• Commutative operation : Ignore order– sort

• Zeros and Identities– simplify + delete elements

• Distributivity– sum of products form or product of sums form


Application

• Evaluation of a variable-free/constant arithmetic expression is normalization.

2 + 3 => 5

(1 + (1 + 2) + 1) => 5• Equality constraints given by axioms are

used as rewrite rules for normalization.– Definition of primitive operations– Relationship among operations


An Interpreter for Object-Oriented Programs

• Class Definition

object(Object, Methods)

E.g., object(rectangle(Len,Wid), [(area(A) :- A is Len * Wid)]

).


class-name +

instance variablesmessage method

(cont’d)• object/instance

rectangle(5,10)• passing a message

send(Object-instance, Message)

E.g.,

send(rectangle(5,10),area(A)).• specifying class-subclass hierarchy

E.g.,isa(square(sd),rectangle(sd,sd)).


Interpreter Codesend( Object, Message) :- get_methods( Object, Methods),

process( Message, Methods). % Find Object's methods

% Execute corresponding method

get_methods( Object, Methods) :- object( Object, Methods). % Private methods

get_methods( Object, Methods) :- isa( Object, Super),

get_methods( Super, Methods).% Inherited methods


(cont’d)

process( Msg, [Msg | _]).

% Use a fact

process( Msg, [ (Msg :- Body) | _]) :- call( Body).

% Use a rule

process( Msg, [_ | Methods]) :-

process( Msg, Methods).


?- trace, send(square(4), area(A)).

Call: (7) send(square(4), area(_G414)) ? creep

Call: (8) get_methods(square(4), _G551) ? creep

Call: (9) object(square(4), _G551) ? creep

Fail: (9) object(square(4), _G551) ? creep

Redo: (8) get_methods(square(4), _G551) ? creep

Call: (9) isa(square(4), _G551) ? creep

Exit: (9) isa(square(4), rectangle(4, 4)) ? creep

Call: (9) get_methods(rectangle(4, 4), _G554) ? creep

Call: (10) object(rectangle(4, 4), _G554) ? creep

Exit: (10) object(rectangle(4, 4), [ (area(_G555):-_G555 is 4*4)]) ? creep

Exit: (9) get_methods(rectangle(4, 4), [ (area(_G555):-_G555 is 4*4)]) ? creep

Exit: (8) get_methods(square(4), [ (area(_G555):-_G555 is 4*4)]) ? creep

Call: (8) process(area(_G414), [ (area(_G555):-_G555 is 4*4)]) ? creep

Call: (9) _G414 is 4*4 ? creep

Exit: (9) 16 is 4*4 ? creep

Exit: (8) process(area(16), [ (area(16):-16 is 4*4)]) ? creep

Exit: (7) send(square(4), area(16)) ? creep

A = 16 .


Meta-Programming

Documents

Transcript of Meta-Programming