pomegranate 0.9

data/lib/pomegranate.rb

@@ -0,0 +1,29 @@
+# This file is part of Pomegranate
+# 
+# Pomegranate is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# Pomegranate is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with Pomegranate.  If not, see <http://www.gnu.org/licenses/>.
+
+
+require 'rubygems'
+require 'pathname'
+require 'ruleby'
+include Ruleby
+
+class Pathname
+  def /(path)
+    (self + path).expand_path
+  end
+end # class Pathname
+
+dir = Pathname(__FILE__).dirname.expand_path / 'pomegranate'
+require dir / 'rdfs_plus_rulebook'

data/lib/pomegranate/rdfs_plus_rulebook.rb

@@ -0,0 +1,327 @@
+# This file is part of the Pomegranate project (http://pius.github.com/pomegranate/)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2008 Pius Uzamere. All rights reserved.
+#
+# * Authors: Pius Uzamere
+#
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+require 'lib/pomegranate/rdfs_rulebook'
+
+class RdfsPlusRulebook < RdfsRulebook
+  
+  def rules
+    rdfs_rules
+    rdfs_plus_rules
+  end
+  
+  #nodoc
+  def rdfs_plus_rules
+    ## 
+    # Implements Type Propagation through owl:inverseOf
+    #
+    # ==== Semantics
+    #   Given:
+    #   P owl:inverseOf Q
+    #   x P y
+    #
+    #   Infer:
+    #   y Q x
+    #
+    # ==== Example
+    #   p = Triple.new(":Pius", ":took_a_class_taught_by", ":Winston"); 
+    #   h = Triple.new(":took_a_class_taught_by", "owl:inverseOf", ":taught") 
+    #   assert p; assert h;  #=> infers a triple ~= Triple.new(":Winston", "taught", ":Pius")
+    #
+    # @author Pius Uzamere
+    def owl_inverse_of
+    end
+    
+    rule :owl_inverse_of,
+      [Triple,:fact,{m.predicate=>:pred, m.object => :new_subj, m.subject => :new_obj}],
+      [Triple,:ont_statement,{m.object => :inferred_pred},m.predicate=="owl:inverseOf", m.subject == b(:pred)],
+      [:not, Triple, m.predicate==b(:inferred_pred), m.subject==b(:new_subj), m.object==b(:new_obj)] do |v|
+        inferred_property = v[:ont_statement].object
+        obj = v[:fact].subject
+        subj = v[:fact].object
+        assert Triple.new(subj, inferred_property, obj)
+        puts "Made type inference based on owl:inverseOf: Triple(#{subj}, #{inferred_property}, #{obj})"
+    end
+    
+    ## 
+    # Implements Type Propagation through owl:SymmetricProperty
+    #
+    # ==== Semantics
+    #   Given:
+    #   P rdf:type owl:SymmetricProperty
+    #
+    #   Infer:
+    #   P owl:inverseOf P
+    #
+    # ==== Example
+    #   p = Triple.new(":Pius", ":was_in_a_class_with", ":Adam"); 
+    #   h = Triple.new(":was_in_a_class_with", "rdf:type", "owl:SymmetricProperty") 
+    #   assert p; assert h;  #=> infers a triple ~= Triple.new(":Adam", ":was_in_a_class_with", ":Pius")
+    #
+    # @author Pius Uzamere
+    def owl_symmetric_property
+    end
+    
+    rule :owl_symmetric_property,
+      [Triple,:ont_statement,m.predicate=="rdf:type",m.object=="owl:SymmetricProperty"] do |v|
+        prop = v[:ont_statement].subject
+        assert Triple.new(prop, "owl:inverseOf", prop)
+        puts "Made type inference based on owl:SymmetricProperty: Triple(#{prop}, owl:inverseOf, #{prop})"
+    end
+    
+    ## 
+    # Implements Type Propagation through owl:TransitiveProperty
+    #
+    # ==== Semantics
+    #   Given:
+    #   P rdf:type owl:TransitiveProperty
+    #   X P Y
+    #   X P Z
+    #
+    #   Infer:
+    #   X P Z
+    #
+    # ==== Example
+    #   p = Triple.new(":Dirichlet", ":is_an_academic_ancestor_of", ":Minsky"); 
+    #   h = Triple.new(":Poisson", ":is_an_academic_ancestor_of", ":Dirichlet");
+    #   j = Triple.new(":is_an_academic_ancestor_of", "rdf:type", "owl:TransitiveProperty"); 
+    #   assert p; assert h; assert j;  #=> infers a triple ~= Triple.new(":Poisson", ":is_an_academic_ancestor_of", ":Minsky")
+    #
+    # @author Pius Uzamere
+    def owl_transitive_property
+    end
+        
+    rule :owl_transitive_property,
+      [Triple,:ont_statement,{m.subject => :trans_prop},m.predicate=="rdf:type",m.object=="owl:TransitiveProperty"],
+      [Triple,:fact1,{m.predicate=>:predi, m.subject => :sub, m.object => :trans_obj}, m.predicate == b(:trans_prop), m.subject.not== m.object],
+      [Triple,:fact2, m.predicate==b(:predi), m.subject==b(:trans_obj), m.predicate.not=="owl:inverseOf", m.object.not== b(:sub) ] do |v|
+        subj = v[:fact1].subject
+        obj = v[:fact2].object
+        prop = v[:ont_statement].subject
+        assert Triple.new(subj, prop, obj)
+        puts "Made type inference based on owl:TransitiveProperty: Triple(#{subj}, #{prop}, #{obj})"
+    end
+    
+    ## 
+    # Implements Class Equivalence through owl:equivalentClass
+    #
+    # ==== Semantics
+    #   Given:
+    #   A owl:equivalentClass B
+    #   r rdf:type A
+    #   
+    #   Infer:
+    #   r rdf:type B
+    #
+    #      AND
+    #
+    #   Given:
+    #   C owl:equivalentClass D
+    #   C rdfs:subClassOf D
+    #   z rdf:type D
+    #
+    #   Infer:
+    #   z rdf:type C
+    #
+    # ==== Example
+    #   p = Triple.new("mit:class", "owl:equivalentClass", "mit:subject"); 
+    #   h = Triple.new(":6.111", "rdf:type", "mit:class");
+    #   assert p; assert h; #=> infers a triple ~= Triple.new(":6.111", ":rdf:type", ":mit:subject")
+    #
+    # @author Pius Uzamere
+    def owl_equivalent_class
+    end
+    
+    rule :owl_equivalent_class,
+      [Triple,:ont_statement,m.predicate=="owl:equivalentClass"] do |v|
+        assert Triple.new("owl:equivalentClass", "rdf:type", "owl:SymmetricProperty")
+        assert Triple.new("owl:equivalentClass", "rdfs:subPropertyOf", "rdfs:subClassOf")
+        #this is cute . . . only annoying thing is that you don't get the downstream explanation of the inferences
+    end
+    
+    
+    ## 
+    # Implements Property Equivalence through owl:equivalentProperty
+    #
+    # ==== Semantics
+    #   Given:
+    #   A owl:equivalentProperty B
+    #   r A c
+    #   
+    #   Infer:
+    #   r B C
+    #
+    #      AND
+    #
+    #   Given:
+    #   C owl:equivalentClass D
+    #   C rdfs:subClassOf D
+    #   z rdf:type D
+    #
+    #   Infer:
+    #   z rdf:type C
+    #
+    # ==== Example
+    #   p = Triple.new("mit:took_class", "owl:equivalentProperty", "mit:took_course"); 
+    #   h = Triple.new(":Pius", "mit:took_course", ":6.111");
+    #   assert p; assert h; #=> infers a triple ~= Triple.new(":Pius", "mit:took_class", ":6.111")
+    #
+    # @author Pius Uzamere
+    
+    def owl_equivalent_property
+    end
+    
+    rule :owl_equivalent_property,
+      [Triple,:ont_statement,m.predicate=="owl:equivalentProperty"] do |v|
+        assert Triple.new("owl:equivalentProperty", "rdf:type", "owl:SymmetricProperty")
+        assert Triple.new("owl:equivalentProperty", "rdfs:subPropertyOf", "rdfs:subPropertyOf")
+        #this is cute . . . only annoying thing is that you don't get the downstream explanation of the inferences
+    end
+
+    ## 
+    # Implements Individual Equivalence through owl:sameAs
+    #
+    # ==== Semantics
+    #   Given:
+    #   x owl:sameAs y
+    #   o P x
+    #   
+    #   Infer:
+    #   o P y
+    #
+    #      AND
+    #
+    #   Given:
+    #   x owl:sameAs y
+    #   x P o
+    #
+    #   Infer:
+    #   z rdf:type C
+    #
+    # ==== Example
+    #   p = Triple.new(":Pius", "owl:sameAs", ":Uzamere"); 
+    #   h = Triple.new(":Pius", "mit:took_course", ":6.171");
+    #   assert p; assert h; #=> infers a triple ~= Triple.new(":Uzamere", "mit:took_course", ":6.171")
+    #
+    # @author Pius Uzamere
+    
+    def owl_same_as
+    end
+    
+    rule :owl_same_as_symmetricity,
+      [Triple,:ont_statement, m.predicate=="owl:sameAs"] do |v|
+      assert Triple.new("owl:sameAs", "rdf:type", "owl:SymmetricProperty")
+      puts "asserting the symmetricity of owl:sameAs"
+    end
+    
+    
+    rule :owl_same_as_when_subject,
+
+      [Triple,:ont_statement,{m.subject => :original, m.object => :doppelganger}, m.predicate=="owl:sameAs"],
+      [Triple,:fact, {m.predicate => :p, m.object => :common_object}, m.subject == b(:original), m.subject.not== b(:doppelganger), m.predicate.not== "owl:sameAs"],
+      [:not, Triple, m.predicate==b(:p), m.subject==b(:doppelganger), m.object==b(:common_object)] do |v|
+
+      subj = v[:ont_statement].object
+      pred = v[:fact].predicate
+      obj = v[:fact].object
+      
+      puts "Made type inference based on owl:sameAs: Triple(#{subj}, #{pred}, #{obj})"
+      assert Triple.new(subj, pred, obj)
+      #this is cute . . . only annoying thing is that you don't get the downstream explanation of the inferences
+    end
+    
+    rule :owl_same_as_when_object,
+      [Triple,:ont_statement,{m.object => :original, m.subject => :doppelganger}, m.predicate=="owl:sameAs"],
+      [Triple,:fact, {m.predicate => :p, m.object => :ob, m.subject => :common_subject}, m.object == b(:original), m.object.not== b(:doppelganger), m.predicate.not== "owl:sameAs"],
+      [:not, Triple, m.predicate==b(:p), m.subject==b(:common_subject), m.object==b(:doppelganger)] do |v|
+
+      obj = v[:ont_statement].subject
+      pred = v[:fact].predicate
+      subj = v[:fact].subject
+      
+      puts "Made type inference based on owl:sameAs: Triple(#{subj}, #{pred}, #{obj})"
+      assert Triple.new(subj, pred, obj)
+      #this is cute . . . only annoying thing is that you don't get the downstream explanation of the inferences
+    end
+    
+    ## 
+    # owl:FunctionalProperty
+    #
+    # ==== Semantics
+    #   Given:
+    #   P rdf:type owl:FunctionalProperty
+    #   x P y
+    #   x P z
+    #   
+    #   Infer:
+    #   y owl:sameAs z
+    #
+    # ==== Example
+    #   p = Triple.new("mit:had_academic_advisor", "rdf:type", "owl:FunctionalProperty");
+    #   h = Triple.new(":Pius", "mit:had_academic_advisor", ":Hal");
+    #   d = Triple.new(":Pius", "mit:had_academic_advisor", ":Dude_Who_Wrote_SICP_With_Gerald_Sussman");
+    #   assert p; assert h; assert d; #=> infers a triple ~= Triple.new(":Hal", "owl:sameAs", ":Dude_Who_Wrote_SICP_With_Gerald_Sussman")
+    #
+    # @author Pius Uzamere
+    
+    def owl_functional_property
+    end
+    
+    rule :owl_functional_property,
+      [Triple,:ont_statement,{m.subject => :the_prop}, m.predicate == "rdf:type", m.object=="owl:FunctionalProperty"],
+      [Triple,:fact1, {m.subject => :common_subject, m.object => :first_object}, m.predicate == b(:the_prop)],
+      [Triple,:fact2, {m.object => :second_object}, m.subject == b(:common_subject), m.predicate == b(:the_prop)] do |v|
+
+        subj = v[:fact1].object
+        obj = v[:fact2].object
+        
+        puts "Made type inference based on owl:FunctionalProperty: Triple(#{subj}, owl:sameAs, #{obj})"
+        assert Triple.new(subj, "owl:sameAs", obj)
+    end
+    
+    ## 
+    # owl:InverseFunctionalProperty
+    #
+    # ==== Semantics
+    #   Given:
+    #   P rdf:type owl:InverseFunctionalProperty
+    #   z P x
+    #   y P x
+    #   
+    #   Infer:
+    #   y owl:sameAs z
+    #
+    # ==== Example
+    #   p = Triple.new("mit:lived_alone_fall_2004_in", "rdf:type", "owl:FunctionalProperty");
+    #   h = Triple.new(":Pius", "mit:lived_alone_fall_2004_in", ":pomegranate_314_at_Next_House");
+    #   d = Triple.new(":2004_UA_President", "mit:lived_alone_fall_2004_in", ":pomegranate_314_at_Next_House");
+    #   assert p; assert h; assert d; #=> infers a triple ~= Triple.new(":Pius", "owl:sameAs", ":2004_UA_President")
+    #
+    # @author Pius Uzamere
+    
+    def owl_inverse_functional_property
+    end
+    
+    rule :owl_inverse_functional_property,
+      [Triple,:ont_statement,{m.subject => :the_prop}, m.predicate == "rdf:type", m.object=="owl:InverseFunctionalProperty"],
+      [Triple,:fact1, {m.object => :common_object, m.subject => :first_subject}, m.predicate == b(:the_prop)],
+      [Triple,:fact2, {m.subject => :second_subject}, m.object == b(:common_object), m.predicate == b(:the_prop)] do |v|
+
+        subj = v[:fact1].subject
+        obj = v[:fact2].subject
+        
+        puts "Made type inference based on owl:InverseFunctionalProperty: Triple(#{subj}, owl:sameAs, #{obj})"
+        assert Triple.new(subj, "owl:sameAs", obj)
+    end
+
+  end
+end

