longjing 0.1.0

data/lib/longjing/ff/preprocess.rb

@@ -0,0 +1,43 @@
+require 'longjing/parameters'
+require 'longjing/problem'
+
+module Longjing
+  module FF
+    class Preprocess
+      module NegGoal
+        def applicable?(set)
+          set.include?(self)
+        end
+        def apply(set)
+          set << self
+        end
+      end
+
+      def execute(problem)
+        ret = propositionalize(problem)
+        reverse_negative_goals(ret.goal)
+        ret
+      end
+
+      def propositionalize(problem)
+        actions = problem[:actions].map do |action|
+          params = Parameters.new(action)
+          params.propositionalize(problem[:objects])
+        end.flatten
+        Problem.new(actions, problem[:init], problem[:goal])
+      end
+
+      def reverse_negative_goals(goal)
+        case goal
+        when PDDL::And
+          goal.literals.each do |lit|
+            reverse_negative_goals(lit)
+          end
+        when PDDL::Not
+          goal.extend(NegGoal)
+          goal.ff_neg_goal = true
+        end
+      end
+    end
+  end
+end

data/lib/longjing/ff/relaxed_graph_plan.rb

@@ -0,0 +1,140 @@
+require 'longjing/pddl/literal'
+
+module Longjing
+  module PDDL
+    class Literal
+      attr_accessor :ff_layer, :ff_goal
+    end
+  end
+
+  module FF
+    class RelaxedGraphPlan
+      attr_reader :actions, :literals
+
+      def initialize(cg)
+        @actions = cg.actions
+        @add2actions = cg.add2actions
+        @pre2actions = cg.pre2actions
+        @literals = cg.literals
+      end
+
+      def layers(goal, state)
+        step = 0
+        scheduled_facts = state.raw.to_a
+        scheduled_actions = []
+        @literals.each do |lit|
+          lit.ff_layer = nil
+          lit.ff_goal = false
+        end
+        goal.each do |lit|
+          lit.ff_goal = true
+        end
+        @actions.each do |action|
+          action.counter = 0
+          action.layer = Float::INFINITY
+          if action.pre.empty?
+            action.difficulty = 0
+            scheduled_actions << action
+          else
+            action.difficulty = Float::INFINITY
+          end
+        end
+        goal_count = goal.size
+        loop do
+          scheduled_facts.each do |lit|
+            next unless lit.ff_layer.nil?
+            lit.ff_layer = step
+            if lit.ff_goal
+              goal_count -= 1
+            end
+            if actions = @pre2actions[lit]
+              actions.each do |action|
+                next if action.counter == action.count_target
+                action.counter += 1
+                if action.counter == action.count_target
+                  action.difficulty = step
+                  scheduled_actions << action
+                end
+              end
+            end
+          end
+          break if goal_count == 0
+          scheduled_facts = []
+          scheduled_actions.each do |action|
+            action.layer = step
+            action.add.each do |lit|
+              if lit.ff_layer.nil?
+                scheduled_facts << lit
+              end
+            end
+          end
+          scheduled_actions = []
+          break if scheduled_facts.empty?
+          step += 1
+        end
+      end
+
+      def extract(goal, state, added_goals=[])
+        layers(goal, state)
+        goal_layers = goal.map(&:ff_layer)
+        return nil if goal_layers.any?(&:nil?)
+        # m = first layer contains all goals
+        m = goal_layers.max
+
+        marks = Hash.new{|h,k| h[k]={}}
+        layer2facts = Array.new(m + 1) { [] }
+
+        goal.each do |lit|
+          layer2facts[lit.ff_layer] << lit
+        end
+
+        plan = []
+        (1..m).to_a.reverse.each do |i|
+          subplan = []
+          layer2facts[i].each do |g|
+            next if marks[g].include?(i)
+            next unless actions = @add2actions[g]
+            action = actions.select do |a|
+              a.layer == i - 1
+            end.min_by(&:difficulty)
+
+            action.pre.each do |lit|
+              if lit.ff_layer != 0 && !marks[lit].include?(i - 1)
+                layer2facts[lit.ff_layer] << lit
+              end
+            end
+            action.add.each do |lit|
+              marks[lit][i] = true
+              marks[lit][i-1] = true
+            end
+            unless added_goals.empty?
+              action.del.each do |lit|
+                if added_goals.include?(lit)
+                  return nil
+                end
+              end
+            end
+
+            subplan << action
+          end
+          unless subplan.empty?
+            plan << subplan
+          end
+        end
+        if plan.empty?
+          [plan]
+        else
+          helpful_actions = {}
+          layer2facts[1].each do |lit|
+            @add2actions[lit].each do |action|
+              if action.layer == 0
+                helpful_actions[action.action] = true
+              end
+            end
+          end
+          [plan, helpful_actions.empty? ? nil : helpful_actions.keys]
+        end
+      end
+    end
+  end
+end

