rover_prover 0.1.0

data/lib/rover_prover/language/sequent.rb

@@ -0,0 +1,126 @@
+require_relative './formula/formulae.rb'
+class Sequent
+  attr_reader :left, :right, :siblings, :depth
+  def initialize(left, right, siblings, depth)
+    @left = []
+    @right = []
+    @left_depth_tbl = {}
+    @right_depth_tbl = {}
+    left.each { |l| left_add(l) }
+    right.each { |l| right_add(l) }
+    @siblings = siblings
+    @depth = depth
+  end
+
+  def deepen(enable_siblings: false)
+    new_siblings = @siblings.nil? ? (enable_siblings ? [] : @siblings): @siblings.dup
+    new = Sequent.new(@left.dup, @right.dup, new_siblings, @depth + 1)
+    @left.each do |formula|
+      new.left_set_depth(formula, left_get_depth(formula))
+    end
+    @right.each do |formula|
+      new.right_set_depth(formula, right_get_depth(formula))
+    end
+    new
+  end
+
+  def trivial?
+    (@left & @right).length > 0
+  end
+
+  def set_default_instantiation_time(time)
+    @left.each { |l| l.set_instantiation_time(time) }
+    @right.each { |r| r.set_instantiation_time(time) }
+  end
+
+  def left_formula
+    @left.reject { |f| f.is_a?(Predicate) }.min_by { |f| left_get_depth(f) }
+  end
+
+  def right_formula
+    @right.reject { |f| f.is_a?(Predicate) }.min_by { |f| right_get_depth(f) }
+  end
+
+  def left_add(l)
+    @left.push(l)
+    @left_depth_tbl[l] = 0
+  end
+
+  def right_add(r)
+    @right.push(r)
+    @right_depth_tbl[r] = 0
+  end
+
+  def left_remove(l)
+    @left.delete(l)
+    @left_depth_tbl.delete(l)
+  end
+
+  def right_remove(r)
+    @right.delete(r)
+    @right_depth_tbl.delete(r)
+  end
+
+  def left_get_depth(l)
+    @left_depth_tbl[l]
+  end
+
+  def right_get_depth(r)
+    @right_depth_tbl[r]
+  end
+
+  def left_set_depth(l, t)
+    @left_depth_tbl[l] = t
+  end
+
+  def right_set_depth(r, t)
+    @right_depth_tbl[r] = t
+  end
+
+  def free_variables
+    @left.map { |formula| formula.free_variables }.flatten | @right.map { |formula| formula.free_variables}.flatten
+  end
+
+  def free_unification_terms
+    @left.map { |formula| formula.free_unification_terms }.flatten | @right.map { |formula| formula.free_unification_terms}.flatten
+  end
+
+  def get_variable_name(prefix)
+    names = free_variables.map(&:name) | free_unification_terms.map(&:name)
+    index = 1
+    name = prefix + index.to_s
+    while names.include?(name) do
+      index += 1
+      name = prefix + index.to_s
+    end
+    name
+  end
+
+  def get_unifiable_pairs
+    pairs = []
+    @left.each do |formula_a|
+      @right.each do |formula_b|
+        pairs.push([formula_a, formula_b]) unless formula_a.unify(formula_b).nil?
+      end
+    end
+    pairs
+  end
+
+  def to_s
+    "#{@left.map(&:to_s).join(', ')} ⊢ #{@right.map(&:to_s).join(', ')}"
+  end
+
+  def eql?(sequent)
+    include?(@left, sequent.left) &&
+    include?(@right, sequent.right) &&
+    include?(sequent.left, @left) &&
+    include?(sequent.right, @right)
+  end
+
+  private
+  def include?(formulas1, formulas2)
+    formulas2.all? do |f2|
+      formulas1.any? { |f1| f1.eql?(f2) }
+    end
+  end
+end

data/lib/rover_prover/language/term/function.rb

