标签：apple T2 list Syntax fruit location Basic kitchen Prolog

1. Run Prolog

file name: test.pl
go to the location of the test.pl in terminal
input swipl
input [test].(remember '.')
do sth
if you want to halt the file, input halt

e.g.

2. Facts

comment: type '%': % This is the syntax for comments
facts
1. fact: pred(arg1, arg2, ..., argn).
2. arg: integer, atom, string begin with lower letter etc
3. variable: item begin with '_' or UPPER LETTER, structure etc
4. e.g.
```
father('David', 'John').    % remember '.' at the end 
room(a).
```

3. Simple Query

?-: the prompt for the interpreter
query: type pred(something)
1. if exist answer, return the answer; if you want more answer, type ;
2. e.g.
```
room(a).
room(b).
```
query principle inside
1. prolog will match user's target to find the answer; when input ;, it will redo (release the variable first and start the search from the last token)
2. prolog's target has four ports to control the processes
  1. call: find the clause
  2. exit: target matched successfully, mark the success clause, and bind the variable
  3. redo: release the variable first and start the search from the last token
  4. fail: can not find more success clause
debug: input debug
trace: input trace
- e.g.
```
room(a).
room(b).
room(c).
```

4. Hybrid Query

hybrid query: input more query like:

location(apple, kitchen).
location(trash, kitchen).
edible(apple).

some interval predicate
1. write(1 arg): print some string
2. nl: print an enter
3. tab(1 arg: n): print n \space
- e.g.
  here is the trace

5. Rules

rule: head :- body, head is predicate, :- means "if", body is target

e.g.

location(apple, kitchen).
location(trash, kitchen).
edible(apple).

where_food(X, Y) :- location(X, Y), edible(X).

result:

append more rules: we can append more rules to define a predicate

e.g.

location(apple, kitchen).
location(burger, kitchen).
location(trash, kitchen).
edible(apple).
yummy(burger).
where_food(X, Y) :- location(X, Y), edible(X).
where_food(X, Y) :- location(X, Y), yummy(X).

rules basic principle: in fact rules are multiple layers of query. we can see the trace of last instance:

6. Arithmetic

math expression: X is expression
operation
1. +, -, *, /
2. >, <, >=, =<
use in rules
- e.g.
```
c_to_f(C, F) :- F is C * 9 / 5 + 32.
```

7. Data Management

asserta & assert
1. asserta(X): it will append X to the beginning of the dynamic database
2. assert(X): it will append X to the end of the dynamic database
3. dynamic pred/arg_size: if you want to use asserta & assert, please type dynamic pred/arg_size to run at the front of the program, which allows pred can be modified dynamically
- e.g.
```
fruit(apple).
fruit(watermelon).
```
retract(X): remove X from dynamic database(remember dynamic)

use in rules

fruit(apple).
fruit(watermelon).
fruit(tomato).

is_fruit(X) :- fruit(X).
is_fruit(X) :- write('NO FRUIT NOW!'), nl, fail.

remove(X) :- retract(fruit(X)).

8. Recursion

recursion:

e.g.

location(envelope, desk).
location(stamp, envelope).
location(key, envelope).

is_contained_in(T1, T2) :- location(T1, T2).
is_contained_in(T1, T2) :- location(X, T2), is_contained_in(T1, X).

recursion basic principle
Which is faster?
1. is_contained_in(T1,T2):- location(X,T2), is_contained_in(T1,X).
2. is_contained_in(T1,T2):- location(T1,X), is_contained_in(X,T2).
- if we ask is_contained_in(X, desk), 1. is faster!

9. Unification

unification
1. variable & any items
2. original item & original item(atom or integer): when they equal
3. structure & structure: when each corresponding parameter of two structures can be associated
= (arg1, arg2) or arg1 = arg2
1. notice: = is Unification
2. e.g.
3. variable unification
4. if the values of the variables conflict in both bindings, it will fail
5. anonymous variable _: it will not bind any values
difference between unification and math expression: unification will not compute, but is will do

10. Data Structure

structure: functor(arg1, arg2, ...)

% object(name, color, size, amount)
location(object(candle, red, small, 1), kitchen).
location(object(apple, red, small, 1), kitchen).
location(object(apple, green, small, 1), kitchen).
location(object(table, blue, big, 50), kitchen).

nested structure

location(object(table, blue, dimension(1, 2, 3), 50), kitchen).

11. List

List: [obj1, obj2, ...]

empty list: [] or nil

% loc_list(nil, hall).
loc_list([], hall).
loc_list([apple, banana, orange], kitchen).

head and tail
1. [a|[b, c, d]] = [a, b, c, d], a is head, [b ,c ,d] is tail. we use | to divide them, behind | is a list
2. we can use | at other place
3. nil can not match [H|T], which can be used in recursion bounds checking
4. list basic principle: '[|]'(head, tail) = (head | tail), in fact | is a predicate; we can use display() to see it.

member(obj, list)

we can use member to see obj is in the list or not.

member basic principle

member(H, [H | T]).   % in head ?
member(X, [H | T]) :- member(X, T).   % in tail ?

append(list1, list2, dest)
1. connect list1 and list2 to be a new list dest
2. append basic principle
```
append([], X, X).
append([H | T1], X, [H | T2]) :- append(T1, X, T2).
```
  see how to split a list
findall(result, target, result_list): find all elements in target mode and store them in result_list in result mode
```
fruit(apple).
fruit(banana).
```

12. Operator

math operator
operator
1. infix: 3 + 10
2. prefix: -13
3. postfix: 8 factorial

operator precedence

precedence value: 1 ~ 1200
value smaller, priority bigger
op(value, fix, name_of_operator)

fix	`name`	trait
Infix	`xfx`	non-associative
Infix	`xfy`	right to left
Infix	`yfx`	left to right
Prefix	`fx`	non-associative
Prefix	`fy`	left to right
Postfix	`xf`	non-associative
Postfix	`yf`	right to left

: operator
```
obj(apple, size: small, color: red).
```

13. Cut

cut!: add ! in the rule will cut the search

fruit(apple).
fruit(banana).
fruit(orange).

cut_test1(X) :- fruit(X).
cut_test1('last clause').

cut_test2(X):- fruit(X), ! .
cut_test2('last clause').

! suppresses the traceback of the left target, while the target to its right is unaffected
```
cut_test3(X, Y) :- fruit(X), ! , fruit(Y).
```
not(X): negate X bool value
not basic principle
```
not(X) :- call(X), !, fail.
not(X).
```

14. Process Control

repeat: always succeed, provide an infinite number of choice points
how to create a endless loop:
```
command_loop :- repeat, fail.
```

loop: read in a simple command and echoed on the screen until the user enters end

command_loop :-
    repeat,
    write('Enter command (end to exit): '), 
    read(X), 
    write(X), nl, 
    X = end.

Tail Recursion
1. Tail Resursion: using recursion to repeat; its form is a recursive statement at the end of the function, and the computation of each layer does not need to use the return information of the next layer so that a good Prolog interpreter does not need to rely on a stack
2. e.g. factorial(number, 1, answer) -> answer := number!
```
factorial(1, F, F).
factorial(N, T, F) :- 
    N > 1, 
    NEXT_T is N * T,
    NEXT_N is N - 1, 
    factorial(NEXT_N, NEXT_T, F).
```
  5! = 120;

15. Natural Language

And Proof: first find out all the possible breakdown of a sentence, then test whether each part of breakdown is legal

Diff Table: including two tables: full table and remainder table, which can be used as two arguments of the predicate; we use - to connect two tables to make it easier to read, in the form of X - Y