data/lib/longjing/logging.rb

@@ -0,0 +1,65 @@
+require 'logger'
+
+module Longjing
+  module Logging
+    def logger
+      @@logger ||= Logger.new(STDOUT).tap do |l|
+        l.level = Logger::WARN
+        l.formatter = proc do |severity, datetime, progname, msg|
+          "#{severity[0]} #{datetime}: #{msg}\n"
+        end
+      end
+    end
+
+    def logger=(l)
+      @@logger = l
+    end
+
+    def log(event=nil, *args, &block)
+      case event
+      when :exploring
+        state = args[0]
+        logger.debug { "\n\nExploring: #{state}\n=======================" }
+      when :action
+        action, result = args
+        logger.debug { "\nAction: #{action.signature}\n-----------------------" }
+        logger.debug { "=>  #{result}" }
+      when :heuristic
+        new_state, solution, dist, best = args
+        logger.debug {
+          buf = ""
+          solution[0].reverse.each_with_index do |a, i|
+            buf << "  #{i}. [#{a.map(&:signature).join(", ")}]\n"
+          end
+          "Relaxed plan (cost: #{dist}):\n#{buf}\n  helpful actions: #{solution[1] ? solution[1].map(&:signature).join(", ") : '[]'}"
+        }
+        if dist < best
+          logger.debug { "Add to plan #{new_state.path.last.signature}, cost: #{dist}" }
+        else
+          logger.debug { "Add to frontier" }
+        end
+      when :facts
+        args[0].each_slice(3) do |group|
+          logger.info { "  #{group.map(&:to_s).join(' ')}"}
+        end
+      when :problem
+        prob = args[0]
+        logger.info {
+          "Problem: #{prob[:problem]}, domain: #{prob[:domain]}"
+        }
+        logger.info {
+          "Requirements: #{prob[:requirements].join(', ')}"
+        }
+        log(:problem_stats, prob)
+      when :problem_stats
+        prob = args[0]
+        logger.info { "# types: #{Array(prob[:types]).size}" }
+        logger.info { "# predicates: #{prob[:predicates].size}" }
+        logger.info { "# object: #{prob[:objects].size}" }
+        logger.info { "# actions: #{prob[:actions].size}" }
+      when NilClass
+        logger.info(&block)
+      end
+    end
+  end
+end

data/lib/longjing/parameters.rb

@@ -0,0 +1,32 @@
+module Longjing
+  class Parameters
+    def initialize(action)
+      @action = action
+      @params = action.params
+    end
+
+    def propositionalize(objects)
+      return [@action] if objects.empty?
+      permutate(objects).map do |arguments|
+        @action.substitute(arguments)
+      end.compact
+    end
+
+    # return: [objs, objs...]
+    def permutate(objects)
+      return [] if @params.empty?
+      type_args = @params.map do |param|
+        args = objects.select { |obj| obj.is_a?(param.type) }
+        return [] if args.empty?
+        args
+      end
+      Longjing.logger.debug {
+        "type arguments: #{type_args.map {|v| v.size}.join(', ')}"
+      }
+
+      type_args[0].product(*type_args[1..-1]).reject do |array|
+        array.uniq.size < @params.size
+      end
+    end
+  end
+end

data/lib/longjing/pddl.rb

@@ -0,0 +1,24 @@
+require 'longjing/pddl/parser.tab.rb'
+
+module Longjing
+  class Error < StandardError
+  end
+
+  class UnknownDomain < Error
+  end
+
+  class UnsupportedRequirements < Error
+  end
+
+  module PDDL
+    module_function
+
+    def domains
+      @domains ||= {}
+    end
+
+    def parse(pddl)
+      Parser.new.parse(pddl, self.domains)
+    end
+  end
+end

data/lib/longjing/pddl/action.rb

@@ -0,0 +1,32 @@
+require 'longjing/pddl/literal'
+
+module Longjing
+  module PDDL
+    class Action
+      attr_reader :name, :params, :precond, :effect
+
+      def initialize(name, params, precond, effect)
+        @name = name
+        @params = params
+        @precond = precond
+        @effect = effect
+      end
+
+      def substitute(arguments)
+        variables = Hash[@params.zip(arguments)]
+        return nil unless precond = @precond.substitute(variables)
+        return nil unless effect = @effect.substitute(variables)
+        Action.new(@name, arguments, precond, effect)
+      end
+
+      def signature
+        "#{@name}(#{@params.map(&:name).map(&:to_s).join(' ')})"
+      end
+
+      def to_s
+        "(action #{@name} :parameters #{@params.join(' ')} :precondition #{@precond} :effect #{@effect})"
+      end
+      alias :inspect :to_s
+    end
+  end
+end