@@ -0,0 +1,63 @@
+require_relative '../term.rb'
+
+class Function < Term
+  attr_reader :terms
+  def initialize(name, terms)
+    super(name)
+    @terms = terms
+  end
+
+  def free_variables
+    @terms.map(&:free_variables).flatten.uniq
+  end
+
+  def free_unification_terms
+    @terms.map(&:free_unification_terms).flatten.uniq
+  end
+
+  def replace(old, new)
+    return new if eql?(old)
+    Function.new(@name, @terms.map { |term| term.replace(old, new) })
+  end
+
+  def set_instantiation_time(time)
+    @time = time
+    @terms.each{ |term| term.set_instantiation_time(time) }
+  end
+
+  def occurs(unification_term)
+    @terms.any? { |term| term.occurs(unification_term) }
+  end
+
+
+  def eql?(function)
+    return false unless function.is_a?(Function)
+    return false unless @name == function.name
+    return false unless @terms.length == function.terms.length
+    @terms.zip(function.terms).all? { |t1, t2| t1.eql?(t2) }
+  end
+
+  def to_s
+    terms_s = @terms.empty? ? "" : "(#{@terms.map(&:to_s).join(', ')})"
+    "#{@name}#{terms_s}"
+  end
+
+  def unify(term)
+    return term.unify(self) if term.is_a?(UnificationTerm)
+    return nil unless term.is_a?(Function)
+    return nil unless @terms.length == term.terms.length
+    term_pair = @terms.zip(term.terms)
+    subst = {}
+
+    term_pair.each do |term_a, term_b|
+      subst.each do |k, v| 
+        term_a = term_a.replace(k, v)
+        term_b = term_b.replace(k, v)
+      end
+      sub = term_a.unify(term_b)
+      return nil if sub == nil
+      subst.merge!(sub)
+    end
+    subst
+  end
+end

data/lib/rover_prover/language/term/terms.rb

@@ -0,0 +1,3 @@
+require_relative 'function.rb'
+require_relative 'unification_term.rb'
+require_relative 'variable.rb'

data/lib/rover_prover/language/term/unification_term.rb

@@ -0,0 +1,38 @@
+require_relative '../term.rb'
+
+class UnificationTerm < Term
+  def free_variables
+    []
+  end
+
+  def free_unification_terms
+    [self]
+  end
+
+  def replace(old, new)
+    return new if eql?(old)
+    self
+  end
+
+  def occurs(unification_term)
+    eql?(unification_term)
+  end
+
+  def set_instantiation_time(time)
+    @time = time
+  end
+
+  def to_s
+    @name
+  end
+
+  def eql?(uni)
+    return false unless uni.is_a?(UnificationTerm)
+    @name == uni.name
+  end
+
+  def unify(term)
+    return nil if term.occurs(self) || term.time > @time
+    { self => term }
+  end
+end

data/lib/rover_prover/language/term/variable.rb

@@ -0,0 +1,40 @@
+require_relative '../term.rb'
+
+class Variable < Term
+  def free_variables
+    [self]
+  end
+
+  def free_unification_terms
+    []
+  end
+
+  def replace(old, new)
+    return new if eql?(old)
+    self
+  end
+
+  def occurs(unification_term)
+    false
+  end
+
+  def set_instantiation_time(time)
+    @time = time
+  end
+
+  def to_s
+    @name
+  end
+
+  def eql?(var)
+    return false unless var.is_a?(Variable)
+    @name == var.name
+  end
+
+  def unify(term)
+    return term.unify(self) if term.is_a?(UnificationTerm)
+    return nil unless term.is_a?(Variable)
+    return nil unless eql?(term)
+    {}
+  end
+end

data/lib/rover_prover/language/term.rb

@@ -0,0 +1,10 @@
+require_relative 'expression.rb'
+class Term
+  attr_reader :time, :name
+  TIME_DEFAULT = 0
+  include Expression
+  def initialize(name)
+    @name = name
+    @time = TIME_DEFAULT
+  end
+end

data/lib/rover_prover/language.rb

@@ -0,0 +1,3 @@
+require_relative 'language/formula/formulae.rb'
+require_relative 'language/term/terms.rb'
+require_relative 'language/sequent.rb'

data/lib/rover_prover/processor/commands.rb

@@ -0,0 +1,32 @@
+class Axioms
+end
+
+class Lemmas
+end
+
+class Axiom
+  attr_reader :formula
+  def initialize(formula)
+    @formula = formula
+  end
+end
+
+class Lemma
+  attr_reader :formula
+  def initialize(formula)
+    @formula = formula
+  end
+end
+
+class Remove
+  attr_reader :formula
+  def initialize(formula)
+    @formula = formula
+  end
+end
+
+class Reset
+end
+
+class Exit
+end

data/lib/rover_prover/processor/processor.rb

@@ -0,0 +1,2 @@
+require_relative 'rover_lexer.rb'
+require_relative 'rover_parser.rb'

data/lib/rover_prover/processor/rover_lexer.rb

