rubylog 1.0.0 → 2.0pre1

data/examples/checkmate.rb

@@ -0,0 +1,88 @@
+require "rubylog"
+
+
+rubylog do
+  predicate_for Array, ".on()"
+
+  black, white = 0, 1
+  pawn,rook,knight,bishop,queen,king = :pawn, :rook, :knight, :bishop, :queen, :king
+
+  mark = :mark
+
+  signs = {pawn: "p", rook:"r", knight:"n", bishop:"b", queen:"q", king:"k", mark:"x"}
+
+  [black,pawn]  .on! [5,7]
+  [black,bishop].on! [8,1]
+  [black,pawn]  .on! [8,5]
+  [black,king]  .on! [8,6]
+
+  [white,pawn]  .on! [1,7]
+  [white,king]  .on! [1,8]
+  [white,bishop].on! [2,8]
+  [white,pawn]  .on! [3,7]
+  [white,pawn]  .on! [5,5]
+  [white,pawn]  .on! [6,6]
+  [white,knight].on! [6,8]
+  [white,bishop].on! [7,2]
+  [white,pawn]  .on! [7,7]
+  [white,pawn]  .on! [8,4]
+
+  predicate ":show"
+
+  :show.if do
+    (R_.in(1..8).and(R.is{9-R_})).each do
+      F.in(1..8).each do
+        print '.' unless prove [C,P].on([F,R]).and :cut!.and { print C==white ? signs[P].upcase : signs[P]; true }
+      end
+      puts
+    end
+    puts
+    true
+  end
+
+  functor_for Rubylog::Structure, :attacks, :can_move_to
+  functor_for Integer, :rook_move, :bishop_move, :squares, :squares_forward
+  prefix_functor :knight_move, :pawn_attack, :pawn_move
+
+
+  [C,king    ].on(S).can_move_to(S1).if   1.  rook_move(S,S1).or 1.bishop_move(S,S1)
+  [C,queen   ].on(S).can_move_to(S1).if ANY.  rook_move(S,S1).or ANY.bishop_move(S,S1)
+  [C,bishop  ].on(S).can_move_to(S1).if ANY.bishop_move(S,S1)
+  [C,knight  ].on(S).can_move_to(S1).if     knight_move(S,S1)
+  [C,rook    ].on(S).can_move_to(S1).if ANY.  rook_move(S,S1)
+
+  [white,pawn].on(S).can_move_to(S1).if       pawn_move(S,S1)
+  [black,pawn].on(S).can_move_to(S1).if       pawn_move(S1,S)
+  [white,pawn].on([F,2]).can_move_to!([F,4])
+  [black,pawn].on([F,7]).can_move_to!([F,5])
+
+  [white,pawn].on(S).attacks(S1).if! pawn_attack(S,S1)
+  [black,pawn].on(S).attacks(S1).if! pawn_attack(S1,S)
+  X.attacks(S1).if X.can_move_to(S1)
+
+
+  N.squares_forward(A[1..8],B[1..8]).if B.is(A,:+,N)
+  N.squares(A,B).if A.in(1..8).and B.in(1..8).and B.is(A,:+,N).or A.is(B,:+,N)
+
+  N.  rook_move([F ,R1],[F ,R2]).if N.squares(R1,R2)
+  N.  rook_move([F1,R ],[F2,R ]).if N.squares(F1,F2)
+  N.bishop_move([F1,R1],[F2,R2]).if N.squares(R1,R2).and N.squares(F1,F2)
+
+  knight_move([F1,R1],[F2,R2]).if((1.squares(F1,F2).and 2.squares(R1,R2))
+                               .or(1.squares(R1,R2).and 2.squares(F1,F2)))
+  pawn_move(  [F ,R1],[F ,R2]).if 1.squares_forward(R1,R2)
+  pawn_attack([F1,R1],[F2,R2]).if R2.is(R1,:+,1).and 1.squares(F1,F2)
+
+
+  functor_for Rubylog::Structure, :moved_to
+
+  [C,P].on(S).moved_to(S1).if [C,P].on(S).and [C,P].on(S).can_move_to(S1).and [C,P].on(S).revoked.and [C,P].on(S1).assumed
+
+  solve :show.and [C,P].on(S).moved_to(S1).and{ puts "#{C} #{P}: #{S} -> #{S1}"; true}.and :show
+
+
+
+
+
+
+end

