View difference between Paste ID: hqZ2FsZL and CCsZgZvf

 %% Backward chaining
 %% -- implemented as a parallel search
 %% -- the search tree interleaves calling of solveGoals and solveRules
 %% -- solveGoals takes the first result available (OR)
 %% -- solveRules collects all results before calculating an answer (AND)
 %% -- technically this is called an AND-OR tree
-	%% Initialize KB
+
 -module(backward).
 -export([start/0,mainLoop/0,solveGoal/2,solveRule/2,collect/3]).
 
 start() ->
 	%% Initialize knowledge base;  Notice the goal g has 2 rules applicable to it
 	ets:new(rules, [bag, named_table]),
 	ets:insert(rules, {g,[d,e,f,h,i,j],1.0}),
 	ets:insert(rules, {g,[a,b,c],1.1}),
 	ets:insert(rules, {a,[],0.1}),
 	ets:insert(rules, {b,[],0.2}),
 	ets:insert(rules, {c,[],0.3}),
 	ets:insert(rules, {d,[],0.4}),
 	ets:insert(rules, {e,[],0.5}),
 	ets:insert(rules, {f,[],0.6}),
 	ets:insert(rules, {h,[],0.7}),
 	ets:insert(rules, {i,[],0.8}),
 	ets:insert(rules, {j,[],0.9}),
 	mainLoop().
-		true -> ok
+
 mainLoop() ->
-	Daddy = spawn(backward, solveGoal, [element(2, Query), self()]),
+
 	if
 		Query == {ok, x} -> exit(normal);
-					  exit(Daddy, ok)
+		true -> true
 	end,
 	Root = spawn(backward, solveGoal, [element(2, Query), self()]),
 	receive
 		{_, Truth} -> io:format("Answer is: ~w~n", [Truth]),
 					  exit(Root, ok)       % terminate the remaining processes
 	end,
 	mainLoop().
 
 solveGoal(Goal, Caller) ->
-			%% If RHS is null
+
 	ApplicableRules = ets:match(rules,{Goal, '$1', '$2'}),
-			%% If RHS contains subgoals
+
 		fun([RuleBody,Truth]) ->
 		if
 			%% If rule's body is null, return the truth value
 			RuleBody == [] -> Caller ! {Goal, Truth};
-		%% Each message is of the form {goal,truth}
+			%% If rule's body contains subgoals, solve them recursively
 			true -> spawn_link(backward, solveRule, [RuleBody, self()])
 		end end,
 		ApplicableRules),
 	receive
 		%% Each message is of the form {subgoal,truth}
 		%% Just accept the 1st answer
 		{_, Truth} -> Caller ! {Goal, Truth}
-	%% For each subgoal in Rule
+
-	%% Spawn a process to solve each subgoal
+
 solveRule(RuleTail, Caller) ->
 	N = length(RuleTail),
 	Collector = spawn_link(backward, collect, [[], N, Caller]),
 	%% For each subgoal in Rule, spawn a process to solve each subgoal
 	lists:foreach(
 		fun(Subgoal) -> spawn_link(backward, solveGoal, [Subgoal, Collector]) end,
-	%% If we have N messages send back the answer
+
 
 %% Accumulate results
 collect(Truths, N, Caller) ->
 	%% Collect N messages before sending back an answer
 	%% Answer = min of truth values, equivalent to fuzzy-logic AND
 	%% "min" is changed to "sum" to examine the code's behavior
 	if length(Truths) == N -> Caller ! {dont_care, lists:sum(Truths)};
 	   true -> true
 	end,
 	receive
 		{_, Truth} -> collect([Truth | Truths], N, Caller)
 	end.