data/lib/longjing/pddl/literal.rb

@@ -0,0 +1,220 @@
+module Longjing
+  module PDDL
+    class Literal
+      def applicable?(set)
+        raise "Unsupported operation"
+      end
+
+      def apply(set)
+        raise "Unsupported operation"
+      end
+
+      def substitute(variables)
+        raise "Unsupported operation"
+      end
+
+      def to_a
+        [self]
+      end
+    end
+
+    class Empty < Literal
+      def applicable?(set)
+        true
+      end
+
+      def apply(set)
+      end
+
+      def substitute(variables)
+        self
+      end
+
+      def to_s
+        "()"
+      end
+
+      def inspect
+        "<empty>"
+      end
+    end
+    EMPTY = Empty.new
+
+    class Fact < Literal
+      @@insts = {}
+      class << self
+        def [](*args)
+          @@insts[args] ||= new(*args)
+        end
+      end
+
+      attr_reader :hash
+
+      def initialize(pred, objs)
+        @pred = pred
+        @objs = objs
+        @hash = [pred, objs].hash
+      end
+
+      def applicable?(set)
+        set.include?(self)
+      end
+
+      def apply(set)
+        set << self
+      end
+
+      def substitute(variables)
+        self
+      end
+
+      def to_s
+        "(#{[@pred.name, *@objs.map(&:name)].join(' ')})"
+      end
+
+      def inspect
+        "(fact #{[@pred.name, *@objs].join(' ')})"
+      end
+    end
+
+    class Formula < Literal
+      attr_reader :pred, :vars, :hash
+      def initialize(pred, vars)
+        @pred = pred
+        @vars = vars
+        @hash = [pred, vars].hash
+      end
+
+      def substitute(variables)
+        Fact[@pred, @vars.map{|v| variables[v]}]
+      end
+
+      def to_s
+        "(#{[@pred.name, *@vars].join(' ')})"
+      end
+
+      def inspect
+        "(formula #{to_s})"
+      end
+    end
+
+    class Not < Literal
+      @@insts = {}
+      class << self
+        def [](lit)
+          @@insts[lit] ||= new(lit)
+        end
+      end
+
+      attr_reader :literal, :hash
+
+      def initialize(literal)
+        @literal = literal
+        @hash = literal.hash
+      end
+
+      def applicable?(set)
+        !set.include?(@literal)
+      end
+
+      def apply(set)
+        set.delete(@literal)
+      end
+
+      def substitute(variables)
+        ret = @literal.substitute(variables)
+        if ret.nil?
+          EMPTY
+        elsif ret == EMPTY
+          nil
+        else
+          Not[ret]
+        end
+      end
+
+      def to_s
+        "(not #{@literal})"
+      end
+
+      def inspect
+        "(not #{@literal.inspect})"
+      end
+    end
+
+    class Equal < Literal
+      attr_reader :left, :right
+      def initialize(left, right)
+        @left, @right = left, right
+      end
+
+      def substitute(variables)
+        variables[@left] == variables[@right] ? EMPTY : nil
+      end
+
+      def to_s
+        "(= #{@left} #{@right})"
+      end
+
+      def inspect
+        "(= #{@left.inspect} #{@right.inspect})"
+      end
+    end
+
+    class EqualFormula < Equal
+      def substitute(variables)
+        @left == @right ? EMPTY : nil
+      end
+    end
+
+    class And < Literal
+      attr_reader :literals
+
+      def initialize(literals)
+        @literals = literals
+      end
+
+      def applicable?(set)
+        @literals.all? do |lit|
+          lit.applicable?(set)
+        end
+      end
+
+      def apply(set)
+        ret = set.dup
+        @literals.each do |lit|
+          lit.apply(ret)
+        end
+        ret
+      end
+
+      def substitute(variables)
+        ret = []
+        @literals.each do |lit|
+          n = lit.substitute(variables)
+          return nil if n.nil?
+          next if n == EMPTY
+          ret << n
+        end
+        if ret.empty?
+          nil
+        elsif ret.size == 1
+          ret[0]
+        else
+          And.new(ret)
+        end
+      end
+
+      def to_a
+        @literals
+      end
+
+      def to_s
+        "(and #{@literals.map(&:to_s).join(" ")})"
+      end
+
+      def inspect
+        "(and #{@literals.map(&:inspect).join(" ")})"
+      end
+    end
+  end
+end