porolog 0.0.7 → 0.0.8

data/lib/porolog/scope.rb

@@ -16,9 +16,9 @@ module Porolog
   class Scope
     
     # Error class for rescuing or detecting any Scope error.
-    class ScopeError        < PorologError ; end
+    class Error             < PorologError ; end
     # Error class indicating a non-Predicate was assigned to a Scope.
-    class NotPredicateError < ScopeError   ; end
+    class NotPredicateError < Error        ; end
     
     attr_reader :name
     
@@ -74,7 +74,7 @@ module Porolog
     # @return [Porolog::Predicate] the Predicate assigned to the Scope.
     # @raise [NotPredicateError] when provided predicate is not actually a Predicate.
     def []=(name,predicate)
-      raise NotPredicateError.new("#{predicate.inspect} is not a Predicate") unless predicate.is_a?(Predicate)
+      raise NotPredicateError, "#{predicate.inspect} is not a Predicate" unless predicate.is_a?(Predicate)
       @predicates[name.to_sym] = predicate
     end
     

data/lib/porolog/tail.rb

@@ -0,0 +1,52 @@
+#
+#   lib/porolog/tail.rb      - Plain Old Ruby Objects Prolog Engine -- Tail
+#
+#     Luis Esteban   2 May 2018
+#       created
+#
+
+module Porolog
+  
+  # A Porolog::Tail is used to represent the tail of a list.
+  #
+  # It corresponds to the use of the splat operator within an Array.
+  #
+  # @author Luis Esteban
+  #
+  # @!attribute value
+  #   @return [Object] The value of the tail.
+  class Tail
+    
+    # Creates a new Tail for an Array.
+    # @param value [Object] the value of the tail.
+    def initialize(value = UNKNOWN_TAIL)
+      @value = value
+    end
+    
+    # Returns the value of the Tail.
+    # The optional arguments are ignored; this is for polymorphic compatibility with Porolog::Value and Porolog::Variable,
+    # which are used to prevent inifinite recursion.
+    # @return [Object] the value of the Tail.
+    def value(*)
+      @value
+    end
+    
+    # @return [String] pretty representation.
+    def inspect
+      "*#{@value.inspect}"
+    end
+    
+    # @return [Array] embedded variables.
+    def variables
+      @value.variables
+    end
+    
+    # @param other [Object, #value]
+    # @return [Boolean] whether the value of the Tail is equal to the value of another Object.
+    def ==(other)
+      @value == other.value
+    end
+    
+  end
+  
+end

data/lib/porolog/value.rb

@@ -7,22 +7,22 @@
 
 module Porolog
   
-  # Porolog::Value
-  #
-  #   A Porolog::Value combines a value with a goal so that when the goal
-  #   is closed, the value can be uninstantiated at the same time.
+  # A Porolog::Value combines a value with a goal so that when the goal
+  # is closed, the value can be uninstantiated at the same time.
   #
   # @author Luis Esteban
+  #
   # @!attribute goal
   #   @return [Porolog::Goal] The goal in which the value was instantiated.
   # @!attribute instantiations
   #   @return [Array<Porolog::Instantiation>] Instantiations of this value.
+  #
   class Value
     
     # Error class for rescuing or detecting any Value error.
-    class Error < PorologError ; end
+    class Error     < PorologError ; end
     # Error class indicating that the supplied goal is not actually a goal.
-    class GoalError < Error    ; end
+    class GoalError < Error        ; end
     
     attr_accessor :goal, :instantiations
     
@@ -30,13 +30,10 @@ module Porolog
     # @param goal [Porolog::Goal] the Goal to be associated.
     # @return [Porolog::Value] the Value.
     def initialize(value, goal)
-      raise GoalError.new("Not a Goal: #{goal.inspect}") unless goal.is_a?(Goal)
+      raise GoalError, "Not a Goal: #{goal.inspect}" unless goal.is_a?(Goal)
       
-      if value.is_a?(Value)
-        @value = value.value
-      else
-        @value = value
-      end
+      @value = value
+      @value = value.value if value.is_a?(Value)
       @goal  = goal
       
       @instantiations = []

data/lib/porolog/variable.rb

