catlogic 0.0.1

data/catlogic.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'catlogic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "catlogic"
+  spec.version       = Catlogic::VERSION
+  spec.authors       = ["Jeffrey C. Witt"]
+  spec.email         = ["jeffreycwitt@gmail.com"]
+  spec.summary       = %q{A gem for building categorial propositions and syllogisms}
+  spec.description   = %q{A gem for building categorial propositions and syllogisms}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry'
+end

data/lib/catlogic/distribution.rb

@@ -0,0 +1,16 @@
+class Distribution
+  attr_reader :label
+
+  def initialize(distribution)
+    @label = distribution
+  end
+
+  def opposite
+    if self.label == 'distributed'
+      opposite = Distribution.new('undistributed')
+    elsif self.label == 'undistributed'
+      opposite = Distribution.new('distributed')
+    end
+    return opposite
+  end
+end

data/lib/catlogic/figure.rb

@@ -0,0 +1,45 @@
+class Figure
+  attr_reader :label
+
+  def initialize(figure)
+    @label = figure
+  end
+
+
+  def major_subject
+    if @label == 1 || @label == 3
+      subject = Term.new('M')
+
+    elsif @label == 2 || @label == 4
+      subject = Term.new('P')
+    end
+    return subject
+  end
+
+  def major_predicate
+    if @label == 1 || @label == 3
+      predicate = Term.new("P")
+    elsif @label == 2 || @label == 4
+      predicate = Term.new("M")
+    end
+    return predicate
+  end
+  def minor_subject
+    if @label == 1 || @label == 2
+      subject = Term.new("S")
+
+    elsif @label == 3 || @label == 4
+      subject = Term.new("M")
+
+    end
+    return subject
+  end
+  def minor_predicate
+    if @label == 1 || @label == 2
+      predicate = Term.new("M")
+    elsif @label == 3 || @label == 4
+      predicate = Term.new("S")
+    end
+    return predicate
+  end
+end

data/lib/catlogic/form.rb

@@ -0,0 +1,22 @@
+class Form
+  attr_reader :mood, :figure, :label
+  # takes three Mood Object and Figure Object
+  def initialize(mood, figure)
+    @mood = mood
+    @figure = figure
+    @label = "#{@mood.label}#{@figure.label}"
+  end
+  def syllogism
+     majorproposition = Proposition.new(@mood.majortype.quantity, @figure.major_subject, @mood.majortype.quality, @figure.major_predicate, true)
+    minorproposition = Proposition.new(@mood.minortype.quantity, @figure.minor_subject, @mood.minortype.quality, @figure.minor_predicate, true)
+    conclusion = Proposition.new(@mood.conclusiontype.quantity, Term.new("S"), @mood.conclusiontype.quality, Term.new("P"), true)
+
+    syllogism = Syllogism.new(majorproposition, minorproposition, conclusion)
+
+    return syllogism
+  end
+  def validity
+    syllogism = self.syllogism
+    syllogism.validity
+  end
+end

data/lib/catlogic/mood.rb

@@ -0,0 +1,14 @@
+class Mood
+  attr_reader :majortype, :minortype, :conclusiontype
+
+  # takes three propositionType objects
+  def initialize(majortype, minortype, conclusiontype)
+    @majortype = majortype
+    @minortype = minortype
+    @conclusiontype = conclusiontype
+  end
+
+  def label
+    "#{@majortype.label}#{@minortype.label}#{@conclusiontype.label}"
+  end
+end

data/lib/catlogic/premise_collection.rb