data/examples/combination.rb

@@ -0,0 +1,17 @@
+require "rubylog"
+extend Rubylog::Context
+
+predicate_for Array, ".choose(,,)"
+predicate_for Integer, ".one_less_than()"
+
+N.one_less_than(M).if M.sum_of(N,1)
+
+L.choose!(0,[],L)
+[A,*REST].choose(N[thats>0],CHOSEN,[A,*REM]).if REST.choose(N,CHOSEN,REM)
+[A,*REST].choose(N[thats>0],[A,*CHOSEN],REM).if N1.one_less_than(N).and REST.choose(N1,CHOSEN,REM)
+
+[1,2,3,4,5].choose(3,L,ANY).each do
+  L.choose(1,[A],REM).each do
+    puts "#{A}: #{REM}"
+  end
+end

data/examples/dcg.rb

@@ -1,8 +1,9 @@
+require "rubylog"
 # This is a quick and dirty solution to replace Prolog's DCG syntax.
 # It is slow for long inputs. See examples/dcg2.rb for a more efficient algorithm (the same as Prolog's DCG).
 
-theory do
-  functor_for Array, :sentence, :subject, :object, :nominal_phrase, :noun, :verb, :article
+rubylog do
+  predicate_for Array, ".sentence", ".subject", ".object", ".nominal_phrase", ".noun", ".verb", ".article"
 
   [*S,*V,*O].sentence.if S.subject.and V.verb.and O.object
   S.subject.if S.nominal_phrase

data/examples/dcg2.rb

@@ -4,8 +4,8 @@
 $:.unshift File.dirname(__FILE__)+"/../lib"
 require 'rubylog'
 
-theory do
-  functor_for Array, :sentence, :subject, :object, :nominal_phrase, :noun, :verb, :article
+rubylog do
+  predicate_for Array, ".sentence()", ".subject()", ".object()", ".nominal_phrase()", ".noun()", ".verb()", ".article()"
 
   # sentence --> subject, verb, object
   Se.sentence(L3).if Se.subject(L1).and L1.verb(L2).and L2.object(L3)

data/{logic → examples}/directory_structure_logic.rb

@@ -1,9 +1,7 @@
-require "./lib/rubylog/builtins/file_system"
+require "rubylog"
 
-theory do
-  subject String
-  functor :dir, :contains
-  check_discontiguous false
+rubylog do
+  predicate_for String, ".dir", ".contains()"
 
   ".git".dir!.contains! "Git repository"
   "bin".dir!.contains! "executables"

data/examples/dirlist.rb

@@ -0,0 +1,4 @@
+require "rubylog"
+extend Rubylog::Context
+
+

data/examples/divisors.rb

@@ -0,0 +1,6 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require "rubylog"
+
+extend Rubylog::Context
+
+p (P.is(672).and A.in{1..P}.and P.product_of(A,B).and{A<=B}).count

data/examples/enumerators.rb

@@ -1,9 +1,9 @@
 $:.unshift File.dirname(__FILE__)+"/../lib"
 require 'rubylog'
 
-theory do
-  subject Symbol
-  functor :likes
+rubylog do
+  self.default_subject = Symbol
+  predicate ".likes()"
 
   :john.likes! :beer
   :john.likes! :milk

data/examples/factorial.rb

@@ -1,9 +1,8 @@
 $:.unshift File.dirname(__FILE__)+"/../lib"
 require 'rubylog'
 