@@ -0,0 +1,307 @@
+#
+#   lib/porolog/variable.rb      - Plain Old Ruby Objects Prolog Engine -- Variable
+#
+#     Luis Esteban   2 May 2018
+#       created
+#
+
+
+module Porolog
+  
+  # A Porolog::Variable is used to hold instantiations during the process of satisfying a goal.
+  # It implements a variable of a goal.
+  # It allows instantiations to be made and removed as the goal
+  # is attempted to be satisfied.
+  #
+  # @author Luis Esteban
+  #
+  # @!attribute name
+  #   @return [Symbol] The name of the variable.
+  # @!attribute goal
+  #   @return [Porolog::Goal] The Goal for which this Variable's instantiations are bound.
+  # @!attribute instantiations
+  #   @return [Array<Porolog::Instantiation>] The Instantiations of this Variable.
+  # @!attribute values
+  #   @return [Array<Porolog::Value>] the Values of the Variable when used as an anonymous Variable.
+  #
+  class Variable
+    
+    # Error class for rescuing or detecting any Variable error.
+    class Error                 < PorologError  ; end
+    # Error class indicating a Variable has been instantiated to multiple different values at the same time.
+    class MultipleValuesError   < Error         ; end
+    # Error class indicating a Variable has been created without a Goal.
+    class GoalError             < Error         ; end
+    # Error class indicating a Variable has been instantiated to a value that contains itself.
+    class SelfReferentialError  < Error         ; end
+    # Error class indicating an unexpected scenario has occurred.
+    class UnexpectedError       < Error         ; end
+    
+    attr_accessor :name, :goal, :instantiations, :values
+    
+    # Initializes the Variable and attaches it to the Goal.
+    # @param name [Object] the name used to refer to the Variable.
+    # @param goal [Porolog::Goal] the Goal the Variable is to be attached to.
+    def initialize(name, goal)
+      raise GoalError, "Not a Goal: #{goal.inspect}" unless goal.is_a?(Goal)
+      @goal = goal
+      name  = name.to_sym  if name.is_a?(String)
+      
+      case name
+        when Symbol
+          @name   = name
+          @values = []
+        when Variable
+          @name   = name.name
+          @values = []
+        when Value
+          @name   = name.value
+          @values = [name]
+        else
+          @name   = name.to_s
+          @values = [Value.new(name, goal)]
+      end
+      
+      @instantiations = []
+      @goal.variable(self)
+    end
+    
+    # Converts a Variable back to a Symbol.
+    # @return [Symbol, nil] the name of the Variable.
+    def to_sym
+      @name && @name.to_sym
+    end
+    
+    # @return [Symbol] the type of the Variable, which should be :variable.
+    def type
+      :variable
+    end
+    
+    # @return [String] pretty representation.
+    def inspect
+      "#{@goal.myid}.#{@name.inspect}"
+    end
+    
+    # @param visited [Array] used to prevent infinite recursion.
+    # @param depth [Integer] the current level of indentation.
+    # @param index [Object, nil] the index into this Variable that is instantiated.
+    # @param self_index [Object, nil] the index where this Variable is instantiated.
+    # @return [String] the inspect of the Variable showing instantiations using indentation.
+    def inspect_with_instantiations(visited = [], depth = 0, index = nil, self_index = nil)
+      return if visited.include?(self)
+      
+      index_str = index      && "[#{index.inspect}]"      || ''
+      prefix    = self_index && "[#{self_index.inspect}]" || ''
+      name      = "#{'  ' * depth}#{prefix}#{@goal.myid}.#{@name.inspect}#{index_str}"
+      
+      name = "#{name} = #{@values.map(&:inspect).join(',')}#{index_str}" if @values && !@values.empty? && @instantiations.empty?
+      
+      others = @instantiations.map{|instantiation|
+        [
+          instantiation.variable1.inspect_with_instantiations(visited + [self], depth + 1, instantiation.index1, instantiation.index2),
+          instantiation.variable2.inspect_with_instantiations(visited + [self], depth + 1, instantiation.index2, instantiation.index1),
+        ].compact
+      }.reject(&:empty?)
+      
+      [
+        name,
+        *others,
+      ].join("\n")
+    end
+    
+    # @return [Object,self] returns the current value of the Variable based on its current instantiations.
+    #   If there are no concrete instantiations, it returns itself, indicating no value.
+    # @param visited [Array] prevents infinite recursion.
+    def value(visited = [])
+      return nil if visited.include?(self)
+      visited = visited + [self]
+      
+      # -- Collect values --
+      values = [*@values]
+      
+      @instantiations.each do |instantiation|
+        values += instantiation.values_for(self, visited)
+      end
+     
+      values.uniq!
+     
+      # -- Filter trivial values --
+      values = [[nil]] if values == [[UNKNOWN_TAIL], [nil]] || values == [[nil], [UNKNOWN_TAIL]]
+     
+      values = values.reject{|value| value == UNKNOWN_TAIL }
+     
+      values_values = values.map{|value| value.value(visited) }.reject{|value| value == UNKNOWN_ARRAY }
+      
+      # -- Condense Values --
+      result = if values_values.size > 1
+        # -- Potentially Multiple Values Found --
+        if values_values.all?{|value| value.is_a?(Array) }
+          # -- All Values Are Arrays --
+          unifications  = []
+          
+          values_goals = values.map{|value|
+            value.respond_to?(:goal) && value.goal || value.variables.map(&:goal).first
+          }
+
+          merged, unifications = unify_many_arrays(values, values_goals, visited)
+          
+          merged.value(visited).to_a
+        else
+          # -- Not All Values Are Arrays --
+          unifications = []
+          values.each_cons(2){|left,right|
+            unification = unify(left, right, @goal, @goal, visited)
+            if unification && unifications
+              unifications += unification
+            else
+              unifications = nil
+            end
+          }
+          if unifications
+            values.sort_by{|value|
+              case value
+                when Variable, Symbol             then  2
+                when UNKNOWN_TAIL, UNKNOWN_ARRAY  then  9
+                else                              0
+              end
+            }.first || self
+          else
+            raise MultipleValuesError, "Multiple values detected for #{inspect}: #{values.inspect}"
+          end
+        end
+      else
+        # -- One (or None) Value Found --
+        values.sort_by{|value|
+          case value
+            when Variable, Symbol             then  2
+            when UNKNOWN_TAIL, UNKNOWN_ARRAY  then  9
+            else                              0
+          end
+        }.first || self
+      end
+      
+      # -- Splat Tail --
+      if result.is_a?(Array) && result.size == 1 && result.first.is_a?(Tail)
+        result = result.first.value
+      end
+      
+      result
+    end
+    
+    # Instantiates Variable to another experssion.
+    # @param other [Object] the other value (or object) being instantiated.
+    # @param index_into_other [] the index into the other value.
+    # @param index_into_self [] the index into this Variable.
+    # @return [Porolog::Instantiation,nil] the instantiation made.
+    # @example
+    #   # To instantiate the third element of x to the second element of y,
+    #   # x = [a,b,c,d,e]
+    #   #          |
+    #   # y =   [p,q,r,s]
+    #     x = goal.variable(:x)
+    #     y = goal.variable(:y)
+    #     x.instantiate(y, 1, 2)
+    # @example
+    #   # To instantiate the tail of x to y,
+    #     x.instantiate(y, nil, :tail)
+    def instantiate(other, index_into_other = nil, index_into_self = nil)
+      raise SelfReferentialError, "Cannot instantiate self-referential definition for #{(self.variables & other.variables).inspect}"  unless (self.variables & other.variables).empty?
+      
+      # -- Check Instantiation is Unifiable --
+      unless self.value.is_a?(Variable) || other.value.is_a?(Variable)
+        # -- Determine Other Goal --
+        other_goal = nil
+        other_goal = other.goal if other.respond_to?(:goal)
+        other_goal ||= self.goal
+        
+        # -- Check Unification --
+        unless unify(self, other, self.goal, other_goal)
+          self.goal.log << "Cannot unify: #{self.inspect} and #{other.inspect}"
+          return nil
+        end
+      end
+      
+      # -- Create Instantiation --
+      instantiation = Instantiation.new(self, index_into_self, other, index_into_other)
+      
+      # -- Create Reverse Assymetric Instantiations --
+      if other.value.is_a?(Array) && other.value.last.is_a?(Tail)
+        array = other.value
+        if array.length == 2
+          if array.first.is_a?(Variable)
+            Instantiation.new(array.first, nil, self, :head)
+          end
+          if array.last.is_a?(Tail) && array.last.value.is_a?(Variable)
+            Instantiation.new(array.last.value, nil, self, :tail)
+          end
+        end
+      end
+      
+      # -- Return --
+      instantiation
+    end
+    
+    # Removes this Variable by removing all of its insantiations.
+    # @return [Boolean] success.
+    def remove
+      @instantiations.dup.each(&:remove)
+      @instantiations[0..-1] = []
+      true
+    end
+    
+    # Removes instantiations from another goal.
+    # @param other_goal [Porolog::Goal] the Goal of which instantiations are to be removed.
+    # @return [Boolean] success.
+    def uninstantiate(other_goal)
+      @instantiations.delete_if do |instantiation|
+        instantiation.remove  if instantiation.other_goal_to(self) == other_goal
+      end
+      
+      @values.delete_if{|value| value.goal == other_goal }
+      true
+    end
+    
+    # Indexes the value of the Variable.
+    # @param index [Object] the index into the value.
+    # @return [Object, nil] the value at the index in the value of the Variable.
+    def [](index)
+      value = self.value
+      value = value.value if value.is_a?(Value)
+      
+      case value
+        when Array
+          case index
+            when Integer
+              value[index]
+            when Symbol
+              case index
+                when :head
+                  value[0]
+                when :tail
+                  value[1..-1]
+                else
+                  nil
+              end
+            else
+              nil
+          end
+        else
+          nil
+      end
+    end
+    
+    # @return [Array<Porolog::Variable>] the Variables in itself, which is just itself.
+    def variables
+      [self]
+    end
+    
+    # Compares Variables.
+    # @param other [Porolog::Variable] the other Variable.
+    # @return [Boolean] whether the two Variables have the same name in the same Goal.
+    def ==(other)
+      other.is_a?(Variable) && @name == other.name && @goal == other.goal
+    end
+    
+  end
+  
+end