@@ -0,0 +1,211 @@
+class PremiseCollection
+  def initialize(propositionarray)
+    @collection = propositionarray
+  end
+
+  def getAllValidSyllogisms
+
+    if @collection.count < 2
+      puts "collection must include two or more propositions"
+    else
+      #inputconclusions = @collection
+      validsyllogisms = []
+      pairs = []
+
+      @collection.each do |proposition|
+
+        @collection.each do |secondproposition|
+          unless proposition.equal? secondproposition
+            pairs << PremisePair.new(proposition, secondproposition)
+          end
+        end
+      end
+      pairs.each do |pair|
+        if pair.isThreeTermPair?
+          conclusions = pair.getPossibleConclusions
+          conclusions.each do |conclusion|
+            syllogism = Syllogism.new(pair.getMajor, pair.getMinor, conclusion)
+            if syllogism.validity == "valid"
+              validsyllogisms << syllogism
+            end
+          end
+        end
+      end
+    end
+    return validsyllogisms
+  end
+
+  def getUniqueValidSyllogisms
+      inputconclusions = @collection
+      validsyllogisms = self.getAllValidSyllogisms
+      uniquevalidsyllogisms = []
+
+      validsyllogisms.each do |syllogism|
+      validconclusion = syllogism.getConclusion
+        if (validconclusion.isUnique?(inputconclusions))
+                  uniquevalidsyllogisms << syllogism
+        end
+      end
+    return uniquevalidsyllogisms
+  end
+
+=begin
+  def getUniqueInferredTruths
+
+    uniquevalidsyllogisms = self.getUniqueValidSyllogisms
+    uniqueinferredtruths = []
+
+    uniquevalidsyllogisms.each do |syllogism|
+      uniqueinferredtruths << syllogism.getConclusion
+    end
+
+    return uniqueinferredtruths
+  end
+=end
+
+  def getAllInferredTruths
+    inputconclusions = @collection
+    inferredconclusions = []
+
+    validsyllogisms = self.getAllValidSyllogisms
+    validsyllogisms.each do |syllogism|
+      validconclusion = syllogism.getConclusion
+
+      if (validconclusion.isUnique?(inputconclusions))
+        inferredconclusions << validconclusion
+      end
+    end
+    return inferredconclusions
+  end
+
+
+  def getUniqueInferredTruths
+    newset = PremiseCollection.new(self.getAllInferredTruths)
+    unique_inferredconclusions = newset.reduceToUniqueSet
+    return unique_inferredconclusions
+  end
+
+
+
+  def displayLoopedInferredTruths
+
+      #get first set of inferences from initial collection set
+      inferredtruths = self.getUniqueInferredTruths
+      #combine with existing - on first interation will be comined with empty array
+      combinedset = self.combineSets(inferredtruths)
+
+      puts "======================="
+      puts "first set of inferences"
+      puts inferredtruths.count
+      puts "======================="
+
+
+      self.displayAllValidSyllogisms
+      self.displayUniqueSyllogisms
+      self.displayInferredTruths
+
+
+      while (inferredtruths.count != 0)
+
+      ## create new collection object
+      newcollection = PremiseCollection.new(combinedset)
+
+      ## get next set of inferences
+
+      #reset inferred truths
+      inferredtruths = newcollection.getUniqueInferredTruths
+      #rest combined set
+      combinedset = newcollection.combineSets(inferredtruths)
+
+      puts "======================="
+      puts "next set of inferences"
+      puts inferredtruths.count
+      puts "======================="
+
+      #display inferred set
+      newcollection.displayAllValidSyllogisms
+      newcollection.displayUniqueSyllogisms
+      newcollection.displayInferredTruths
+
+    end
+  end
+
+
+  def combineSets(newset)
+    newcollection = []
+
+    newcollection << @collection
+    newcollection << newset
+
+
+    return newcollection.flatten
+  end
+
+
+
+  def reduceToUniqueSet
+    unique_knownconclusions = []
+
+    @collection.each do |conclusion|
+      if unique_knownconclusions.count == 0
+        unique_knownconclusions << conclusion
+      elsif conclusion.isUnique?(unique_knownconclusions)
+        unique_knownconclusions << conclusion
+      end
+
+
+    end
+    return unique_knownconclusions
+end
+
+  def displayInferredTruths
+    truths = self.getUniqueInferredTruths
+    puts 
+    puts "==== Begin Display All Unique Inferred Truths ==="
+    truths.each do |truth|
+      truth.displayProposition
+    end
+    puts "==== End Display All Unique Inferred Truths ==="
+    puts
+
+  end
+
+  def displayAllValidSyllogisms
+    puts
+    puts "====== Begin Display All Valid Syllogisms==="
+    allvalidsyllogisms = self.getAllValidSyllogisms
+    allvalidsyllogisms.each do |syllogism|
+      syllogism.displayForm
+      syllogism.displaySyllogism
+      puts
+    end
+    puts "======End All Vallid Syllogisms==="
+    puts
+  end
+
+  def displayUniqueSyllogisms
+
+    puts
+    puts "======Begin Display All Syllogism Producing new truths==="
+    uniquevalidsyllogisms = self.getUniqueValidSyllogisms
+    uniquevalidsyllogisms.each do |syllogism|
+      syllogism.displayForm
+      syllogism.displaySyllogism
+      puts
+    end
+    puts "======End Display All Syllogism Producing new truths==="
+    puts
+
+  end
+
+
+  def getNumberOfInferredTruths
+    self.getUniqueInferredTruths.count
+  end
+  def getNumberOfInputTruths
+    @collection.count
+  end
+  def getRatioInputToInferred
+    self.getNumberOfInferredTruths / self.getNumberOfInputTruths
+  end
+end

data/lib/catlogic/premise_pair.rb

