%% Set up your facts first, then define your rules
male('George').
female('Mary').
smart('Mary').
tall('George').
smart('George').

parent('Mary', 'George').
parent('Mary', 'Bob').
parent('George', 'Frank').
parent('George', 'Jenna').

born(1975, 'Bob').
born(1972, 'George').

% The , operator indicates logical AND
%   (which short-circuits if not matched)
older(X,Y) :-
  born(Year1,X),
  born(Year2,Y),
  Year1 < Year2.

mother(X,Y) :- parent(X,Y), female(X).

father(X,Y) :- parent(X,Y), male(X).

grandparent(X,Y) :-
  parent(X,Z), parent(Z,Y).

uncle(X,Y) :-
  parent(Z,Y), brother(X,Z).

aunt(X,Y) :- parent(Z,Y), sister(X,Z).

brother(X,Y) :-
  parent(Z,X), parent(Z,Y), male(X), X \= Y.

sister(X,Y) :-
  parent(Z,X), parent(Z,Y), female(X), X \= Y.

% Prolog applies rule that appears first in the program,
%   so order sometimes matters!
descendant(X,Y) :- parent(Y,X).
descendant(X,Y) :- parent(Y,Z), descendant(X,Z).

%hasachild(X) :- parent(X,Y).
hasachild(X) :- parent(X,_).

speed_mph(ford,100).
time_minutes(ford,20).
distance(X,Y) :-
  speed_mph(X,Speed),
  time_minutes(X,Time),
  Y = Speed * Time / 60.

%greatest common divisor
%gcd(X,Y,D).
gcd(X,X,X).

gcd(X,Y,D) :-
  X < Y,
  Y1 is Y - X,
  gcd(X,Y1,D).

gcd(X,Y,D) :-
  Y < X,
  gcd(Y,X,D).

% gcd(10, 30, Result).
% gcd(30, 10, Result).


cube(N,C) :-
  C is N * N * N,
  write(N),
  write(' cubed is '),
  write(C),
  nl.

% cube(3, Result).


% stop the recursive backward chaining via cut ! operator
cubeit :-
  write( 'enter next number to cube: ' ),
  read(X),
  cube(X).
cube(done) :- !.
cube(N) :-
  C is N * N * N,
  write(N), write( ' cubed is ' ), write(C), nl,
  cubeit.


writelist( [] ).
%writelist( [ Head | Tail ] ) :-
%  write(Head),
%  writelist(Tail).

% flatten an arbitrarily deep list and display
writelist( [ Head | Tail ] ) :-
  ( atom(Head), write(Head) ; writelist(Head) ),
  writelist(Tail).


bars( [] ).
bars( [N|L] ) :- stars(N), nl, bars(L).
stars( N ) :- N > 0, write(*), N1 is N - 1, stars(N1).
stars( N ) :- N =< 0.



%count occurrences of A in list
count( _, [], 0 ).
count( A, [B|L], N ) :-
  atom(B), A = B,
  count( A, L, N1 ),
  N is N1 + 1
  ;
  count( A, L, N ).


%obtain length of list
listlength( [], 0 ).
listlength( [_|Tail], N ) :-
  listlength( Tail, N1 ),
  N = N1 + 1.

%concatenate two lists
concat( [], L, L ).
concat( [X|L1], L2, [X|L3] ) :-
  concat( L1, L2, L3 ).

%reverse a list using recursion and concat relation
reverse( [], [] ).
reverse( [A|B], Reversed ) :-
  reverse( B, ReversedRest ),
  concat( ReversedRest, [A], Reversed ).