data/test/porolog/arguments_test.rb

@@ -13,16 +13,19 @@ describe 'Porolog' do
     reset
   end
   
+  let(:pred_name)   { :pred }
+  let(:pred)        { Predicate.new pred_name }
+  let(:pred1)       { Predicate.new :p }
+  let(:pred2)       { Predicate.new :q }
+  
   describe 'Arguments' do
     
     describe '.reset' do
       
       it 'should delete/unregister all Arguments' do
-        p = Predicate.new :p
-        
-        args1 = Arguments.new p, [1,:x,'word',[2,:y,0.3]]
-        args2 = Arguments.new p, [2]
-        args3 = Arguments.new p, [3,:x,:y,:z]
+        args1 = Arguments.new pred, [1,:x,'word',[2,:y,0.3]]
+        args2 = Arguments.new pred, [2]
+        args3 = Arguments.new pred, [3,:x,:y,:z]
         
         assert_equal    'Arguments1',       args1.myid
         assert_equal    'Arguments2',       args2.myid
@@ -30,8 +33,8 @@ describe 'Porolog' do
         
         Arguments.reset
         
-        args4 = Arguments.new p, [4,[1,2,3]]
-        args5 = Arguments.new p, [5,[]]
+        args4 = Arguments.new pred, [4,[1,2,3]]
+        args5 = Arguments.new pred, [5,[]]
         
         assert_equal    'Arguments-999',    args1.myid
         assert_equal    'Arguments-999',    args2.myid