@@ -0,0 +1,23 @@
+require 'rltk'
+
+class RoverLexer < RLTK::Lexer
+  rule(/axioms/) { :AXIOMS }
+  rule(/lemmas/) { :LEMMAS }
+  rule(/axiom/) { :AXIOM }
+  rule(/lemma/) { :LEMMA }
+  rule(/remove/) { :REMOVE }
+  rule(/reset/) { :RESET }
+  rule(/exit/) { :EXIT }
+  rule(/\(/) { :LPAREN }
+  rule(/\)/) { :RPAREN }
+  rule(/\./) { :PERIOD }
+  rule(/,/) { :COMMA }
+  rule(/not/) { :NOT }
+  rule(/and/) { :AND }
+  rule(/or/) { :OR }
+  rule(/implies/) { :IMPLIES }
+  rule(/forall/) { :FORALL }
+  rule(/exists/) { :EXISTS }
+  rule(/[a-zA-Z][a-zA-Z0-9]*/) { |t| [:SYMBOL, t] }
+  rule(/\s/)
+end

data/lib/rover_prover/processor/rover_parser.rb

@@ -0,0 +1,64 @@
+require 'rltk'
+require_relative 'commands.rb'
+require_relative '../language.rb'
+
+class RoverParser < RLTK::Parser
+  right :IMPLIES
+  left :OR, :AND
+
+  production(:cmd) do
+    clause('AXIOMS') { |_| Axioms.new }
+    clause('LEMMAS') { |_| Lemmas.new }
+    clause('AXIOM noright') { |_, e| Axiom.new(e) }
+    clause('LEMMA noright') { |_, e| Lemma.new(e) }
+    clause('REMOVE noright') { |_, e| Remove.new(e) }
+    clause('RESET') { |_| Reset.new }
+    clause('EXIT') { |_| Exit.new }
+    clause('noright') { |e| e }
+  end
+
+  production(:noright) do
+    clause('FORALL SYMBOL PERIOD noright') { |_, s, _, f| ForAll.new(Variable.new(s), f) }
+    clause('EXISTS SYMBOL PERIOD noright') { |_, s, _, f| ThereExists.new(Variable.new(s), f) }
+    clause('formula') { |e| e }
+  end
+
+  production(:formula) do
+    clause('formula_with_right OR noright') { |e1, _, e2| Or.new(e1, e2) }
+    clause('formula_with_right AND noright') { |e1, _, e2| And.new(e1, e2) }
+    clause('formula_with_right IMPLIES noright') { |e1, _, e2| Implies.new(e1, e2) }
+    clause('literal') { |e| e }
+  end
+
+  production(:formula_with_right) do
+    clause('formula_with_right OR formula_with_right') { |e1, _, e2| Or.new(e1, e2) }
+    clause('formula_with_right AND formula_with_right') { |e1, _, e2| And.new(e1, e2) }
+    clause('formula_with_right IMPLIES formula_with_right') { |e1, _, e2| Implies.new(e1, e2) }
+    clause('literal') { |e| e }
+  end
+
+  production(:literal) do
+    clause('NOT literal') { |_, e| Not.new(e) }
+    clause('predicate') { |e| e }
+  end
+
+  production(:predicate) do
+    clause('SYMBOL') { |s| Predicate.new(s, []) }
+    clause('SYMBOL LPAREN RPAREN') { |s, _, _| Predicate.new(s, []) }
+    clause('SYMBOL LPAREN term_ls RPAREN') { |s, _, ls, _| Predicate.new(s, ls) }
+    clause('LPAREN formula RPAREN') { |_, f, _| f }
+  end
+
+  production(:term_ls) do
+    clause('term COMMA term_ls') { |t, _, ls| ls.unshift(t) }
+    clause('term') { |t| [t] }
+  end
+
+  production(:term) do
+    clause('SYMBOL') { |s| Variable.new(s) }
+    clause('SYMBOL LPAREN RPAREN') { |s, _, _| Function.new(s, []) }
+    clause('SYMBOL LPAREN term_ls RPAREN') { |s, _, ls, _| Function.new(s, ls) }
+  end
+
+  finalize
+end

data/lib/rover_prover/prover/prover.rb