@@ -0,0 +1,61 @@
+class PremisePair
+  
+  attr_reader :major, :minor
+  
+  def initialize(major, minor)
+    @major = major
+    @minor = minor
+  end
+
+  def middle
+    termarray = [@major.subject.label, @major.predicate.label, @minor.subject.label, @minor.predicate.label]
+    middle = nil
+    if self.three_term_pair?
+      termarray.detect do |term|
+        if termarray.count(term) == 2
+          middle = Term.new(term)
+        end
+      end
+    else
+      middle = "Error: this is not a three term syllogism"
+    end
+    return middle
+  end
+
+  def three_term_pair?
+    termarray = [@major.subject.label, @major.predicate.label, @minor.subject.label, @minor.predicate.label]
+    if termarray.uniq.size == 3
+      answer = true
+    else
+      answer = false
+    end
+  end
+
+   def majorterm
+    if @major.subject.label == self.middle.label
+      majorterm = @major.predicate
+    else
+      majorterm = @major.subject
+    end
+    majorterm
+  end
+  def minorterm
+    if @minor.subject.label == self.middle.label
+      minorterm = @minor.predicate
+    else
+      minorterm = @minor.subject
+    end
+    minorterm
+  end
+
+# still need a test for this
+  def possible_conclusions
+    @possible_conclusions = [
+        Proposition.new(Quantity.new("universal"), self.minor, Quality.new("affirmative"), self.minor, true),
+        Proposition.new(Quantity.new("universal"), self.minor, Quality.new("negative"), self.minor, true),
+        Proposition.new(Quantity.new("particular"), self.minor, Quality.new("affirmative"), self.minor, true),
+        Proposition.new(Quantity.new("particular"), self.minor, Quality.new("negative"), self.minor, true)
+    ]
+  end
+
+end

data/lib/catlogic/proposition.rb

@@ -0,0 +1,181 @@
+class Proposition
+
+  attr_reader :quantity, :subject, :quality, :predicate, :truthvalue
+
+  def initialize(quantity, subject, quality, predicate, truthvalue)
+    @quantity=quantity
+    @subject=subject
+    @quality=quality
+    @predicate=predicate
+    @truthvalue=truthvalue
+  end
+
+  def type
+    if @quantity.label == 'universal' && @quality.label == 'affirmative'
+      @type=PropositionType.new("A")
+    elsif @quantity.label == 'universal' && @quality.label == 'negative'
+      @type=PropositionType.new("E")
+    elsif @quantity.label == 'particular' && @quality.label == 'affirmative'
+      @type=PropositionType.new("I")
+    elsif @quantity.label == 'particular' && @quality.label == 'negative'
+      @type=PropositionType.new("O")
+    end
+    return @type
+  end
+
+  def contradictory
+
+    quantity = @quantity.opposite
+    quality = @quality.opposite
+
+    @contradictory = Proposition.new(quantity, @subject, quality, @predicate, !@truthvalue)
+    return @contradictory
+  end
+
+  def subaltern
+
+    quantity = @quantity.opposite
+
+    if @quantity.label == "universal"
+      if @truthvalue
+        truthvalue = @truthvalue
+      elsif !@truthvalue
+        truthvalue = "unknown"
+      end
+    elsif @quantity.label == "particular"
+      if !@truthvalue
+        truthvalue = !@truthvalue
+      elsif @truthvalue
+        truthvalue = "unknown"
+      end
+    end
+
+    @subaltern = Proposition.new(quantity, @subject, @quality, @predicate, truthvalue)
+    return @subaltern
+  end
+
+  def contrary
+    if @quantity.label  == "particular"
+      abort("There is no contrary for this type of propostion. Try subcontrary")
+    end
+    quality = @quality.opposite
+
+    if @truthvalue
+      truthvalue = !@truthvalue
+    elsif !@truthvalue
+      truthvalue = "unknown"
+    end
+
+    contrary = Proposition.new(@quantity, @subject, quality, @predicate, truthvalue)
+    return contrary
+  end
+
+  def subcontrary
+    if @quantity.label  == "universal"
+      abort("There is no subcontrary for this type of propostion. Try contrary.")
+    end
+
+    quality = @quality.opposite
+
+    if !@truthvalue
+      truthvalue = !@truthvalue
+    elsif @truthvalue
+      truthvalue = "unknown"
+    end
+
+    subcontrary = Proposition.new(@quantity, @subject, quality, @predicate, truthvalue)
+    return subcontrary
+  end
+
+  def converse
+    if self.type.label == "A" || self.type.label == "O"
+      truthvalue = "unknown"
+    else
+      truthvalue = @truthvalue
+    end
+    @converse = Proposition.new(@quantity, @predicate, @quality, @subject, truthvalue)
+  end
+
+  def obverse
+    quality = @quality.opposite
+
+    predicate = @predicate.opposite
+    @obverse = Proposition.new(@quantity, @subject, quality, predicate, @truthvalue)
+  end
+
+  def contrapolated
+    if self.type.label == "E" || self.type.label == "I"
+      truthvalue = "unknown"
+    else
+      truthvalue = @truthvalue
+    end
+    subject = @subject.opposite
+    predicate = @predicate.opposite
+
+    @contrapolated = Proposition.new(@quantity, predicate, @quality, subject, truthvalue)
+
+  end
+
+  def position_of_term(term)
+    if self.subject.label == term.label
+      @positionofmiddle = 'subject'
+    elsif self.predicate.label == term.label
+      @positionofmiddle = 'predicate'
+    end
+    return @positionofmiddle
+  end
+
+  def label
+    if @quantity.label == "universal"
+      if @quality.label == "affirmative"
+        display_quantity = "All"
+        display_quality = "are"
+      elsif @quality.label == "negative"
+        display_quantity = "No"
+        display_quality = "are"
+      end
+    elsif @quantity.label == "particular"
+      if @quality.label == "affirmative"
+        display_quantity = "Some"
+        display_quality = "are"
+      elsif @quality.label == "negative"
+        display_quantity = "Some"
+        display_quality = "are not"
+      end
+    end
+    "#{display_quantity} #{@subject.label} #{display_quality} #{@predicate.label}"
+  end
+
+  def distribution(position)
+    if position == 'subject'
+      distribution = @subject.distribution_subject(@quantity)
+    elsif position == 'predicate'
+      distribution = @predicate.distribution_predicate(@quality)
+    end
+    return distribution
+  end
+
+  def unique?(set)
+    numerofoccurences = self.number_of_occurences(set)
+    if numerofoccurences == 0
+      true
+    else 
+      false
+    end
+  end
+  
+  def number_of_occurences(set)
+    @occurences = 0
+    set.each do |proposition|
+      if (proposition.quantity.label == self.quantity.label && 
+        proposition.subject.label == self.subject.label && 
+        proposition.quality.label == self.quality.label && 
+        proposition.predicate.label == self.predicate.label && 
+        proposition.truthvalue == self.truthvalue)
+        @occurences += 1
+      end
+    end
+    @occurences
+  end
+
+end