@@ -53,10 +56,9 @@ describe 'Porolog' do
     describe '.new' do
       
       it 'should create a new Arguments' do
-        predicate = Predicate.new :p
-        arguments = Arguments.new predicate, [1,:x,'word',[2,:y,0.3]]
+        arguments = Arguments.new pred, [1, :x, 'word', [2, :y, 0.3]]
         
-        assert_Arguments arguments, :p, [1,:x,'word',[2,:y,0.3]]
+        assert_Arguments    arguments, :pred, [1, :x, 'word', [2, :y, 0.3]]
       end
       
     end
@@ -64,21 +66,23 @@ describe 'Porolog' do
     describe '.arguments' do
       
       it 'should return all registered arguments' do
-        assert_equal        0, Arguments.arguments.size
+        # -- No Arguments --
+        assert_equal        0,    Arguments.arguments.size
         
-        predicate1 = Predicate.new :p
-        arguments1 = Arguments.new predicate1, [:x,:y,:z]
+        # -- One Arguments --
+        arguments1 = Arguments.new pred1, [:x,:y,:z]
         
-        assert_equal        1, Arguments.arguments.size
+        assert_equal        1,    Arguments.arguments.size
         assert_Arguments    Arguments.arguments.last, :p, [:x,:y,:z]
         
-        predicate2 = Predicate.new :q
-        arguments2 = Arguments.new predicate2, [:a,:b,:c,:d]
+        # -- Two Arguments --
+        arguments2 = Arguments.new pred2, [:a,:b,:c,:d]
         
-        assert_equal        2, Arguments.arguments.size
+        assert_equal        2,    Arguments.arguments.size
         assert_Arguments    Arguments.arguments.last, :q, [:a,:b,:c,:d]
         
-        assert_equal        [arguments1,arguments2],   Arguments.arguments
+        
+        assert_equal        [arguments1, arguments2],     Arguments.arguments
       end
       
     end
@@ -86,18 +90,16 @@ describe 'Porolog' do
     describe '#initialize' do
       
       it 'should initialize predicate and arguments' do
-        predicate = Predicate.new :p
-        arguments = Arguments.new predicate, [:x,:y,:z]
+        arguments = Arguments.new pred, [:x,:y,:z]
         
-        assert_equal  predicate,      arguments.predicate
+        assert_equal  pred,           arguments.predicate
         assert_equal  [:x,:y,:z],     arguments.arguments
       end
       
       it 'should register the arguments' do
