logica 0.0.1

data/lib/logica/predicates/compounds/at_least.rb

@@ -0,0 +1,90 @@
+module Logica
+  module Predicates
+    module Compounds
+      class AtLeast < Base
+        attr_reader :amount
+
+        def initialize(amount, predicates)
+          super(predicates)
+          @amount = amount
+        end
+
+        def satisfied_by?(*arguments)
+          true_count = 0
+          predicates_count = predicates.size
+          predicates.each_with_index do |predicate, index|
+            true_count += 1 if predicate.satisfied_by?(*arguments)
+            return true if true_count >= amount
+            remaining_predicates_count = predicates_count - (index + 1)
+            return false if true_count + remaining_predicates_count < amount
+          end
+        end
+
+        def and(other)
+          other.and_with_at_least(self)
+        end
+
+        def and_with_other(other, options = {})
+          default_options = {
+            other_first: true
+          }
+          options = default_options.merge(options)
+
+          subsumed = predicates.select { |pred| pred.generalization_of?(other) }
+          new_amount = amount - subsumed.size
+          new_predicates = predicates - subsumed
+          new_at_least = predicate_factory.at_least(new_amount, new_predicates)
+
+          pair = options[:other_first] ? [other, new_at_least] : [new_at_least, other]
+          predicate_factory.conjunction_from_pair(*pair)
+        end
+
+        def portion_satisfied_by(*arguments)
+          if satisfied_by?(*arguments)
+            self
+          else
+            to_disjunction.portion_satisfied_by(*arguments)
+          end
+        end
+
+        def remainder_unsatisfied_by(*arguments)
+          if satisfied_by?(*arguments)
+            predicate_factory.contradiction
+          else
+            unsatisfied_predicates = predicates_unsatisfied_by(*arguments)
+            satisfied_count = predicates.size - unsatisfied_predicates.size
+            new_amount = amount - satisfied_count
+
+            predicate_factory.at_least(new_amount, unsatisfied_predicates)
+          end
+        end
+
+        def to_disjunction
+          @to_disjunction ||= begin
+            combinations = predicates.combination(amount)
+
+            conjunctions = combinations.map do |amount_preds|
+              predicate_factory.conjunction(amount_preds)
+            end
+
+            predicate_factory.disjunction(conjunctions)
+          end
+        end
+
+        def name_and_attributes
+          "#{name}(#{amount}, [#{attributes_string}])"
+        end
+
+        private
+
+        def new_from_list(preds)
+          self.class.new(amount, preds)
+        end
+
+        def do_method_missing(name, *args, &block)
+          to_disjunction.do_method_missing(name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/logica/predicates/compounds/base.rb

@@ -0,0 +1,134 @@
+module Logica
+  module Predicates
+    module Compounds
+      class Base < Predicates::Base
+        attr_reader :predicates
+
+        def self.new_from_pair(first_predicate, second_predicate)
+          new([first_predicate]).with_extra_predicate_last(second_predicate)
+        end
+
+        def self.new_from_list(predicates)
+          predicates.reduce(internal_binary_operation) || neutral_element
+        end
+
+        def initialize(predicates)
+          @predicates = predicates
+          validate_composability
+        end
+
+        def with_extra_predicates(extra_predicates)
+          extra_predicates.reduce(self) do |compound, extra_predicate|
+            return compound if compound == absorbing_element
+            compound.with_extra_predicate_last(extra_predicate)
+          end
+        end
+
+        def with_extra_predicate_last(extra_predicate)
+          with_extra_predicate(extra_predicate) do |subsumed, extra|
+            predicates - subsumed + [extra]
+          end
+        end
+
+        def arity
+          predicates.first.arity
+        end
+
+        def name_and_attributes
+          "#{name}(#{attributes_string})"
+        end
+
+        def without(predicate_or_predicates, options = {})
+          without_predicates([predicate_or_predicates].flatten(1), options)
+        end
+
+        protected
+
+        def without_predicates(preds, options = {})
+          default_options = {
+            recursive: false
+          }
+          options = default_options.merge(options)
+
+          difference = predicates - preds
+
+          remaining = if options[:recursive]
+                        difference.flat_map { |pred| pred.without_predicates(preds, options) }
+                      else
+                        difference
+                      end
+
+          new_from_list(remaining)
+        end
+
+        private
+
+        def validate_composability
+          raise_composability_error unless predicates_are_composable?
+        end
+
+        def raise_composability_error
+          raise ArgumentError, composability_error_message
+        end
+
+        def composability_error_message
+          "cannot compose predicates #{predicates} (arity mismatch)"
+        end
+
+        def predicates_are_composable?
+          predicates.map(&:arity).uniq.size <= 1
+        end
+
+        def annihilated_by?(other)
+          predicates.any? { |own_predicate| annihilation?(own_predicate, other) }
+        end
+
+        def subsumes?(other)
+          predicates.any? { |own_predicate| subsumption?(own_predicate, other) }
+        end
+
+        def with_extra_predicate_first(extra_predicate)
+          with_extra_predicate(extra_predicate) do |subsumed, extra|
+            [extra] + predicates - subsumed
+          end
+        end
+
+        def with_extra_predicate(extra_predicate)
+          return absorbing_element if annihilated_by?(extra_predicate)
+
+          candidates = if subsumes?(extra_predicate)
+                         predicates
+                       else
+                         predicates_subsumed = predicates.select { |pred| subsumption?(extra_predicate, pred) }
+                         yield predicates_subsumed, extra_predicate
+                       end
+          candidates.one? ? candidates.first : new_with_predicates(candidates)
+        end
+
+        def predicates_satisfied_by(*arguments)
+          predicates.select { |predicate| predicate.satisfied_by?(*arguments) }
+        end
+
+        def predicates_unsatisfied_by(*arguments)
+          predicates.select { |predicate| predicate.unsatisfied_by?(*arguments) }
+        end
+
+        def new_with_predicates(new_predicates)
+          self.class.new(new_predicates)
+        end
+
+        def new_from_list(preds)
+          self.class.new_from_list(preds)
+        end
+
+        def absorbing_element
+          self.class.absorbing_element
+        end
+
+        def attributes_string
+          predicates.map(&:name_and_attributes).join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/logica/predicates/compounds/conjunction.rb

@@ -0,0 +1,75 @@
+module Logica
+  module Predicates
+    module Compounds
+      class Conjunction < Base
+        class << self
+          def internal_binary_operation
+            :and
+          end
+
+          def neutral_element
+            predicate_factory.tautology
+          end
+
+          def absorbing_element
+            predicate_factory.contradiction
+          end
+        end
+
+        def satisfied_by?(*arguments)
+          predicates.all? { |predicate| predicate.satisfied_by?(*arguments) }
+        end
+
+        def and(other)
+          other.and_with_conjunction(self)
+        end
+
+        def and_with_other(other)
+          with_extra_predicate_first(other)
+        end
+
+        def specialization_of?(other)
+          other.generalization_of_conjunction?(self)
+        end
+
+        def specialization_of_other?(other)
+          predicates.any? { |predicate| predicate.specialization_of?(other) }
+        end
+
+        def portion_satisfied_by(*arguments)
+          satisfied_predicates = predicates_satisfied_by(*arguments)
+          predicate_factory.conjunction(satisfied_predicates)
+        end
+
+        def remainder_unsatisfied_by(*arguments)
+          unsatisfied_predicates = predicates_unsatisfied_by(*arguments)
+          if unsatisfied_predicates.empty?
+            predicate_factory.contradiction
+          else
+            predicate_factory.conjunction(unsatisfied_predicates)
+          end
+        end
+
+        protected
+
+        def and_with_conjunction(conjunction)
+          conjunction.with_extra_predicates(predicates)
+        end
+
+        private
+
+        def name
+          'AND'
+        end
+
+        def subsumption?(first, second)
+          first.specialization_of?(second)
+        end
+
+        def annihilation?(first, second)
+          first.disjoint_with?(second)
+        end
+      end
+    end
+  end
+end

data/lib/logica/predicates/compounds/disjunction.rb

@@ -0,0 +1,79 @@
+module Logica
+  module Predicates
+    module Compounds
+      class Disjunction < Base
+        class << self
+          def internal_binary_operation
+            :or
+          end
+
+          def neutral_element
+            predicate_factory.contradiction
+          end
+
+          def absorbing_element
+            predicate_factory.tautology
+          end
+        end
+
+        def satisfied_by?(*arguments)
+          predicates.any? { |predicate| predicate.satisfied_by?(*arguments) }
+        end
+
+        def or(other)
+          other.or_with_disjunction(self)
+        end
+
+        def or_with_other(other)
+          with_extra_predicate_first(other)
+        end
+
+        def specialization_of?(other)
+          other.generalization_of_disjunction?(self)
+        end
+
+        def generalization_of_other?(other)
+          predicates.any? { |predicate| predicate.generalization_of?(other) }
+        end
+
+        def portion_satisfied_by(*arguments)
+          if satisfied_by?(*arguments)
+            self
+          else
+            portions = predicates.map { |predicate| predicate.portion_satisfied_by(*arguments) }
+            predicate_factory.conjunction(portions)
+          end
+        end
+
+        def remainder_unsatisfied_by(*arguments)
+          if satisfied_by?(*arguments)
+            predicate_factory.contradiction
+          else
+            remainders = predicates.map { |predicate| predicate.remainder_unsatisfied_by(*arguments) }
+            predicate_factory.disjunction(remainders)
+          end
+        end
+
+        protected
+
+        def or_with_disjunction(disjunction)
+          disjunction.with_extra_predicates(predicates)
+        end
+
+        private
+
+        def name
+          'OR'
+        end
+
+        def subsumption?(first, second)
+          first.generalization_of?(second)
+        end
+
+        def annihilation?(first, second)
+          first.exhaustive_with?(second)
+        end
+      end
+    end
+  end
+end

data/lib/logica/predicates/contradiction.rb

@@ -0,0 +1,25 @@
+module Logica
+  module Predicates
+    class Contradiction < Base
+      def satisfied_by?(*arguments)
+        false
+      end
+
+      def negated
+        predicate_factory.tautology
+      end
+
+      def specialization_of?(other)
+        true
+      end
+
+      def generalization_of_other?(other)
+        false
+      end
+
+      def to_s
+        'FALSE |n|'
+      end
+    end
+  end
+end

data/lib/logica/predicates/negation.rb

@@ -0,0 +1,45 @@
+module Logica
+  module Predicates
+    class Negation < Base
+      attr_reader :predicate
+
+      def initialize(predicate)
+        @predicate = predicate
+      end
+
+      def satisfied_by?(*arguments)
+        predicate.unsatisfied_by?(*arguments)
+      end
+
+      def negated
+        predicate
+      end
+
+      def specialization_of?(other)
+        other.generalization_of_negation_of?(predicate)
+      end
+
+      def generalization_of_negation_of?(other)
+        predicate.specialization_of?(other)
+      end
+
+      def disjoint_with_other?(other)
+        predicate.generalization_of?(other)
+      end
+
+      def arity
+        predicate.arity
+      end
+
+      def name_and_attributes
+        "#{name}(#{predicate.name_and_attributes})"
+      end
+
+      private
+
+      def name
+        'NOT'
+      end
+    end
+  end
+end

data/lib/logica/predicates/partial_application.rb

@@ -0,0 +1,30 @@
+module Logica
+  module Predicates
+    class PartialApplication < Base
+      attr_reader :predicate, :first_arguments
+
+      def initialize(predicate, first_arguments)
+        @predicate = predicate
+        @first_arguments = first_arguments
+      end
+
+      def satisfied_by?(*arguments)
+        predicate.satisfied_by?(*(first_arguments + arguments))
+      end
+
+      def arity
+        predicate.arity - first_arguments.size
+      end
+
+      def name_and_attributes
+        "#{predicate.name_and_attributes}(#{first_arguments.join(', ')})"
+      end
+
+      private
+
+      def do_partially_applied_with(more_arguments)
+        predicate_factory.partial_application(predicate, first_arguments + more_arguments)
+      end
+    end
+  end
+end

data/lib/logica/predicates/tautology.rb

@@ -0,0 +1,29 @@
+module Logica
+  module Predicates
+    class Tautology < Base
+      def satisfied_by?(*arguments)
+        true
+      end
+
+      def negated
+        predicate_factory.contradiction
+      end
+
+      def specialization_of?(other)
+        other.generalization_of_tautology?(self)
+      end
+
+      def generalization_of_other?(other)
+        true
+      end
+
+      def generalization_of_negation_of?(other)
+        true
+      end
+
+      def to_s
+        'TRUE |n|'
+      end
+    end
+  end
+end

data/lib/logica/version.rb

@@ -0,0 +1,3 @@
+module Logica
+  VERSION = '0.0.1'.freeze
+end

data/lib/logica.rb

@@ -0,0 +1,25 @@
+require 'openhouse'
+
+require 'logica/version'
+
+require 'logica/comparable_by_state'
+
+require 'logica/predicates/base'
+require 'logica/predicates/ad_hoc'
+require 'logica/predicates/partial_application'
+require 'logica/predicates/negation'
+require 'logica/predicates/tautology'
+require 'logica/predicates/contradiction'
+
+require 'logica/predicates/compounds/base'
+require 'logica/predicates/compounds/conjunction'
+require 'logica/predicates/compounds/disjunction'
+require 'logica/predicates/compounds/at_least'
+
+require 'logica/predicate_factory'
+
+module Logica
+  def self.predicate_factory
+    @predicate_factory ||= PredicateFactory.new
+  end
+end

data/logica.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'logica/version'
+
+Gem::Specification.new do |spec|
+  spec.name     = 'logica'
+  spec.version  = Logica::VERSION
+  spec.date     = '2017-06-20'
+  spec.authors  = ['Eugenio Bruno']
+  spec.email    = ['eugeniobruno@gmail.com']
+
+  spec.summary  = 'Logica is a framework to reify and work with predicates.'
+  spec.homepage = 'https://github.com/eugeniobruno/logica'
+  spec.license  = 'MIT'
+
+  spec.files    = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir           = 'bin'
+  spec.executables      = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files       = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths    = ['lib']
+  spec.extra_rdoc_files = %w[LICENSE.txt README.md CODE_OF_CONDUCT.md CHANGELOG.md]
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_runtime_dependency 'openhouse', '~> 0.0', '>= 0.0.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest-bender', '~> 0.0', '>= 0.0.2'
+  spec.add_development_dependency 'simplecov', '~> 0.14'
+  spec.add_development_dependency 'coveralls', '~> 0.8'
+  spec.add_development_dependency 'pry-byebug', '~> 3.4'
+end