data/lib/catlogic/proposition_type.rb

@@ -0,0 +1,47 @@
+class PropositionType
+
+  attr_reader :label, :truthvalue
+
+  def initialize(type, truthvalue=true)
+    @type = type
+    @label = type
+    @truthvalue = truthvalue
+  end
+  def getType
+    @type
+  end
+
+  def quantity
+    if @label == "A"
+      quantity = Quantity.new("universal")
+    elsif @label == "E"
+      quantity = Quantity.new("universal")
+    elsif @label == "I"
+      quantity = Quantity.new("particular")
+    elsif @label == "O"
+      quantity = Quantity.new("particular")
+    else
+      quantity = "not a valid type"
+    end
+    return quantity
+  end
+  def quality
+    if @label == "A"
+      quality = Quality.new("affirmative")
+    elsif @label == "E"
+      quality = Quality.new("negative")
+    elsif @label == "I"
+      quality = Quality.new("affirmative")
+    elsif @label == "O"
+      quality = Quality.new("negative")
+    else
+      quality = "not a valid type"
+    end
+    return quality
+  end
+
+  def proposition
+    proposition = Proposition.new(Quantity.new(self.quantity.label), Term.new("S"), Quality.new(self.quality.label), Term.new("P"), @truthvalue)
+    return proposition
+  end
+end

data/lib/catlogic/quality.rb

@@ -0,0 +1,16 @@
+class Quality
+  attr_reader :label
+
+  def initialize(quality)
+    @label = quality
+  end
+
+  def opposite
+    if self.label == 'negative'
+      qualityopposite = Quality.new('affirmative')
+    elsif self.label == 'affirmative'
+      qualityopposite = Quality.new('negative')
+    end
+    return qualityopposite
+  end
+end

data/lib/catlogic/quantity.rb

@@ -0,0 +1,16 @@
+class Quantity
+  attr_reader :label
+
+  def initialize(quantity)
+    @label = quantity
+  end
+
+  def opposite
+    if self.label == 'universal'
+      quantityopposite = Quantity.new('particular')
+    elsif self.label == 'particular'
+      quantityopposite = Quantity.new('universal')
+    end
+    return quantityopposite
+  end
+end