mini_kraken 0.1.08 → 0.1.13

data/spec/core/def_relation_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/disj2'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/formal_arg'
+require_relative '../../lib/mini_kraken/core/formal_ref'
+require_relative '../../lib/mini_kraken/core/goal'
+require_relative '../../lib/mini_kraken/core/goal_template'
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+require_relative '../../lib/mini_kraken/core/environment'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/def_relation'
+
+module MiniKraken
+  module Core
+    describe DefRelation do
+      let(:tea) { KSymbol.new(:tea) }
+      let(:formal_t) { FormalArg.new('t') }
+      let(:t_ref) { FormalRef.new('t') }
+      let(:equals_tea) { GoalTemplate.new(Equals.instance, [tea, t_ref]) }
+      subject { DefRelation.new('teao', equals_tea, [formal_t]) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name, a goal template, formal args' do
+          expect { DefRelation.new('teao', equals_tea, [formal_t]) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('teao')
+        end
+
+        it 'should know its goal template' do
+          expect(subject.goal_template).to eq(equals_tea)
+        end
+
+        it 'should know its formals' do
+          expect(subject.formals).to eq([formal_t])
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:cup) { KSymbol.new(:cup) }
+        let(:ref_x) { VariableRef.new('x') }
+        let(:equals_cup) { GoalTemplate.new(Equals.instance, [cup, t_ref]) }
+        let(:g_template) { GoalTemplate.new(Disj2.instance, [equals_tea, equals_cup]) }
+        subject { DefRelation.new('teacup', g_template, [formal_t]) }
+        let(:env) { Environment.new }
+
+        it 'should provide solver for a single-node goal without var ref' do
+          defrel = DefRelation.new('teao', equals_tea, [formal_t])
+          solver = defrel.solver_for([tea], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          outcome = solver.resume
+          expect(outcome).to be_nil
+
+          solver = defrel.solver_for([cup], env)
+          outcome = solver.resume
+          expect(outcome).not_to be_successful
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+
+        it 'should provide solver for a single-node goal' do
+          defrel = DefRelation.new('teao', equals_tea, [formal_t])
+          env.add_var(Variable.new('x'))
+          solver = defrel.solver_for([ref_x], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(ref_x.value(outcome)).to eq(tea)
+
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+
+        it 'should provide solver for a single-node goal' do
+          env.add_var(Variable.new('x'))
+          solver = subject.solver_for([ref_x], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(ref_x.value(outcome)).to eq(tea)
+
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(ref_x.value(outcome)).to eq(cup)
+
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/equals_spec.rb

@@ -275,9 +275,9 @@ module MiniKraken
 
         it 'should unify composite terms with variables' do
           # Reasoned S2, frame 1:36
-          # (run* q (fresh (x) (==  '(((,q)) (,x)) `(((,x)) pod)))) ;; => ('pod)
-          expr1 = cons(cons(ref_q), ref_x)
-          expr2 = cons(cons(ref_x), pod)
+          # (run* q (fresh (x) (==  '(((,q)) ,x) `(((,x)) pod)))) ;; => ('pod)
+          expr1 = cons(cons(cons(ref_q)), ref_x)
+          expr2 = cons(cons(cons(ref_x)), pod)
 
           result = solve_for(expr1, expr2)
           # require 'debug'

data/spec/core/goal_template_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/disj2'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/formal_arg'
+require_relative '../../lib/mini_kraken/core/formal_ref'
+require_relative '../../lib/mini_kraken/core/goal'
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+# require_relative '../../lib/mini_kraken/core/environment'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/goal_template'
+
+
+module MiniKraken
+  module Core
+    describe GoalTemplate do
+      let(:tea) { KSymbol.new(:tea) }
+      let(:t_ref) { FormalRef.new('t') }
+      subject { GoalTemplate.new(Equals.instance, [tea, t_ref]) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a relation and args' do
+          expect { GoalTemplate.new(Equals.instance, [tea, t_ref]) }.not_to raise_error
+        end
+
+        it 'should know its relation' do
+          expect(subject.relation).to eq(Equals.instance)
+        end
+
+        it 'should know its arguments' do
+          expect(subject.args[0]).to eq(tea)
+          expect(subject.args[1]).to eq(t_ref)
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:formal_t) { FormalArg.new('t') }
+        let(:cup) { KSymbol.new(:cup) }
+        let(:ref_x) { VariableRef.new('x') }
+        # let(:env) { Environment.new }
+
+        it 'should instantiate a single-node goal' do
+          expect(subject.instantiate([formal_t], [cup])).to be_kind_of(Goal)
+          goal = subject.instantiate([formal_t], [cup])
+          expect(goal.relation).to eq(Equals.instance)
+          expect(goal.actuals[0]).to eq(tea)
+          expect(goal.actuals[1]).to eq(cup)
+        end
+
+        it 'should instantiate a multiple-nodes goal' do
+          sub_tmp1 =  GoalTemplate.new(Equals.instance, [tea, t_ref])
+          sub_tmp2 =  GoalTemplate.new(Equals.instance, [cup, t_ref])
+          template =  GoalTemplate.new(Disj2.instance, [sub_tmp1, sub_tmp2])
+
+          goal = template.instantiate([formal_t], [ref_x])
+          expect(goal.relation).to eq(Disj2.instance)
+          subgoal1 = goal.actuals[0]
+          expect(subgoal1).to be_kind_of(Goal)
+          expect(subgoal1.relation).to eq(Equals.instance)
+          expect(subgoal1.actuals[0]).to eq(tea)
+          expect(subgoal1.actuals[1]).to eq(ref_x)
+          subgoal2 = goal.actuals[1]
+          expect(subgoal2).to be_kind_of(Goal)
+          expect(subgoal2.relation).to eq(Equals.instance)
+          expect(subgoal2.actuals[0]).to eq(cup)
+          expect(subgoal2.actuals[1]).to eq(ref_x)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/k_boolean_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'ostruct'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/k_boolean'
+
+module MiniKraken
+  module Core
+    describe KBoolean do
+      subject { KBoolean.new('#t') }
+
+      context 'Initialization:' do
+        it 'could be created with a Ruby true/false value' do
+          expect { KBoolean.new(true) }.not_to raise_error
+          expect { KBoolean.new(false) }.not_to raise_error
+        end
+
+        it 'could be created with a Ruby Symbol value' do
+          expect { KBoolean.new(:"#t") }.not_to raise_error
+          expect { KBoolean.new(:"#f") }.not_to raise_error
+        end
+
+        it 'could be created with a Ruby String value' do
+          expect { KBoolean.new('#t') }.not_to raise_error
+          expect { KBoolean.new('#f') }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(true)
+        end
+
+        it 'should know that it is a ground term' do
+          env = double('mock-env')
+          expect(subject.ground?(env)).to be_truthy
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know whether it is equal to another instance' do
+          # Same type, same value
+          other = KBoolean.new(true)
+          expect(subject).to be_eql(other)
+
+          other = KBoolean.new(:"#t")
+          expect(subject).to be_eql(other)
+
+          other = KBoolean.new('#t')
+          expect(subject).to be_eql(other)
+
+          # Same type, other value
+          another = KBoolean.new(false)
+          expect(subject).not_to be_eql(another)
+
+          # Same type, other value
+          another = KBoolean.new(:"#f")
+          expect(subject).not_to be_eql(another)
+
+          # Same type, other value
+          another = KBoolean.new('#f')
+          expect(subject).not_to be_eql(another)
+
+          # Different type, same value
+          yet_another = OpenStruct.new(value: true)
+          expect(subject).not_to be_eql(yet_another)
+        end
+
+        it 'should know whether it has same value than other object' do
+          # Same type, same value
+          other = KBoolean.new(true)
+          expect(subject == other).to be_truthy
+
+          other = KBoolean.new(:"#t")
+          expect(subject == other).to be_truthy
+
+          other = KBoolean.new('#t')
+          expect(subject == other).to be_truthy
+
+          # Same type, other value
+          another = KBoolean.new(false)
+          expect(subject == another).to be_falsy
+
+          another = KBoolean.new(:"#f")
+          expect(subject == another).to be_falsy
+
+          another = KBoolean.new('#f')
+          expect(subject == another).to be_falsy
+
+          # Same duck type, same value
+          yet_another = OpenStruct.new(value: true)
+          expect(subject == yet_another).to be_truthy
+
+          # Different duck type, different value
+          still_another = OpenStruct.new(value: false)
+          expect(subject == still_another).to be_falsy
+
+          # Default Ruby representation, same value
+          expect(subject == true).to be_truthy
+
+          # Default Ruby representation, different value
+          expect(subject == false).to be_falsy
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/outcome_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/vocabulary'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/outcome'
+
+module MiniKraken
+  module Core
+    describe Outcome do
+      let(:voc) do
+        obj = Object.new
+        obj.extend(Vocabulary)
+        obj
+      end
+      subject { Outcome.new(:"#s", voc) }
+
+      context 'Initialization:' do
+        it 'should be created with a symbol and a vocabulary' do
+          expect { Outcome.new(:"#s", voc) }.not_to raise_error
+        end
+
+        it 'should know its resultant' do
+          expect(subject.resultant).to eq(:"#s")
+        end
+
+        it 'should know its parent' do
+          expect(subject.parent).to eq(voc)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should have a factory for failing outcome' do
+          instance = Outcome.failure(voc)
+          expect(instance.resultant).to eq(:"#u")
+          expect(instance.parent).to eq(voc)
+        end
+
+        it 'should have a factory for succeeding outcome' do
+          instance = Outcome.success(voc)
+          expect(instance.resultant).to eq(:"#s")
+          expect(instance.parent).to eq(voc)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/vocabulary_spec.rb

@@ -207,6 +207,12 @@ module MiniKraken
           expect(subject.get_rank('z')).to eq(0)
           expect(subject.get_rank('a')).to eq(1)
         end
+
+        it 'should provide a String representation of itself' do
+          expectation = +"#<#{subject.class}:#{subject.object_id.to_s(16)} @parent="
+          expectation << "#<#{subject.parent.class}:#{subject.parent.object_id.to_s(16)}>>"
+          expect(subject.inspect).to eq(expectation)
+        end
       end # context
     end # describe
   end # module

data/spec/glue/fresh_env_spec.rb

@@ -3,7 +3,9 @@
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/mini_kraken/core/goal'
 require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/fail'
 require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/succeed'
 
 # Load the class under test
 require_relative '../../lib/mini_kraken/glue/fresh_env'
@@ -17,15 +19,39 @@ module MiniKraken
       let(:sample_goal) do
         Core::Goal.new(Core::Equals.instance, [pea, pod])
       end
+      let(:pea_goal) do
+        Core::Goal.new(Core::Equals.instance, [pea, pea])
+      end
+      let(:goal_succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
+      let(:goal_fails) { Core::Goal.new(Core::Fail.instance, []) }
       subject { FreshEnv.new(['q'], sample_goal) }
 
       context 'Initialization:' do
-        it 'should be initialized with an array of names' do
+        it 'could be initialized with names and a goal' do
           expect { FreshEnv.new(['q'], sample_goal) }.not_to raise_error
         end
 
+        it 'could be  initialized with names and goals' do
+          expect { FreshEnv.new(%w[x y], [pea_goal, goal_succeeds]) }.not_to raise_error
+        end
+
         it 'should know its variables' do
           expect(subject.vars['q']).not_to be_nil
+
+          instance = FreshEnv.new(%w[x y], sample_goal)
+          expect(instance.vars['x']).not_to be_nil
+          expect(instance.vars['y']).not_to be_nil
+        end
+
+        it 'should know its goal' do
+          # Single goal at initialization
+          expect(subject.goal).to eq(sample_goal)
+
+          # Multiple goals at initialization
+          instance = FreshEnv.new(['q'], [pea_goal, goal_succeeds])
+          expect(instance.goal.relation.name).to eq('conj2')
+          expect(instance.goal.actuals[0]).to eq(pea_goal)
+          expect(instance.goal.actuals[1]).to eq(goal_succeeds)
         end
       end # context
 

data/spec/glue/run_star_expression_spec.rb

@@ -2,10 +2,15 @@
 
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/mini_kraken/core/goal'
+require_relative '../../lib/mini_kraken/core/conde'
 require_relative '../../lib/mini_kraken/core/conj2'
+require_relative '../../lib/mini_kraken/core/def_relation'
 require_relative '../../lib/mini_kraken/core/disj2'
 require_relative '../../lib/mini_kraken/core/equals'
 require_relative '../../lib/mini_kraken/core/fail'
+require_relative '../../lib/mini_kraken/core/formal_arg'
+require_relative '../../lib/mini_kraken/core/formal_ref'
+require_relative '../../lib/mini_kraken/core/goal_template'
 require_relative '../../lib/mini_kraken/core/succeed'
 
 require_relative '../support/factory_methods'
@@ -21,16 +26,26 @@ module MiniKraken
       let(:pea) { k_symbol(:pea) }
       let(:pod) { k_symbol(:pod) }
       let(:sample_goal) { equals_goal(pea, pod) }
+      let(:fails) { Core::Goal.new(Core::Fail.instance, []) }
+      let(:succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
       subject { RunStarExpression.new('q', sample_goal) }
 
       context 'Initialization:' do
-        it 'should be initialized with a name and a goal' do
+        it 'could be initialized with a name and a goal' do
           expect { RunStarExpression.new('q', sample_goal) }.not_to raise_error
         end
 
+        it 'could be initialized with multiple names and a goal' do
+          expect { RunStarExpression.new(%w[r x y], sample_goal) }.not_to raise_error
+        end
+
+        it 'could be initialized with multiple names and goals' do
+          expect { RunStarExpression.new(%w[r x y], [succeeds, succeeds]) }.not_to raise_error
+        end
+
         it 'should know its variables' do
           expect(subject.env.vars['q']).not_to be_nil
-          expect(subject.var.name).to eq('q')
+          expect(subject.env.vars.values[0].name).to eq('q')
         end
 
         it 'should know its goal' do
@@ -39,19 +54,40 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
+        let(:k_false) { k_boolean(false) }
+        let(:k_true) { k_boolean(true) }
+        let(:bean) { k_symbol(:bean) }
         let(:corn) { k_symbol(:corn) }
+        let(:cup) { k_symbol(:cup) }
+        let(:green) { k_symbol(:green) }
+        let(:lentil) { k_symbol(:lentil) }
         let(:meal) { k_symbol(:meal) }
         let(:oil) { k_symbol(:oil) }
         let(:olive) { k_symbol(:olive) }
+        let(:red) { k_symbol(:red) }
+        let(:soup) { k_symbol(:soup) }
+        let(:split) { k_symbol(:split) }
+        let(:tea) { k_symbol(:tea) }
         let(:virgin) { k_symbol(:virgin) }
         let(:ref_q) { Core::VariableRef.new('q') }
+        let(:ref_r) { Core::VariableRef.new('r') }
         let(:ref_x) { Core::VariableRef.new('x') }
         let(:ref_y) { Core::VariableRef.new('y') }
+        let(:ref_z) { Core::VariableRef.new('z') }
         let(:ref_s) { Core::VariableRef.new('s') }
         let(:ref_t) { Core::VariableRef.new('t') }
         let(:ref_u) { Core::VariableRef.new('u') }
-        let(:fails) { Core::Goal.new(Core::Fail.instance, []) }
-        let(:succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
+        let(:ref_z) { Core::VariableRef.new('z') }
+        let(:t_ref) { Core::FormalRef.new('t') }
+        let(:equals_tea) { Core::GoalTemplate.new(Core::Equals.instance, [tea, t_ref]) }
+        let(:equals_cup) { Core::GoalTemplate.new(Core::Equals.instance, [cup, t_ref]) }
+        let(:g_template) { Core::GoalTemplate.new(Core::Disj2.instance, [equals_tea, equals_cup]) }
+        let(:formal_t) { Core::FormalArg.new('t') }
+
+        # Reasoned S2, frame 1:82
+        # (defrel (teacupo t)
+        #   (disj2 (== 'tea t) (== 'cup t)))
+        let(:teacupo_rel) { Core::DefRelation.new('teacupo', g_template, [formal_t]) }
 
         it 'should return a null list with the fail goal' do
           # Reasoned S2, frame 1:7
@@ -90,6 +126,7 @@ module MiniKraken
 
         it 'should return a null list with the succeed goal' do
           instance = RunStarExpression.new('q', succeeds)
+          expect(instance.env.vars).to be_include('q')
 
           # (display (run* q succeed)) ;; => (_0)
           # Reasoned S2, frame 1:16
@@ -386,7 +423,7 @@ module MiniKraken
           instance = RunStarExpression.new('q', goal)
 
           # Reasoned S2, frame 1:56
-          # (run* q (disj2 (equals 'olive q) fail)) ;; => ('olive)
+          # (run* q (disj2 (== 'olive q) fail)) ;; => ('olive)
           result = instance.run
           expect(result.car).to eq(olive)
         end
@@ -397,7 +434,7 @@ module MiniKraken
           instance = RunStarExpression.new('q', goal)
 
           # Reasoned S2, frame 1:57
-          # (run* q (disj2 fail (equals 'oil q)) ;; => (oil)
+          # (run* q (disj2 fail (== 'oil q))) ;; => (oil)
           result = instance.run
           expect(result.car).to eq(oil)
         end
@@ -409,7 +446,7 @@ module MiniKraken
           instance = RunStarExpression.new('q', goal)
 
           # Reasoned S2, frame 1:58
-          # (run* q (disj2 (equals 'olive q) (equals 'oil q)) ;; => (olive oil)
+          # (run* q (disj2 (== 'olive q) (== 'oil q))) ;; => (olive oil)
           result = instance.run
           expect(result.car).to eq(olive)
           expect(result.cdr.car).to eq(oil)
@@ -504,6 +541,462 @@ module MiniKraken
           expect(result.cdr.car).to eq(any_value(0))
           expect(result.cdr.cdr.car).to eq(oil)
         end
+
+        it 'should accept nesting fresh, disj2 and conj2 expressions (I)' do
+          subgoal1 = equals_goal(split, ref_x)
+          expr1 = equals_goal(pea, ref_y)
+          expr2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          subgoal2 = conj2_goal(expr1, expr2)
+          goal = conj2_goal(subgoal1, subgoal2)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('r', fresh_env_x)
+
+          # Reasoned S2, frame 1:67
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #           (== 'split x)
+          #           (conj2
+          #             (== 'pea y)
+          #             (== '(,x ,y) r)))))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should accept nesting fresh, disj2 and conj2 expressions (II)' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          goal = conj2_goal(subgoal1, subgoal2)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('r', fresh_env_x)
+
+          # Reasoned S2, frame 1:68
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #         (conj2
+          #           (== 'split x)
+          #           (== 'pea y)
+          #         (== '(,x ,y) r)))))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should accept fresh with multiple variables' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          goal = conj2_goal(subgoal1, subgoal2)
+          fresh_env = FreshEnv.new(%w[x y], goal)
+          instance = RunStarExpression.new('r', fresh_env)
+
+          # Reasoned S2, frame 1:70
+          # (run* r
+          #   (fresh (x y)
+          #     (conj2
+          #       (conj2
+          #         (== 'split x)
+          #         (== 'pea y)
+          #       (== '(,x ,y) r))))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should accept multiple variables' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          goal = conj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new(%w[r x y], goal)
+
+          # Reasoned S2, frame 1:72
+          # (run* (r x y)
+          #   (conj2
+          #     (conj2
+          #       (== 'split x)
+          #       (== 'pea y))
+          #     (== '(,x ,y) r))) ;; => (((split pea) split pea))
+          #             o
+          #            / \
+          #            o  nil
+          #          /  \
+          #         /    \
+          #        /      \
+          #       /        \
+          #      /          \
+          #      o           o
+          #     / \         / \
+          # split  o   split   o
+          #       / \         / \
+          #    pea  nil     pea  nil
+          result = instance.run
+          expect(result.car.car.car).to eq(split)
+          expect(result.car.car.cdr.car).to eq(pea)
+          expect(result.car.car.cdr.cdr).to be_nil
+          expect(result.car.cdr.car).to eq(split)
+          expect(result.car.cdr.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.cdr).to be_nil
+        end
+
+        it 'should allow simplication of expressions' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          goal = conj2_goal(expr1, expr2)
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:75
+          # (run* (x y)
+          #   (conj2
+          #     (== 'split x)
+          #     (== 'pea y))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should allow simplication of expressions' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal = disj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:76
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (== 'split x) (== 'pea y))
+          #     (conj2 (== 'red x) (== 'bean y)))) ;; => ((split pea)(red bean))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+        end
+
+        it 'should allow nesting a disjunction inside of conjunction' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(red, ref_x)
+          subgoal1 = disj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(ref_x, ref_y)
+          goal = conj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # (display (run* (x y)
+          #   (conj2
+          #     (disj2
+          #       (== 'split x)
+          #       (== 'red x))
+          #     (== x y)))) ;; => ((split split) (red red))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(split)
+          expect(result.cdr.car.cdr.car).to eq(red)
+        end
+
+        it 'should accept fresh with multiple variables' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          subgoal3 = disj2_goal(subgoal1, subgoal2)
+          subgoal4 = equals_goal(cons(ref_x, cons(ref_y, cons(soup))), ref_r)
+          goal = conj2_goal(subgoal3, subgoal4)
+          fresh_env = FreshEnv.new(%w[x y], goal)
+          instance = RunStarExpression.new('r', fresh_env)
+
+          # Reasoned S2, frame 1:77
+          # (run* r
+          #   (fresh (x y)
+          #     (conj2
+          #       (disj2
+          #         (conj2 (== 'split x) (== 'pea y))
+          #         (conj2 (== 'red x) (== 'bean y)))
+          #       (== '(,x ,y soup) r)))) ;; => ((split pea soup) (red bean soup))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.car).to eq(soup)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+          expect(result.cdr.car.cdr.cdr.car).to eq(soup)
+        end
+
+        it 'should allow fresh with multiple goals' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal1 = disj2_goal(subgoal1, subgoal2)
+          goal2 = equals_goal(cons(ref_x, cons(ref_y, cons(soup))), ref_r)
+          fresh_env = FreshEnv.new(%w[x y], [goal1, goal2])
+          instance = RunStarExpression.new('r', fresh_env)
+
+          # Reasoned S2, frame 1:78
+          # (run* r
+          #   (fresh (x y)
+          #     (disj2
+          #       (conj2 (== 'split x) (== 'pea y))
+          #       (conj2 (== 'red x) (== 'bean y)))
+          #     (== '(,x ,y soup) r))) ;; => ((split pea soup) (red bean soup))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.car).to eq(soup)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+          expect(result.cdr.car.cdr.cdr.car).to eq(soup)
+        end
+
+        it 'should allow run* with multiple goals' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal1 = disj2_goal(subgoal1, subgoal2)
+          goal2 = equals_goal(soup, ref_z)
+          instance = RunStarExpression.new(%w[x y z], [goal1, goal2])
+
+          # Reasoned S2, frame 1:80
+          # (run* (x y z)
+          #   (disj2
+          #     (conj2 (== 'split x) (== 'pea y))
+          #     (conj2 (== 'red x) (== 'bean y)))
+          #   (== 'soup z)) ;; => ((split pea soup) (red bean soup))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.car).to eq(soup)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+          expect(result.cdr.car.cdr.cdr.car).to eq(soup)
+        end
+
+        it 'should allow simplified expressions with multiple goals' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          instance = RunStarExpression.new(%w[x y], [expr1, expr2])
+
+          # Reasoned S2, frame 1:81
+          # (run* (x y)
+          #   (== 'split x)
+          #   (== 'pea y)) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should solve expression with defrel' do
+          teacupo_goal = Core::Goal.new(teacupo_rel, [ref_x])
+
+          # Reasoned S2, frame 1:83
+          # (run* x
+          #   (teacupo x)) ;; => ((tea cup))
+          instance = RunStarExpression.new('x', teacupo_goal)
+
+          result = instance.run
+          expect(result.car).to eq(tea)
+          expect(result.cdr.car).to eq(cup)
+        end
+
+        it 'should solve expression with defrel and booleans' do
+          teacupo_goal = Core::Goal.new(teacupo_rel, [ref_x])
+          expr2 = equals_goal(k_true, ref_y)
+          subgoal1 = conj2_goal(teacupo_goal, expr2)
+          expr3 = equals_goal(k_false, ref_x)
+          expr4 = equals_goal(k_true, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal = disj2_goal(subgoal1, subgoal2)
+          # Reasoned S2, frame 1:84
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (teacupo x) (== #t y))
+          #     (conj2 (== #f x) (== #t y))) ;; => ((#f #t)(tea #t) (cup #t))
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          result = instance.run
+          # Order of solutions differs from RS book
+          expect(result.car).to eq(cons(tea, cons(true)))
+          expect(result.cdr.car).to eq(cons(cup, cons(true)))
+          expect(result.cdr.cdr.car).to eq(cons(false, cons(true)))
+        end
+
+        it 'should solve expression with two variable and defrel' do
+          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
+          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_y])
+
+          # Reasoned S2, frame 1:85
+          # (run* (x y)
+          #   (teacupo x)
+          #   (teacupo y)) ;; => ((tea tea)(tea cup)(cup tea)(cup c))
+          instance = RunStarExpression.new(%w[x y], [teacupo_goal1, teacupo_goal2])
+
+          result = instance.run
+          expect(result.car).to eq(cons(tea, cons(tea)))
+          expect(result.cdr.car).to eq(cons(tea, cons(cup)))
+          expect(result.cdr.cdr.car).to eq(cons(cup, cons(tea)))
+          expect(result.cdr.cdr.cdr.car).to eq(cons(cup, cons(cup)))
+        end
+
+        it 'should solve expression with two variable and defrel' do
+          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
+          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_x])
+
+          # Reasoned S2, frame 1:86
+          # (run* (x y)
+          #   (teacupo x)
+          #   (teacupo x)) ;; => ((tea _0)(cup _0))
+          instance = RunStarExpression.new(%w[x y], [teacupo_goal1, teacupo_goal2])
+
+          result = instance.run
+          expect(result.car).to eq(cons(tea, cons(any_value(0))))
+          expect(result.cdr.car).to eq(cons(cup, cons(any_value(0))))
+        end
+
+        it 'should solve expression with defrel and booleans' do
+          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
+          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_x])
+          subgoal1 = conj2_goal(teacupo_goal1, teacupo_goal2)
+          expr3 = equals_goal(k_false, ref_x)
+          expr4 = Core::Goal.new(teacupo_rel, [ref_y])
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal = disj2_goal(subgoal1, subgoal2)
+          # Reasoned S2, frame 1:87
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (teacupo x) (teacupo x))
+          #     (conj2 (== #f x) (teacupo y)))) ;; => ((#f tea)(#f cup)(tea _0)(cup _0))
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          result = instance.run
+          # Order of solutions differs from RS book
+          expect(result.car).to eq(cons(tea, cons(any_value(0))))
+          expect(result.cdr.car).to eq(cons(cup, cons(any_value(0))))
+          expect(result.cdr.cdr.car).to eq(cons(false, cons(tea)))
+          expect(result.cdr.cdr.cdr.car).to eq(cons(false, cons(cup)))
+        end
+
+        it 'should allow conde in the goal expression' do
+          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
+          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_x])
+          expr3 = equals_goal(k_false, ref_x)
+          expr4 = Core::Goal.new(teacupo_rel, [ref_y])
+          goal = conde_goal([[teacupo_goal1, teacupo_goal2], [expr3, expr4]])
+          # Reasoned S2, frame 1:88
+          # (run* (x y)
+          #   (conde
+          #     ((teacupo x) (teacupo x))
+          #     ((== #f x) (teacupo y)))) ;; => ((#f tea)(#f cup)(tea _0)(cup _0))
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          result = instance.run
+          expect(result.car).to eq(cons(tea, cons(any_value(0))))
+          expect(result.cdr.car).to eq(cons(cup, cons(any_value(0))))
+          expect(result.cdr.cdr.car).to eq(cons(false, cons(tea)))
+          expect(result.cdr.cdr.cdr.car).to eq(cons(false, cons(cup)))
+        end
+
+        it 'should allow simplication of expressions (conde version)' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          combo1 = [expr1, expr2]
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          combo2 = [expr3, expr4]
+          goal = conde_goal([combo1, combo2])
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:88 (second part, a rewrite of 1:76)
+          # (run* (x y)
+          #   (conde
+          #     ((== 'split x) (== 'pea y))
+          #     ((== 'red x) (== 'bean y)))) ;; => ((split pea)(red bean))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+        end
+
+        it 'should accept nesting of disj2 and conj2 (conde version)' do
+          equals_olive = Core::Goal.new(Core::Equals.instance, [olive, ref_x])
+          combo = [equals_olive, fails]
+          equals_oil = Core::Goal.new(Core::Equals.instance, [oil, ref_x])
+          goal = conde_goal([combo, equals_oil])
+          instance = RunStarExpression.new('x', goal)
+
+          # Reasoned S2, frame 1:89 (rewrite of 1:62)
+          # (run* x
+          #   (conde
+          #     ((== 'olive x) fail)
+          #     ('oil x))) ;; => (oil)
+          result = instance.run
+          expect(result.car).to eq(oil)
+        end
+
+        it 'should accept nesting of conde inside a fresh context' do
+          equals_lentil = Core::Goal.new(Core::Equals.instance, [lentil, ref_z])
+          fresh_env = FreshEnv.new(['z'], equals_lentil)
+          equals_xy = Core::Goal.new(Core::Equals.instance, [ref_x, ref_y])
+          goal = conde_goal([fresh_env, equals_xy])
+          instance = RunStarExpression.new(%w[x y], goal)
+          fresh_env.parent = instance.env
+
+          # Reasoned S2, frame 1:90
+          # (run* (x y)
+          #   (conde
+          #     ((fresh (z)
+          #       (== 'lentil z)))
+          #     ((== x y)))) ;; => ((_0 _1)(_0 _0))
+          result = instance.run
+          expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
+          expect(result.cdr.car).to eq(cons(any_value(0), cons(any_value(0))))
+        end
+
+        it 'accepts conde with more than two condition lines' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          combo1 = [expr1, expr2]
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          combo2 = [expr3, expr4]
+          expr5 = equals_goal(green, ref_x)
+          expr6 = equals_goal(lentil, ref_y)
+          combo3 = [expr5, expr6]
+          goal = conde_goal([combo1, combo2, combo3])
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:91
+          # (run* (x y)
+          #   (conde
+          #     ((== 'split x) (== 'pea y))
+          #     ((== 'red x) (== 'bean y))
+          #     ((== 'green x) (== 'lentil y))))
+          # ;; => ((split pea)(red bean)(green lentil))
+          result = instance.run
+          expect(result.car).to eq(cons(split, cons(pea)))
+          expect(result.cdr.car).to eq(cons(red, cons(bean)))
+          expect(result.cdr.cdr.car).to eq(cons(green, cons(lentil)))
+        end
       end # context
     end # describe
   end # module