-FactorialTheory = theory do
-  subject Integer
-  functor :factorial
+rubylog do
+  predicate_for Integer, ".factorial()"
 
   0.factorial! 1
   N[thats > 0].factorial(K).if \

data/examples/file_search.rb

@@ -0,0 +1,14 @@
+require "rubylog"
+extend Rubylog::Context
+
+predicate_for String, "FILE.found_in(DIR)"
+
+FILE.found_in(DIR).if FILE.file_in(DIR)
+FILE.found_in(DIR).if DIR2[thats_not =~ /\/\./].dir_in(DIR).and FILE.found_in(DIR2)
+
+"lib/#{X}.rb".found_in("lib").and "lib/#{X}"
+"#{X}/spec/#{S}_spec.rb".found_in("spec").each do
+  puts S
+end
+
+

data/examples/hanoi.rb

@@ -1,9 +1,8 @@
 $:.unshift File.dirname(__FILE__)+"/../lib"
 require "rubylog"
 
-theory do
-  functor_for Integer, :move, :hanoi
-  prefix_functor :write_info
+rubylog do
+  predicate_for Integer, ".move(,,)", ".hanoi"
 
   0.move(ANY,ANY,ANY).if :cut!
   N.move(A,B,C).if (
@@ -15,10 +14,10 @@ theory do
   N.hanoi.if N.move('left', 'right', 'center')
 
   puts "\nWhat's the solution for a single disc?"
-  prove 1.hanoi
+  solve 1.hanoi
 
   puts "\n\nWhat's the solution for 5 discs?"
-  prove 5.hanoi
+  solve 5.hanoi
 
 
 end

data/examples/hello.rb

@@ -3,13 +3,15 @@ $:.unshift File.dirname(__FILE__)+"/../lib"
 require 'rubylog'
 
 
-HelloTheory = theory do
-  functor_for String, :written
+rubylog do
+  predicate_for String, ".written :hello"
 
   X.written.if {puts X; true}
 
-  :hello.if "Hello, world!".written
+  :hello.if "Hello world!".written
 end
 
-HelloTheory.prove :hello
+rubylog do
+  solve :hello
+end
 

data/examples/mice.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+$:.unshift File.dirname(__FILE__)+"/../lib"
+# This is a solution for a math problem.
+#
+# Mafia the black cat plays a game. She has N cups with 0 or 1 mouse under each.
+# She peeks under some cups one by one to see if there is a mouse under them.
+# What she wants to find out is whether there are two cups next to each other
+# which both have a mouse. She found that for some number of cups she has to
+# peek under every cup to decide if there are two adjacent ones with a mouse.
+# In this case she considers the task hard. For which N's does she consider it
+# hard (N<=2013)?
+
+require "rubylog"
+require "rubylog/builtins/assumption"
+extend Rubylog::Context
+
+
+class Cup < Struct.new :i
+  extend Rubylog::Context
+
+  def inspect
+    "##{i}"
+  end
+
+  # A cup can be peeked: it has mouse or not
+  predicate %w(.peeked .has_mouse .seen )
+  C.peeked.if C.has_mouse.assumed.or(:true).and C.seen.assumed
+
+  # A cup can be guessed: it has mouse or not
+  predicate %w(.guessed)
+  C.guessed.if C.has_mouse.assumed.or(:true)
+
+end
+
+
+class CupSet
+  extend Rubylog::Context
+
+  def initialize n
+    @cups = (1..n).map {|i| Cup.new i }
+  end
+
+  def each &block
+    @cups.each &block
+  end
+
+  def [] index
+    @cups[index]
+  end
+
+  # A set has neighbors if 
+  predicate %w(.has_neighbors)
+  CS.has_neighbors.if [C,D].in{CS[0..-2].zip(CS[1..-1] || [])}.and C.has_mouse.and D.has_mouse
+
+  # A predicate definitely solves a set if there is no ambiguity
+  predicate_for Rubylog::Clause, %w(.definitely_solves())
+  T.definitely_solves(CS).if T.any(CS.has_neighbors).and(T.any(CS.has_neighbors.false)).false
+
+  # A trial consist of peeking some cups
+  predicate_for Rubylog::Clause, %w(.trial_for())
+  T.trial_for(CS).if T.is{C.in(CS).map{C.peeked.or :true}.inject(:true,&:and)}.and T
+
+  # A set is easy if can be definitely solved by a trial that has not seen all
+  # cups. A set is had if it cannot.
+  predicate %w(.easy() .hard)
+  CS.easy(Peeks).if any T.trial_for(CS).and(C.in(CS).all(C.seen).false).definitely_solves(CS).and(Peeks.is{D.in(CS).and(D.peeked).map{D}})
+  CS.hard.if CS.easy.false
+
+end
+
+
+N.in(0..4).each do
+  puts "#{N}:"
+  CS.is{CupSet.new(N)}.each do
+
+    C.in{CS}.each { p C }
+    T.trial_for(CS).each { p T }
+
+    easy = false
+    CS.easy(Peeks).each do
+      puts "easy: #{Peeks.inspect}"
+      easy = true
+    end
+    puts "hard" if not easy
+  end
+  puts
+end
+
+
+
+
+

data/examples/mice2.rb

@@ -0,0 +1,19 @@
+require "rubylog"
+extend Rubylog::Context
+
+predicate_for Array, ".array(N) Peek.matches(Guess)"
+
+[].peek!(0)
+[K,*REST].mice(N[thats>0]).if K.in([0,1]).and N.sum_of(N1,1).and REST.mice(N1)
+
+[].seen!([])
+[0,*REST].seen([nil,*REST2]).if REST.seen(REST2)
+[1,*REST].seen([A,*REST2]).if A.in([0,1]).and REST.seen(REST2)
+
+[].guess!([])
+[nil,*REST].guess([A,*REST2]).if A.in([0,1]).and REST.guess(REST2)
+[0,*REST].guess([0,*REST2]).if A.in([0,1]).and REST.guess(REST2)
+[1,*REST].guess([1,*REST2]).if A.in([0,1]).and REST.guess(REST2)
+
+solve N.is(6).and any Peek.peek(N), all(Peek.seen(Seen), all(Guess.guess(Seen), Guess.has_neighbors.false).or(all(Guess.guess(Seen), Guess.has_neighbors)))
+

data/examples/n_queens.rb

@@ -0,0 +1,32 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require "rubylog"
+
+rubylog do
+  predicate_for Integer, ".on(,)", ".attacks(,)", ".placed"
+  predicate ":arranged"
+
+  N=7
+
+  A.attacks(R,ANY_C).if A.on(R,ANY_C)
+  A.attacks(ANY_R,C).if A.on(ANY_R,C)
+  A.attacks(R2,C2).if A.on(R1,C1).and {R1-C1==R2-C2}
+  A.attacks(R2,C2).if A.on(R1,C1).and {R1+C1==R2+C2}
+
+  A.placed.if \
+    C.in(1..N).and(B.on(ANY,ANY).none(B.attacks(A,C))).and A.on(A,C).assumed
+
+  :arranged.if every A.in(1..N), A.placed
+
+  :arranged.solve do
+    L.in(1..N).each do
+      M.in(1..N).each do
+        print ANY.on?(L,M) ? "X" : "."
+      end
+      puts
+    end
+    puts
+  end
+
+
+end
+

data/examples/object_oriented.rb

@@ -0,0 +1,14 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require "rubylog"
+
+class User
+  extend Rubylog::Context
+  predicate_for self, ".user", ".admin"
+
+  def initialize admin=false
+    self.user!
+    self.admin! if admin
+  end
+end
+
+

data/examples/palindrome_detection.rb

@@ -0,0 +1,18 @@
+require "rubylog"
+extend Rubylog::Context
+
+predicate_for String, ".palindrome"
+
+S[length: 0..1].palindrome!
+S.palindrome.if S.is("#{A[length: 1]}#{B}#{A}").and B.palindrome
+
+check "".palindrome
+check "a".palindrome
+check "aa".palindrome
+check "aba".palindrome
+check "abba".palindrome
+check "ababa".palindrome
+check "ab".palindrome.false
+check "abb".palindrome.false
+check "abbc".palindrome.false
+check "ababab".palindrome.false

data/examples/parsing.rb

@@ -1,10 +1,12 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require "rubylog"
 require "readline"
 
-theory do
-  functor_for String, :term, :expr, :atom
+rubylog do
+  predicate_for String, ".term()", ".expr()", ".atom()"
 
-  "#{A}+#{B}".expr(K).if A.term(I).and B.expr(J).and K.is{I+J}
-  "#{A}-#{B}".expr(K).if A.term(I).and B.expr(J).and K.is{I-J}
+  "#{A}+#{B}".expr(K).if A.expr(I).and B.term(J).and K.is{I+J}
+  "#{A}-#{B}".expr(K).if A.expr(I).and B.term(J).and K.is{I-J}
   A.expr(K).if A.term(K)
   "#{A}*#{B}".term(K).if A.atom(I).and B.term(J).and K.is{I*J}
   "#{A}/#{B}".term(K).if A.atom(I).and B.term(J).and K.is{I/J}

data/examples/permutation.rb

@@ -0,0 +1,12 @@
+require "rubylog"
+extend Rubylog::Context
+predicate_for Array, ".permutation()"
+
+[].permutation! []
+[*FRONT, A, *BACK].permutation([A,*REST]).if [*FRONT,*BACK].permutation(REST)
+
+[1,2,3,4].permutation(P).each do
+  p P
+end
+
+

data/examples/prefix.rb

@@ -0,0 +1,13 @@
+require "rubylog"
+extend Rubylog::Context
+
+predicate_for Kernel, ".hello()"
+
+hello!(2)
+hello(5).if { puts "Hello" }
+
+hello?(5)
+
+check hello(2)
+check hello(4).false
+

data/examples/primality_by_division.rb

@@ -0,0 +1,22 @@
+require "rubylog"
+extend Rubylog::Context
+
+predicate_for Integer, ".prime .odd .divides()"
+
+A.divides(B).if { B%A == 0 }
+A.odd.if 2.divides(A).false
+
+2.prime!
+N[thats>2].prime.if N.odd.and none D[thats.odd?].in{3..Math.sqrt(N)}, D.divides(N)
+
+check 1.prime.false
+check 2.prime
+check 3.prime
+check 4.prime.false
+check 5.prime
+check 6.prime.false
+check 7.prime
+check 8.prime.false
+check 9.prime.false
+check 10.prime.false
+

data/examples/primitives.rb

@@ -1,17 +1,20 @@
 $:.unshift File.dirname(__FILE__)+"/../lib"
 require 'rubylog'
 
-Rubylog.theory "Try" do
-  subject String
+Try = Rubylog.create_context
+Try.instance_eval do
+  predicate ":hello_world"
 
   def primitives.hello
     puts "Hello"
     yield
   end
 
-  def primitives.hello x
-    puts "Hello #{x.rubylog_deep_dereference}!"
-    yield
+  class << primitives_for(String)
+    def hello x
+      puts "Hello #{x.rubylog_deep_dereference}!"
+      yield
+    end
   end
 
   :hello_world.if "World".hello
@@ -19,6 +22,5 @@ Rubylog.theory "Try" do
 end
 
 
-p Try.prove :hello
-p Try.prove :hello_world
-p Try.prove{X.is("World").and X.hello}
+p Try.true? :hello
+p Try.true? :hello_world

data/examples/sieve_of_eratosthenes.rb

@@ -0,0 +1,14 @@
+require "rubylog"
+extend Rubylog::Context
+
+predicate_for Integer, ".sieve .prime .nonprime .multiple_of(N,Limit)"
+
+A.multiple_of(N,Limit).if I.in{(0..Limit/N)}.and A.is{N*I}
+
+N.sieve.if X.in{2..N}.all X.nonprime.or(
+  proc{X.prime!}.and M.multiple_of(X,N).all{M.nonprime!}
+)
+
+100.sieve.solve
+
+p A.in(1..100).and(A.prime).map{A}

data/examples/string_interpolation.rb

@@ -0,0 +1,4 @@
+require "rubylog"
+extend Rubylog::Context
+
+solve S.is("Mary had a #{X} lamb.").and X.is("little").and { puts S }

data/examples/sudoku.rb

@@ -0,0 +1,52 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require "rubylog"
+
+class Sudoku
+  def initialize
+    @rows = (1..9).map{(1..9).map{Rubylog::Variable.new}}
+  end
+
+  attr_reader :rows
+  
+  def columns
+    @rows.transpose
+  end
+
+  def blocks
+    (0..2).map {|a| (0..2).map {|b| (0..2).map {|c| (0..2).map {|d| 
+      @rows[a*3+c][b*3+d]
+    }}.flatten(1) }}.flatten(1)
+  end
+
+  extend Rubylog::Context
+
+  predicate_for Array, ".unique"
+  L.unique.unless L.is [*ANY, X, *ANY, X, *ANY]
+
+  predicate ".solved .good .shown .given(s)"
+  S.solved.if every L.in{S.rows}.and(F.in(L)), F.in(1..9)
+  S.good.if all(T.in{[S.rows, S.columns, S.blocks]}.and(L.in{T}), L.unique)
+
+  S.shown.if do
+    L.in{S.rows}.each do
+      p L
+    end
+    puts 
+    true
+  end
+
+  _=ANY
+  solve S.is{Sudoku.new}.and lambda{S.rows}.is([
+                                     [5,_,_,_,2,4,7,_,_],
+                                     [_,_,2,_,_,_,8,_,_],
+                                     [1,_,_,7,_,3,9,_,2],
+                                     [_,_,8,_,7,2,_,4,9],
+                                     [_,2,_,9,8,_,_,7,_],
+                                     [7,9,_,_,_,_,_,8,_],
+                                     [_,_,_,_,3,_,5,_,6],
+                                     [9,6,_,_,1,_,3,_,_],
+                                     [_,5,_,6,9,_,_,1,_]
+  ]).and S.solved.and S.good.and S.shown rescue p $!
+end
+
+

data/examples/tracing.rb

@@ -0,0 +1,19 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require "rubylog"
+extend Rubylog::Context
+
+# no trace
+solve S.is("Hello #{X}!").and X.is("no Trace") do puts S end
+
+# tracing with on/off
+Rubylog.trace!
+solve S.is("Hello #{X}!").and X.is("Trace") do puts S end
+Rubylog.trace!(false)
+
+# no trace again
+solve S.is("Hello #{X}!").and X.is("no Trace again") do puts S end
+
+# tracing with block
+Rubylog.trace do
+  solve S.is("Hello #{X}!").and X.is("Trace with block") do puts S end
+end

data/lib/rspec/rubylog.rb

@@ -0,0 +1,29 @@
+require "rspec"
+require "rubylog"
+
+# This module is included in RSpecExampleGroup's with rubylog:true metadata.
+#
+module Rubylog::RSpecExampleGroup
+  def self.included example_group
+    # Make it a context
+    example_group.extend Rubylog::Context
+  end
+end
+
+RSpec.configure do |c|
+
+  # enable use of Rubylog in example groups
+  c.include Rubylog::RSpecExampleGroup, :rubylog => true
+
+  # enable use of Rubylog in examples
+  c.before do
+    # when :rubylog=>true is given
+    if self.class.metadata[:rubylog]
+      # create the context from the example
+      # this initializes the context
+      Rubylog.create_context self
+    end
+  end
+end
+
+