data/lib/pomegranate/rdfs_rulebook.rb

@@ -0,0 +1,188 @@
+# This file is part of the Pomegranate project (http://pius.github.com/pomegranate/)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2008 Pius Uzamere. All rights reserved.
+#
+# * Authors: Pius Uzamere
+#
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+require 'rubygems'
+require 'ruleby'
+
+include Ruleby
+
+class Triple
+  def initialize(subject,predicate,object)
+    @subject = subject
+    @predicate = predicate
+    @object= object
+  end  
+  attr:subject, true
+  attr:predicate, true
+  attr:object, true
+  
+  def ==(obj)
+    (@subject == obj.subject) && (@object == obj.object) && (@predicate == obj.predicate)
+  end
+  
+end
+
+
+class RdfsRulebook < Ruleby::Rulebook
+  
+  def rules
+    rdfs_rules
+  end
+  
+  #nodoc
+  def rdfs_rules
+    
+    ## 
+    # Implements Type Propagation through rdfs:subClassOf
+    #
+    # ==== Semantics
+    #   Given:
+    #   A rdfs:subClassOf B
+    #   r rdf:type A
+    #
+    #   Infer:
+    #   r rdf:type B
+    #
+    # ==== Example
+    #   p = Triple.new(":Pius", "rdf:type", ":male"); 
+    #   h = Triple.new(":male", "rdfs:subClassOf", ":human") 
+    #   assert p; assert h;  #=> infers a triple ~= Triple.new(":Pius", "rdf:type", ":human")
+    #
+    # @author Pius Uzamere
+    def rdfs_sub_class_of
+    end
+    
+    rule :rdfs_sub_class_of,
+    #TODO: add a patch to ruleby whereby the parser will raise when there's a no method error (e.g. m.subj)
+      [Triple,:fact,{m.subject => :subj, m.object=>:obj},m.predicate=="rdf:type"],
+      [Triple,:ont_statement,{m.object => :inferred_class },m.predicate=="rdfs:subClassOf", m.subject == b(:obj)],
+      [:not, Triple, m.predicate=="rdf:type", m.subject==b(:subj), m.object==b(:inferred_class)] do |v|
+        inferred_class = v[:ont_statement].object
+        subj = v[:fact].subject
+        assert Triple.new(subj, "rdf:type", inferred_class)
+        puts "Made type inference based on rdfs:subClassOf: Triple(#{subj}, rdf:type, #{inferred_class})"  
+    end
+    
+
+    ## 
+    # Implements Type Propagation through rdfs:subPropertyOf
+    #
+    # ==== Semantics
+    #   Given:
+    #   P rdfs:subPropertyOf R
+    #   A P B
+    #
+    #   Infer:
+    #   A R B
+    #
+    # ==== Example
+    #   p = Triple.new(":Pius", "mit:majored_in", ":Course_6"); 
+    #   h = Triple.new("mit:majored_in", "rdfs:subPropertyOf", "mit:took_some_classes_in") 
+    #   assert p; assert h;  #=> infers a triple ~= Triple.new(":Pius", "mit:took_some_classes_in", ":Course_6")
+    #
+    # @author Pius Uzamere
+    def rdfs_sub_property_of
+    end
+    
+    rule :rdfs_sub_property_of,
+      [Triple,:fact,{m.predicate=>:pred, m.subject => :subj, m.object=>:obj}],
+      [Triple,:ont_statement, {m.object => :inferred_pred}, m.predicate=="rdfs:subPropertyOf", m.subject == b(:pred)],
+      [:not, Triple, m.predicate==b(:inferred_pred), m.subject==b(:subj), m.object==b(:obj)] do |v|
+        inferred_property = v[:ont_statement].object
+        subj = v[:fact].subject
+        obj = v[:fact].object
+        assert Triple.new(subj, inferred_property, obj)
+        puts "Made type inference based on subPropertyOf: Triple(#{subj},#{inferred_property}, #{obj})"  
+    end
+    
+    ## 
+    # Implements Type Propagation through rdfs:domain
+    #
+    # ==== Semantics
+    #   Given:
+    #   P rdfs:domain D
+    #   x P y
+    #
+    #   Infer:
+    #   x rdf:type D
+    #
+    # ==== Example
+    #   p = Triple.new("mit:majored_in", "rdfs:domain", ":student"); 
+    #   h = Triple.new(":Pius", "mit:majored_in", ":Course_17") 
+    #   assert p; assert h;  #=> infers a triple ~= Triple.new(":Pius", "rdf:type", ":student")
+    #
+    # @author Pius Uzamere
+    def rdfs_domain
+    end
+    
+    rule :rdfs_domain,
+      [Triple,:fact,{m.predicate=>:pred}],
+      [Triple,:ont_statement,m.predicate=="rdfs:domain", m.subject == b(:pred)] do |v|
+        inferred_type = v[:ont_statement].object
+        subj = v[:fact].subject
+        assert Triple.new(subj, "rdf:type", inferred_type)
+        puts "Made type inference based on rdfs:domain: Triple(#{subj},rdf:type, #{inferred_type})"  
+    end
+    
+    ## 
+    # Implements Type Propagation through rdfs:range
+    #
+    # ==== Semantics
+    #   Given:
+    #   P rdfs:range R
+    #   x P y
+    #
+    #   Infer:
+    #   y rdf:type R
+    #
+    # ==== Example
+    #   p = Triple.new("mit:majored_in", "rdfs:range", ":major"); 
+    #   h = Triple.new(":Pius", "mit:majored_in", ":Course_17") 
+    #   assert p; assert h;  #=> infers a triple ~= Triple.new(":Pius", "rdf:type", ":student")
+    #
+    # @author Pius Uzamere
+    def rdfs_range
+    end
+    
+    rule :rdfs_range,
+      [Triple,:fact,{m.predicate=>:pred}],
+      [Triple,:ont_statement,m.predicate=="rdfs:range", m.subject == b(:pred)] do |v|
+        inferred_type = v[:ont_statement].object
+        subj = v[:fact].object
+        assert Triple.new(subj, "rdf:type", inferred_type)
+        puts "Made type inference based on rdfs:range: Triple(#{subj},rdf:type, #{inferred_type})"  
+    end
+    
+  end
+end
+
+include Ruleby
+engine :engine do |e|
+  #the engine takes an unreasonably long time to inspect -- consider patching Ruleby
+  RdfsRulebook.new(e).rdfs_rules 
+  
+  q = Triple.new(":Pius", "mit:majored_in", ":Course_6"); 
+  r = Triple.new("mit:majored_in", "rdfs:subPropertyOf", "mit:took_some_classes_in")
+  
+  e.assert q
+  e.assert r
+  
+  e.match
+
+  # p = Triple.new(":Pius", "rdf:type", ":male")
+  # h = Triple.new(":male", "rdfs:subClassOf", ":human") 
+  # e.assert p
+  # e.assert h
+  # e.match
+  # puts "matching facts"
+  # puts e.facts
+end