@@ -0,0 +1,277 @@
+require_relative 'unifier.rb'
+require_relative '../language.rb'
+require 'pry'
+
+class Prover
+  def prove_formula(axioms, formula)
+    prove(
+      Sequent.new(
+        axioms,
+        [formula],
+        nil,
+        0
+      )
+    )
+  end
+
+  def prove(sequent)
+    sequent.set_default_instantiation_time(0)
+    unifier = Unifier.new
+
+    frontier = [sequent]
+    proven = []
+    while true do
+      frontier = frontier - proven
+      old = frontier.pop
+      break if old.nil?
+      puts "#{old.depth}. #{old.to_s}"
+
+      if old.trivial?
+        proven.push(old)
+        next
+      end
+
+      unless old.siblings.nil?
+        pairs_list = old.siblings.map(&:get_unifiable_pairs)
+        if pairs_list.all? { |list| !list.empty? }
+          subst = unifier.unify_all(pairs_list)
+          unless subst.nil?
+            subst.each { |k, v| puts "#{k.to_s} = #{v.to_s}" }
+            proven = proven | old.siblings
+            frontier = frontier - proven
+            next
+          end
+        else
+          old.siblings.delete(old)
+        end
+      end
+
+      left = old.left_formula
+      right = old.right_formula
+      return false if left.nil? && right.nil?
+
+      if apply_left?(old, left, right)
+        frontier.push(*derivation_left(old, left))
+      else
+        frontier.push(*derivation_right(old, right))
+      end
+    end
+    true
+  end
+
+  def derivation_left(old, left)
+    return derivation_left_not(old, left) if left.is_a?(Not)
+    return derivation_left_and(old, left) if left.is_a?(And)
+    return derivation_left_or(old, left) if left.is_a?(Or)
+    return derivation_left_implies(old, left) if left.is_a?(Implies)
+    return derivation_left_for_all(old, left) if left.is_a?(ForAll)
+    return derivation_left_there_exists(old, left) if left.is_a?(ThereExists)
+    []
+  end
+
+  def derivation_right(old, right)
+    return derivation_right_not(old, right) if right.is_a?(Not)
+    return derivation_right_and(old, right) if right.is_a?(And)
+    return derivation_right_or(old, right) if right.is_a?(Or)
+    return derivation_right_implies(old, right) if right.is_a?(Implies)
+    return derivation_right_for_all(old, right) if right.is_a?(ForAll)
+    return derivation_right_there_exists(old, right) if right.is_a?(ThereExists)
+    []
+  end
+
+  def derivation_left_not(sequent, left)
+    new = sequent.deepen
+    new.left_remove(left)
+    new.right_add(left.formula)
+    new.right_set_depth(left.formula, (sequent.left_get_depth(left) + 1))
+    unless new.siblings.nil?
+      new.siblings.push(new)
+    end
+    [new]
+  end
+
+  def derivation_left_and(sequent, left)
+    new = sequent.deepen
+    new.left_remove(left)
+    left_depth = sequent.left_get_depth(left)
+    new.left_add(left.formula_a)
+    new.left_set_depth(left.formula_a, left_depth + 1)
+    new.left_add(left.formula_b)
+    new.left_set_depth(left.formula_b, left_depth + 1)
+    unless new.siblings.nil?
+      new.siblings.push(new)
+    end
+    [new]
+  end
+
+  def derivation_left_or(sequent, left)
+    new_a = sequent.deepen
+    new_b = sequent.deepen
+    new_a.left_remove(left)
+    new_b.left_remove(left)
+    left_depth = sequent.left_get_depth(left)
+    new_a.left_add(left.formula_a)
+    new_a.left_set_depth(left.formula_a, left_depth + 1)
+    new_b.left_add(left.formula_b)
+    new_b.left_set_depth(left.formula_b, left_depth + 1)
+    unless new_a.siblings.nil?
+      new_a.siblings.push(new_a)
+    end
+    unless new_b.siblings.nil?
+      new_b.siblings.push(new_b)
+    end
+    [new_a, new_b]
+  end
+
+  def derivation_left_implies(sequent, left)
+    new_a = sequent.deepen
+    new_b = sequent.deepen
+    new_a.left_remove(left)
+    new_b.left_remove(left)
+    left_depth = sequent.left_get_depth(left)
+    new_a.right_add(left.formula_a)
+    new_a.right_set_depth(left.formula_a, left_depth + 1)
+    new_b.left_add(left.formula_b)
+    new_b.left_set_depth(left.formula_b, left_depth + 1)
+    unless new_a.siblings.nil?
+      new_a.siblings.push(new_a)
+    end
+    unless new_b.siblings.nil?
+      new_b.siblings.push(new_b)
+    end
+    [new_a, new_b]
+  end
+
+  def derivation_left_for_all(sequent, left)
+    new = sequent.deepen(enable_siblings: true)
+    left_depth = sequent.left_get_depth(left)
+    new.left_set_depth(left, left_depth + 1)
+    formula = left.formula.replace(
+      left.variable,
+      UnificationTerm.new(sequent.get_variable_name('t'))
+    )
+    formula.set_instantiation_time(sequent.depth + 1)
+    unless new.left.include?(formula)
+      new.left_add(formula)
+      new.left_set_depth(formula, left_depth + 1)
+    end
+    unless new.siblings.nil?
+      new.siblings.push(new)
+    end
+    [new]
+  end
+
+  def derivation_left_there_exists(sequent, left)
+    new = sequent.deepen
+    new.left_remove(left)
+    left_depth = sequent.left_get_depth(left)
+    variable = Variable.new(sequent.get_variable_name('v'))
+    formula = left.formula.replace(left.variable, variable)
+    formula.set_instantiation_time(sequent.depth + 1)
+    new.left_add(formula)
+    new.left_set_depth(formula, left_depth + 1)
+    unless new.siblings.nil?
+      new.siblings.push(new)
+    end
+    [new]
+  end
+
+  def derivation_right_not(sequent, right)
+    new = sequent.deepen
+    new.right_remove(right)
+    new.left_add(right.formula)
+    new.left_set_depth(right.formula, (sequent.right_get_depth(right) + 1))
+    unless new.siblings.nil?
+      new.siblings.push(new)
+    end
+    [new]
+  end
+
+  def derivation_right_and(sequent, right)
+    new_a = sequent.deepen
+    new_b = sequent.deepen
+    new_a.right_remove(right)
+    new_b.right_remove(right)
+    right_depth = sequent.right_get_depth(right)
+    new_a.right_add(right.formula_a)
+    new_a.right_set_depth(right.formula_a, right_depth + 1)
+    new_b.right_add(right.formula_b)
+    new_b.right_set_depth(right.formula_b, right_depth + 1)
+    unless new_a.siblings.nil?
+      new_a.siblings.push(new_a)
+    end
+    unless new_b.siblings.nil?
+      new_b.siblings.push(new_b)
+    end
+    [new_a, new_b]
+  end
+
+  def derivation_right_or(sequent, right)
+    new = sequent.deepen
+    new.right_remove(right)
+    right_depth = sequent.right_get_depth(right)
+    new.right_add(right.formula_a)
+    new.right_set_depth(right.formula_a, right_depth + 1)
+    new.right_add(right.formula_b)
+    new.right_set_depth(right.formula_b, right_depth + 1)
+    unless new.siblings.nil?
+      new.siblings.push(new)
+    end
+    [new]
+  end
+
+  def derivation_right_implies(sequent, right)
+    new = sequent.deepen
+    new.right_remove(right)
+    right_depth = sequent.right_get_depth(right)
+    new.left_add(right.formula_a)
+    new.left_set_depth(right.formula_a, right_depth + 1)
+    new.right_add(right.formula_b)
+    new.right_set_depth(right.formula_b, right_depth + 1)
+    unless new.siblings.nil?
+      new.siblings.push(new)
+    end
+    [new]
+  end
+
+  def derivation_right_for_all(sequent, right)
+    new = sequent.deepen
+    new.right_remove(right)
+    right_depth = sequent.right_get_depth(right)
+    variable = Variable.new(sequent.get_variable_name('v'))
+    formula = right.formula.replace(right.variable, variable)
+    formula.set_instantiation_time(sequent.depth + 1)
+    new.right_add(formula)
+    new.right_set_depth(formula, right_depth + 1)
+    unless new.siblings.nil?
+      new.siblings.push(new)
+    end
+    [new]
+  end
+
+  def derivation_right_there_exists(sequent, right)
+    new = sequent.deepen(enable_siblings: true)
+    right_depth = sequent.right_get_depth(right)
+    new.right_set_depth(right, right_depth + 1)
+    formula = right.formula.replace(
+      right.variable,
+      UnificationTerm.new(sequent.get_variable_name('t'))
+    )
+    unless new.right.include?(formula)
+      formula.set_instantiation_time(sequent.depth + 1)
+      new.right_add(formula)
+    end
+    new.right_set_depth(formula, right_depth + 1)
+    unless new.siblings.nil?
+      new.siblings.push(new)
+    end
+    [new]
+  end
+
+  private
+  def apply_left?(sequent, left, right)
+    return true if right.nil?
+    return false if left.nil?
+    sequent.right_get_depth(right) > sequent.left_get_depth(left)
+  end
+end