-        predicate  = Predicate.new :p
-        arguments1 = Arguments.new predicate, [:x]
-        arguments2 = Arguments.new predicate, [:x,:y]
-        arguments3 = Arguments.new predicate, [:x,:y,:z]
+        arguments1 = Arguments.new pred, [:x]
+        arguments2 = Arguments.new pred, [:x,:y]
+        arguments3 = Arguments.new pred, [:x,:y,:z]
         
         assert_equal  [
           arguments1,
@@ -111,10 +113,9 @@ describe 'Porolog' do
     describe '#myid' do
       
       it 'should return its class and index as a String' do
-        predicate = Predicate.new :p
-        arguments1 = Arguments.new predicate, [:x]
-        arguments2 = Arguments.new predicate, [:x,:y]
-        arguments3 = Arguments.new predicate, [:x,:y,:z]
+        arguments1 = Arguments.new pred, [:x]
+        arguments2 = Arguments.new pred, [:x,:y]
+        arguments3 = Arguments.new pred, [:x,:y,:z]
         
         assert_equal  'Arguments1',     arguments1.myid
         assert_equal  'Arguments2',     arguments2.myid
@@ -122,10 +123,9 @@ describe 'Porolog' do
       end
       
       it 'should return its class and -999 as a String when deleted/reset' do
-        predicate = Predicate.new :p
-        arguments1 = Arguments.new predicate, [:x]
-        arguments2 = Arguments.new predicate, [:x,:y]
-        arguments3 = Arguments.new predicate, [:x,:y,:z]
+        arguments1 = Arguments.new pred, [:x]
+        arguments2 = Arguments.new pred, [:x,:y]
+        arguments3 = Arguments.new pred, [:x,:y,:z]
         
         Arguments.reset
         
@@ -142,6 +142,7 @@ describe 'Porolog' do
         predicate1 = Predicate.new :p
         predicate2 = Predicate.new :q
         predicate3 = Predicate.new :generic
+        
         arguments1 = Arguments.new predicate1, [:x]
         arguments2 = Arguments.new predicate2, [:list, [1,2,3]]
         arguments3 = Arguments.new predicate3, [:a,:b,:c]
@@ -156,12 +157,11 @@ describe 'Porolog' do
     describe '#fact!' do
       
       it 'should create a fact for its predicate' do
-        predicate1 = Predicate.new :predicate1
-        arguments1 = predicate1.(1,'a',0.1)
+        arguments1 = pred.(1,'a',0.1)
         
         arguments1.fact!
         
-        assert_equal '[  predicate1(1,"a",0.1):- true]', predicate1.rules.inspect
+        assert_equal '[  pred(1,"a",0.1):- true]', pred.rules.inspect
       end
       
     end
@@ -169,12 +169,11 @@ describe 'Porolog' do
     describe '#falicy!' do
       
       it 'should create a falicy for its predicate' do
-        predicate1 = Predicate.new :predicate1
-        arguments1 = predicate1.(1,'a',0.1)
+        arguments1 = pred.(1,'a',0.1)
         
         arguments1.falicy!
         
-        assert_equal '[  predicate1(1,"a",0.1):- false]', predicate1.rules.inspect
+        assert_equal '[  pred(1,"a",0.1):- false]', pred.rules.inspect
       end
       
     end
@@ -182,12 +181,11 @@ describe 'Porolog' do
     describe '#cut_fact!' do
       
       it 'should create a fact for its predicate and terminate solving the goal' do
-        predicate1 = Predicate.new :predicate1
-        arguments1 = predicate1.(1,'a',0.1)
+        arguments1 = pred.(1,'a',0.1)
         
         arguments1.cut_fact!
         
-        assert_equal '[  predicate1(1,"a",0.1):- [:CUT, true]]', predicate1.rules.inspect
+        assert_equal '[  pred(1,"a",0.1):- [:CUT, true]]', pred.rules.inspect
       end
       
     end
@@ -195,12 +193,11 @@ describe 'Porolog' do
     describe '#cut_falicy!' do
       
       it 'should create a falicy for its predicate and terminate solving the goal' do
-        predicate1 = Predicate.new :predicate1
-        arguments1 = predicate1.(1,'a',0.1)
+        arguments1 = pred.(1,'a',0.1)
         
         arguments1.cut_falicy!
         
-        assert_equal '[  predicate1(1,"a",0.1):- [:CUT, false]]', predicate1.rules.inspect
+        assert_equal '[  pred(1,"a",0.1):- [:CUT, false]]', pred.rules.inspect
       end
       
     end
@@ -208,14 +205,13 @@ describe 'Porolog' do
     describe '#<<' do
       
       it 'should create a rule for its predicate' do
-        predicate1 = Predicate.new :predicate1
-        arguments1 = predicate1.(1,'a',0.1)
+        arguments1 = pred.(1,'a',0.1)
         
         arguments1 << [
-          1,2,3
+          pred1.(1,2,3)
         ]
         
-        assert_equal '[  predicate1(1,"a",0.1):- [1, 2, 3]]', predicate1.rules.inspect
+        assert_equal '[  pred(1,"a",0.1):- [p(1,2,3)]]', pred.rules.inspect
       end
       
     end
@@ -223,16 +219,17 @@ describe 'Porolog' do
     describe '#evaluates' do
       
       it 'should add a block as a rule to its predicate' do
-        predicate1 = Predicate.new :predicate1
-        arguments1 = predicate1.(1,'a',0.1)
+        arguments1 = pred.(1,'a',0.1)
         
         line = __LINE__ ; arguments2 = arguments1.evaluates do |*args|
+          #:nocov:
           $stderr.puts "args = #{args.inspect}"
+          #:nocov:
         end
         
         assert_instance_of  Arguments,  arguments2
         
-        part1 = "[  predicate1(1,\"a\",0.1):- #<Proc:0x"
+        part1 = "[  pred(1,\"a\",0.1):- #<Proc:0x"
         part2 = "@#{__FILE__}:#{line}>]"
         
         matcher = Regexp.new(
@@ -242,41 +239,28 @@ describe 'Porolog' do
           Regexp.escape(part2) +
           '\Z'
         )
-        assert_match matcher, predicate1.rules.inspect
+        assert_match matcher, pred.rules.inspect
       end
     end
     
     describe '#variables' do
       
       it 'should find variable arguments' do
-        skip 'until CoreExt added'
-        
-        predicate1 = Predicate.new :alpha
-        arguments1 = predicate1.(1,'a',0.1,:a,2.2,:b,'b',:C,1234)
+        arguments1 = pred.(1,'a',0.1,:a,2.2,:b,'b',:C,1234)
         variables1 = arguments1.variables
         
         assert_equal  [:a,:b,:C], variables1
       end
       
       it 'should find nested variable arguments' do
-        skip 'until CoreExt added'
-        
-        predicate1 = Predicate.new :alpha
-        predicate2 = Predicate.new :bravo
-        
-        arguments = predicate1.(1,'a',0.1,:a,predicate2.(:P,4,:Q),2.2,:b,'b',:C,1234)
+        arguments = pred1.(1, 'a', 0.1, :a, pred2.(:P, 4, :Q), 2.2, :b, 'b', :C, 1234)
         variables = arguments.variables
         
         assert_equal  [:a,:P,:Q,:b,:C], variables
       end
       
       it 'should find embedded variable arguments' do
-        skip 'until CoreExt added'
-        
-        predicate1 = Predicate.new :alpha
-        predicate2 = Predicate.new :bravo
-        
-        arguments = predicate1.(1,[:e1],'a',:h/:t,0.1,:a,predicate2.(:P,[6,:r,8]/predicate2.([:z]),4,:Q),2.2,:b,'b',:C,1234)
+        arguments = pred1.(1, [:e1], 'a', :h/:t, 0.1, :a, pred2.(:P, [6, :r, 8]/pred2.([:z]), 4, :Q), 2.2, :b, 'b', :C, 1234)
         variables = arguments.variables
         
         assert_equal  [:e1,:h,:t,:a,:P,:r,:z,:Q,:b,:C], variables
@@ -287,15 +271,11 @@ describe 'Porolog' do
     describe '#goal' do
       
       it 'should return a new goal for solving the arguments' do
-        skip 'until Goal added'
-        
-        predicate1 = Predicate.new :alpha
-        arguments1 = predicate1.(1,'a',0.1,:a,2.2,:b,'b',:C,1234)
+        arguments1 = pred1.(1, 'a', 0.1, :a, 2.2, :b, 'b', :C, 1234)
         
         goal = arguments1.goal
         
-        assert_instance_of  Goal,         goal
-        assert_equal        arguments1,   goal.arguments
+        assert_Goal         goal,         :p, [1, 'a', 0.1, :a, 2.2, :b, 'b', :C, 1234]
       end
       
     end
@@ -303,8 +283,20 @@ describe 'Porolog' do
     describe '#solutions' do
       
       it 'should memoize solutions' do
-        skip 'until Goal added'
-        # TODO: it 'should memoize solutions' do
+        args1 = Arguments.new pred, [1,2]
+        args2 = Arguments.new pred, [:p,:q]
+        
+        args1.fact!
+        
+        solve_spy = Spy.on(args2, :solve).and_call_through
+        
+        assert_equal  [{ p: 1, q: 2 }],   args2.solutions
+        assert_equal  [{ p: 1, q: 2 }],   args2.solutions
+        assert_equal  [{ p: 1, q: 2 }],   args2.solutions
+        assert_equal  [{ p: 1, q: 2 }],   args2.solutions
+        assert_equal  [{ p: 1, q: 2 }],   args2.solutions
+        
+        assert_equal  1,                  solve_spy.calls.size
       end
       
     end
@@ -312,11 +304,8 @@ describe 'Porolog' do
     describe '#solve' do
       
       it 'should unify and solve a simple predicate' do
-        skip 'until Goal added'
-        
-        alpha = Predicate.new :alpha
-        args1 = Arguments.new alpha, [1,2]
-        args2 = Arguments.new alpha, [:p,:q]
+        args1 = Arguments.new pred, [1,2]
+        args2 = Arguments.new pred, [:p,:q]
         
         args1.fact!
         
@@ -326,14 +315,12 @@ describe 'Porolog' do
       end
       
       it 'should unify and solve a simple predicate with multiple solutions' do
-        skip 'until Goal added'
-        
-        predicate :alpha
+        predicate :simple
         
-        alpha(1,2).fact!
-        alpha(3,4).fact!
+        simple(1,2).fact!
+        simple(3,4).fact!
         
-        solutions = alpha(:p,:q).solve
+        solutions = simple(:p,:q).solve
         
         assert_equal  [
           { p: 1, q: 2 },
@@ -342,14 +329,12 @@ describe 'Porolog' do
       end
       
       it 'should unify and solve a simple predicate with multiple solutions involving a head and tail' do
-        skip 'until Goal added'
+        predicate :basic
         
-        predicate :alpha
+        basic([1,2,3]).fact!
+        basic([3,4,5]).fact!
         
-        alpha([1,2,3]).fact!
-        alpha([3,4,5]).fact!
-        
-        solutions = alpha(:p/:q).solve
+        solutions = basic(:p/:q).solve
         
         assert_equal  [
           { p: 1, q: [2,3] },
@@ -357,9 +342,7 @@ describe 'Porolog' do
         ],solutions
       end
       
-      it 'should unify and solve a basic predicate' do
-        skip 'until Goal added'
-        
+      it 'should unify and solve a normal predicate' do
         predicate :likes
 
         likes('mary','food').fact!
@@ -373,17 +356,28 @@ describe 'Porolog' do
 
         solutions = likes(:who,:what).solve
         
-        assert_equal  [
+        assert_equal [
           { who: 'mary', what: 'food' },
           { who: 'mary', what: 'wine' },
           { who: 'john', what: 'wine' },
           { who: 'john', what: 'mary' },
-        ],solutions
+        ], solutions
       end
       
-      it 'should unify and solve a deeper predicate' do
-        skip 'until Goal added'
+      it 'should allow isnt to be defined' do
+        predicate :isnt
+        
+        isnt(:A,:A) << [:CUT, false]
+        isnt(:A,:B) << [:CUT, true]
+        
+        solutions = isnt(123,123).solve
+        assert_equal [], solutions
         
+        solutions = isnt(123,124).solve
+        assert_equal [{}], solutions
+      end
+      
+      it 'should unify and solve a deeper predicate' do
         predicate :male, :female, :parent
 
         male('james1').fact!
@@ -420,6 +414,7 @@ describe 'Porolog' do
           { X: 'james2' },
         ], solutions
         
+        
         predicate :mother, :father, :sibling, :isnt
 
         mother(:X,:M) << [
@@ -473,27 +468,38 @@ describe 'Porolog' do
       end
       
       it 'should unify and solve a predicate involving a head and tail' do
-        skip 'until Goal added'
-        
-        predicate :alpha, :beta, :gamma
+        predicate :join, :split, :head, :tail
         
-        gamma([1,2]).fact!
-        gamma([2,3]).fact!
+        head(1).fact!
+        head(4).fact!
+        tail([2,3]).fact!
+        tail([5,6]).fact!
         
-        gamma([:h/:t]) << [
-          gamma(:h),
-          gamma(:t),
+        split(:h/:t) << [
+          head(:h),
+          tail(:t),
         ]
         
-        alpha(:l) << [
-          gamma(:l)
+        join(:l) << [
+          split(:l)
         ]
         
-        solutions = alpha(:p/:q).solve
+        solutions = join(:l).solve
         
         assert_equal  [
-          { p: 1, q: 2 },
-          { p: 2, q: 3 },
+          { l: [1,2,3] },
+          { l: [1,5,6] },
+          { l: [4,2,3] },
+          { l: [4,5,6] },
+        ],solutions
+        
+        solutions = join(:p/:q).solve
+        
+        assert_equal  [
+          { p: 1, q: [2,3] },
+          { p: 1, q: [5,6] },
+          { p: 4, q: [2,3] },
+          { p: 4, q: [5,6] },
         ],solutions
       end
       
@@ -541,7 +547,7 @@ describe 'Porolog' do
         end
       end
       
-      it 'should pass on instantiations between goals' do
+      it 'should implement simple recursion' do
         skip 'until StandardPredicates added'
         
         predicate :count
@@ -623,7 +629,7 @@ describe 'Porolog' do
       end
       
       it 'should solve a peeling off predicate' do
-        skip 'until Goal added'
+        skip 'until StandardPredicates added'
         
         predicate :size
 
@@ -650,6 +656,18 @@ describe 'Porolog' do
         skip 'until StandardPredicates added and converted to list representation'
         # TODO: convert to list representation
         
+        predicate :tower
+        
+        tower(1, :X, :Y, :Z, [[:X,:Z]]).fact!
+        tower(:N, :X, :Y, :Z, :S) << [
+          gtr(:N,1),
+          is(:M,:N){|n| n - 1 },
+          tower(:M, :X, :Z, :Y, :S1), 
+          tower( 1, :X, :Y, :Z, :S2), 
+          tower(:M, :Y, :X, :Z, :S3),
+          append(:S1,  :S2, :S12),
+          append(:S12, :S3, :S),
+        ]
         predicate :move
 
         move(1,:X,:Y,:Z) << [
@@ -671,7 +689,6 @@ describe 'Porolog' do
           'Move top disk from right to left',
           'Move top disk from right to center',
           'Move top disk from left to center',
-          'Move top disk from left to right',
           'Move top disk from center to right',
           'Move top disk from center to left',
           'Move top disk from right to left',
@@ -681,6 +698,31 @@ describe 'Porolog' do
           'Move top disk from center to right',
         ].map{|s| "#{s}\n" }.join
         
+        solutions = tower(3, 'left', 'middle', 'right', :moves).solve
+        
+        expected_solutions = [
+          {
+            moves: [
+              ['left',   'center'],
+              ['left',   'right'],
+              ['center', 'right'],
+              ['left',   'center'],
+              ['right',  'left'],
+              ['right',  'center'],
+              ['left',   'center'],
+              ['center', 'right'],
+              ['center', 'left'],
+              ['right',  'left'],
+              ['center', 'right'],
+              ['left',   'center'],
+              ['left',   'right'],
+              ['center', 'right'],
+            ]
+          }
+        ]
+        
+        assert_equal  expected_solutions, solutions
+
         assert_output expected_output do
           solutions = move(4,'left','right','center').solve
           
@@ -695,20 +737,27 @@ describe 'Porolog' do
     describe '#solve_for' do
       
       it 'should solve a predicate for specified variables' do
-        skip 'until Goal added'
+        predicate :alpha
         
+        alpha(1,2).fact!
+        
+        solutions = alpha(:p,:q).solve_for(:q,:p)
+        
+        assert_equal [[2,1]], solutions
+      end
+      
+      it 'should solve a predicate for a specified variable' do
         predicate :alpha
         
         alpha(1,2).fact!
+        alpha(3,5).fact!
         
-        solutions = alpha(:p,:q).solve_for(:p,:q)
+        solutions = alpha(:p,:q).solve_for(:q)
         
-        assert_equal [[1,2]], solutions
+        assert_equal [2,5], solutions
       end
       
       it 'should solve a predicate with multiple solutions for specified variables' do
-        skip 'until Goal added'
-        
         predicate :alpha
         
         alpha(1,2).fact!
@@ -718,12 +767,7 @@ describe 'Porolog' do
         
         solutions = alpha(:p,:q).solve_for(:p)
         
-        assert_equal [
-          [1],
-          [3],
-          [5],
-          [5],
-        ], solutions
+        assert_equal [1,3,5,5], solutions
       end
       
     end
@@ -731,20 +775,48 @@ describe 'Porolog' do
     describe '#valid?' do
       
       it 'should return true when a solution is found' do
-        # TODO: it 'should return true when a solution is found' do
+        predicate :f
+        
+        f(3).fact!
+        
+        assert    f(3).valid?, name
       end
       
       it 'should return false when no solution is found' do
-        # TODO: it 'should return false when no solution is found' do
+        predicate :f
+        
+        f(1).fact!
+        f(2).fact!
+        f(4).fact!
+        f(5).fact!
+        
+        refute    f(3).valid?, name
+      end
+      
+      it 'should return false when a falicy is found' do
+        predicate :f
+        
+        f(3).falicy!
+        
+        refute    f(3).valid?, name
       end
       
     end
     
     describe '#dup' do
       
-      it 'should create a duplicate arguments for another goal' do
-        skip 'until HeadTail added'
-        # TODO: it 'should create a duplicate arguments for another goal' do
+      let(:args1) { pred.(1,'a',0.1,:a,2.2,:b,'b',:C,1234) }
+      let(:goal)  { args1.goal }
+      let(:args2) { args1.dup(goal) }
+      
+      it 'should create a new Arguments' do
+        assert_Arguments  args1, :pred, [1,'a',0.1,:a,2.2,:b,'b',:C,1234]
+        
+        refute_equal      args2.__id__, args1.__id__
+      end
+      
+      it 'should variablise the arguments for the goal' do
+        assert_Arguments  args2, :pred, [1, 'a', 0.1, goal.variable(:a), 2.2, goal.variable(:b), 'b', goal.variable(:C), 1234]
       end
       
     end
@@ -761,14 +833,24 @@ describe 'Porolog' do
         assert    arguments1 == arguments2, 'Arguments with identical predicates and arguments should return true'
       end
       
-      it 'should return false for Arguments with identical predicates and arguments' do
+      it 'should return false for Arguments with non-identical arguments' do
         predicate1 = Predicate.new :omega
         arguments1 = predicate1.(1,'a',0.1)
         
         predicate2 = Predicate.new :omega
         arguments2 = predicate2.(1,'a',0.2)
         
-        refute    arguments1 == arguments2, 'Arguments with non-identical predicates and arguments should return false'
+        refute    arguments1 == arguments2, 'Arguments with non-identical arguments should return false'
+      end
+      
+      it 'should return false for Arguments with non-identical predicates' do
+        predicate1 = Predicate.new :omega
+        arguments1 = predicate1.(1,'a',0.1)
+        
+        predicate2 = Predicate.new :omegb
+        arguments2 = predicate2.(1,'a',0.1)
+        
+        refute    arguments1 == arguments2, 'Arguments with non-identical predicates should return false'
       end
       
     end