catlogic 0.0.1

data/lib/catlogic/syllogism.rb

@@ -0,0 +1,171 @@
+# Class for any syllogism object.
+class Syllogism
+  attr_reader :major, :minor, :conclusion
+
+# Syllogism object initiation takes three Proposition objects
+
+  def initialize(major, minor, conclusion=nil)
+    @major = major
+    @minor = minor
+    if conclusion == nil
+      @conclusion = self.getComputedConclusion
+    else
+      @conclusion = conclusion
+    end
+  end
+
+# This method gets the middle term by looking for the term in the major and minor terms that are used twice.
+  def middle
+    termarray = [@major.subject.label, @major.predicate.label, @minor.subject.label, @minor.predicate.label]
+    middle = nil
+    if self.three_term?
+      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
+    middle
+  end
+
+  def three_term?
+    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
+
+
+
+# gets the major term as a String from the major premise by identifying the middle term
+# and then identifying the term in the premise that is not the middle
+
+  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
+
+# returns the Mood object of Syllogism (e.g. AAA, EEE)
+
+  def mood
+    mood = Mood.new(@major.type, @minor.type, @conclusion.type)
+    return mood
+  end
+
+# gets the Figure of Syllogism (e.g. 1, 2, 3, 4)
+
+  def figure
+    mjmp = @major.position_of_term(self.middle)
+    mnmp = @minor.position_of_term(self.middle)
+
+    if mjmp == 'subject' && mnmp == 'predicate'
+      figure = Figure.new(1)
+    elsif mjmp == 'predicate' && mnmp == 'predicate'
+      figure = Figure.new(2)
+    elsif mjmp == 	'subject' && mnmp == 'subject'
+      figure = Figure.new(3)
+    elsif mjmp == 'predicate' && mnmp == 'subject'
+      figure = Figure.new(4)
+    end
+    return figure
+  end
+
+# Retrieve Form object of the Syllogism (i.e. AAAI, EAI4)
+  def form
+    form = Form.new(self.mood, self.figure)
+    return form
+  end
+
+  def undistributed_middle_test
+    ## Rule Number 1 - middle distributed
+    if @major.distribution(@major.position_of_term(self.middle)).label == 'undistributed' && @minor.distribution(@minor.position_of_term(self.middle)).label == 'undistributed'
+      validity = false
+    else
+      validity = true
+    end
+    return validity
+  end
+
+  def illicit_major_test
+    ##Rule Number 2a distribution of major term
+    if @conclusion.distribution('predicate').label == 'distributed' && @major.distribution(@major.position_of_term(self.majorterm)).label != 'distributed'
+      validity = false
+    else
+      validity = true
+    end
+  end
+  def illicit_minor_test
+    ##Rule Number 2b distribution of minor term - check fallacy of illicit minor
+    if @conclusion.distribution('subject').label == 'distributed' && @minor.distribution(@minor.position_of_term(self.minorterm)).label != 'distributed'
+      validity = false
+    else
+      validty = true
+    end
+  end
+  # exclusive premises
+  def exclusive_premises_test
+    if @major.quality.label == 'negative' && @minor.quality.label == 'negative'
+      validity = false
+    else
+      validity = true
+    end
+  end
+
+  def affirm_from_neg_test
+    if (@major.quality.label == 'negative' || @minor.quality.label == 'negative') && @conclusion.quality.label != 'negative'
+      validity = false
+    else
+      validity = true
+    end
+  end
+
+  def neg_from_affirms_test
+    if (@conclusion.quality.label == 'negative' && (@major.quality.label != 'negative' && @minor.quality.label != 'negative'))
+
+      validity = false
+      #validity = "pass"
+    else
+      validity = true
+    end
+  end
+
+
+  def validity
+    if (self.undistributed_middle_test != true || self.illicit_major_test != true || self.illicit_minor_test != true || self.exclusive_premises_test != true || self.affirm_from_neg_test != true || self.neg_from_affirms_test != true)
+      validity = false
+    else
+      validity = true
+    end
+  end
+
+  def label
+    return "#{@major.label}\n#{@minor.label}\n#{@conclusion.label}"
+  end
+
+
+
+  
+
+  
+
+  def displayPropositionalForm
+    form = Form.new(self.mood, self.figure)
+    form.displayPropositionalForm
+  end
+end

data/lib/catlogic/term.rb

@@ -0,0 +1,32 @@
+class Term
+  attr_reader :label
+
+  def initialize(termname)
+    @label = termname
+  end
+
+  def opposite
+    opposite = Term.new("non-#{@label}")
+    return opposite
+  end
+
+  def distribution_subject(quantity)
+      if quantity.label == 'universal'
+        @distribution = Distribution.new('distributed')
+      elsif quantity.label == 'particular'
+        @distribution = Distribution.new('undistributed')
+      end
+    return @distribution
+
+  end
+
+  def distribution_predicate(quality)
+    if quality.label == 'affirmative'
+      @distribution = Distribution.new('undistributed')
+    elsif quality.label == 'negative'
+      @distribution = Distribution.new('distributed')
+    end
+    return @distribution
+  end
+
+  end

data/lib/catlogic/version.rb

@@ -0,0 +1,3 @@
+module Catlogic
+  VERSION = "0.0.1"
+end

data/lib/catlogic.rb

@@ -0,0 +1,17 @@
+require "catlogic/version"
+
+#module Catlogic
+	# Your code goes here...
+	require "catlogic/distribution"
+	require "catlogic/quality"
+	require "catlogic/quantity"
+	require "catlogic/term"
+	require "catlogic/proposition"
+	require "catlogic/proposition_type"
+	require "catlogic/syllogism"
+	require "catlogic/figure"
+	require "catlogic/mood"
+	require "catlogic/form"
+	require "catlogic/premise_pair"
+	require "catlogic/premise_collection"  
+#end

data/spec/distribution_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'catlogic'
+require 'pry'
+
+describe 'distribution object' do
+  it 'can return distribution label as string' do
+    term = Distribution.new('distributed')
+    result = term.label
+    result.should == 'distributed'
+  end
+
+  it 'can return distribution opposite label as string' do
+    term = Distribution.new('distributed')
+    opposite = term.opposite
+    result = opposite.label
+    result.should == 'undistributed'
+  end
+
+  it 'can return undistributed opposite label as string' do
+    term = Distribution.new('undistributed')
+    opposite = term.opposite
+    result = opposite.label
+    result.should == 'distributed'
+  end
+
+end

data/spec/figure_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+require "catlogic"
+
+describe "figure object" do
+  $figure_1 = Figure.new(1)
+
+  it "should return the label of the figure type object" do
+    label = $figure_1.label
+    label.should == 1
+  end
+  it "should return the major type subject term object" do
+    subject = $figure_1.major_subject
+    subject.label.should == "M"
+  end
+  it "should return the major type predicate term object" do
+    subject = $figure_1.major_predicate
+    subject.label.should == "P"
+  end
+  it "should return the minor type subject term object" do
+    subject = $figure_1.minor_subject
+    subject.label.should == "S"
+  end
+  it "should return the minor type predicate term object" do
+    subject = $figure_1.minor_predicate
+    subject.label.should == "M"
+  end
+end

data/spec/form_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "catlogic"
+
+describe "form object" do
+  mood_aaa = Mood.new(PropositionType.new('A'), PropositionType.new('A'), PropositionType.new('A'))
+  figure_1 = Figure.new(1)
+  $form = Form.new(mood_aaa, figure_1)
+
+  it "should return form label" do
+    label = $form.label
+    label.should == "AAA1"
+  end
+
+  it "should return a syllogism object for the given form" do
+    syllogism = $form.syllogism
+    major = syllogism.major
+    minor = syllogism.minor
+    conclusion = syllogism.conclusion
+
+    major.label == "All M are P" && minor.label == "All S are M" && conclusion.label == "All S are P"
+  end
+end

data/spec/mood_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+require "catlogic"
+
+describe "mood object" do
+
+  $moodobject_aaa = Mood.new(PropositionType.new('A'), PropositionType.new('A'), PropositionType.new('A'))
+
+  it 'can display the label of the mood object' do
+    mood = $moodobject_aaa.label
+    mood.should == 'AAA'
+  end
+
+  it 'can get the major type proposition' do
+    majortype = $moodobject_aaa.majortype
+    majortype.label.should === 'A'
+  end
+end

data/spec/premise_pair_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'catlogic'
+
+describe "premise pair object" do
+
+  	$major = Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Dogs"), true)
+	$minor = Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Mortal Things"), true)
+	$pair = PremisePair.new($major, $minor)
+
+  it 'can return the major proposition' do
+    result = $pair.major
+    result.should == $major
+  end
+
+  it 'can return the minor proposition' do
+    result = $pair.minor
+    result.should == $minor
+  end
+
+  it 'can provide true result when this pair has three and only three distinct terms' do
+  	result = $pair.three_term_pair?
+  	result.should == true
+  end
+
+  it 'can return false result when this pair has only two distinct terms' do
+  	major = Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Dogs"), true)
+	minor = Proposition.new(Quantity.new("universal"), Term.new("Dogs"), Quality.new("affirmative"), Term.new("Mammals"), true)
+	pair = PremisePair.new(major, minor)
+
+  	result = pair.three_term_pair?
+  	result.should == false
+  end
+
+  it 'can return false result when this pair has only four distinct terms' do
+  	major = Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Dogs"), true)
+	minor = Proposition.new(Quantity.new("universal"), Term.new("Cats"), Quality.new("affirmative"), Term.new("Wicked"), true)
+	pair = PremisePair.new(major, minor)
+
+  	result = pair.three_term_pair?
+  	result.should == false
+  end
+
+  it 'can return middle term of pair' do 
+  	result = $pair.middle
+  	result.label.should == "Mammals"
+  end
+
+  
+
+
+end

data/spec/proposition_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+require 'catlogic'
+
+describe 'proposition object' do
+  $propositionAtrue = Proposition.new(Quantity.new("universal"), Term.new('dogs'), Quality.new("affirmative"), Term.new('mortal things'), true)
+  $propositionIfalse = Proposition.new(Quantity.new("particular"), Term.new('dogs'), Quality.new("affirmative"), Term.new('mortal things'), false)
+  $propositionItrue = Proposition.new(Quantity.new("particular"), Term.new('dogs'), Quality.new("affirmative"), Term.new('mortal things'), true)
+  it 'can return the quantity' do
+    result = $propositionAtrue.quantity
+    result.label.should == 'universal'
+  end
+  it 'can return the quality' do
+    result = $propositionAtrue.quality
+    result.label.should == 'affirmative'
+  end
+  it 'can return the subject' do
+    result = $propositionAtrue.subject
+    result.label.should == 'dogs'
+  end
+  it 'can return the predicate' do
+    result = $propositionAtrue.predicate
+    result.label.should == 'mortal things'
+  end
+  it 'can return the truth value' do
+    result = $propositionAtrue.truthvalue
+    result.should == true
+  end
+  it 'can return the type of proposition' do
+    type = $propositionAtrue.type
+    type.label.should == "A"
+  end
+  it 'can return the contradictory' do
+    quality = $propositionAtrue.contradictory.quality
+    quantity = $propositionAtrue.contradictory.quantity
+    # need a better test that can test the object rather than just string outputs
+    quality.label.should == "negative" && quantity.label.should == "particular"
+  end
+  it 'can return the correct subaltern of A proposition' do 
+  # the sub altern of an A type proposition should be True I proposition
+    subaltern = $propositionAtrue.subaltern
+      quantity = subaltern.quantity
+      subject = subaltern.quality
+      quality = subaltern.quality
+      predicate = subaltern.quality
+      truthvalue = subaltern.truthvalue
+    
+    quantity.label.should == "particular" && 
+        subject.label == "dogs" && 
+        quality.label.should == "affirmative" && 
+        predicate.label.should == "mortal things" && 
+        truthvalue.should == true
+  end
+  it 'can return the correct contra of a true A Proposition' do
+    contrary = $propositionAtrue.contrary
+      quantity = contrary.quantity
+      subject = contrary.quality
+      quality = contrary.quality
+      predicate = contrary.quality
+      truthvalue = contrary.truthvalue
+
+    quantity.label.should == "universal" &&
+        subject.label == "dogs" &&
+        quality.label.should == "negative" &&
+        predicate.label.should == "mortal things" &&
+        truthvalue.should == false
+  end
+  it 'can return the correct subcontrary response of a true I Proposition' do
+    subcontrary = $propositionIfalse.subcontrary
+      quantity = subcontrary.quantity
+      subject = subcontrary.quality
+      quality = subcontrary.quality
+      predicate = subcontrary.quality
+      truthvalue = subcontrary.truthvalue
+
+    quantity.label.should == "particular" &&
+        subject.label == "dogs" &&
+        quality.label.should == "negative" &&
+        predicate.label.should == "mortal things" &&
+        truthvalue.should == true
+  end
+  it 'can return the correct converse of an true I proposition' do
+    converse = $propositionItrue.converse
+      quantity = converse.quantity
+      subject = converse.quality
+      quality = converse.quality
+      predicate = converse.quality
+      truthvalue = converse.truthvalue
+
+    quantity.label.should == "particular" &&
+        subject.label == "mortal things" &&
+        quality.label.should == "negative" &&
+        predicate.label.should == "dogs" &&
+        truthvalue.should == true
+
+  end
+  it 'can return the obverse of an true A proposition' do
+    obverse = $propositionAtrue.converse
+      quantity = obverse.quantity
+      subject = obverse.quality
+      quality = obverse.quality
+      predicate = obverse.quality
+      truthvalue = obverse.truthvalue
+
+    quantity.label.should == "universal" &&
+        subject.label == "dogs" &&
+        quality.label.should == "negative" &&
+        predicate.label.should == "non-mortal things" &&
+        truthvalue.should == true
+  end
+  it 'can return the obverse of a true A proposition' do
+    obverse = $propositionAtrue.converse
+      quantity = obverse.quantity
+      subject = obverse.quality
+      quality = obverse.quality
+      predicate = obverse.quality
+      truthvalue = obverse.truthvalue
+
+    quantity.label.should == "universal" &&
+        subject.label == "dogs" &&
+        quality.label.should == "negative" &&
+        predicate.label.should == "non-mortal things" &&
+        truthvalue.should == true
+  end
+  it 'can return the correct contrapolated proposition of a true A proposition' do
+    contrapolated = $propositionAtrue.converse
+      quantity = contrapolated.quantity
+      subject = contrapolated.quality
+      quality = contrapolated.quality
+      predicate = contrapolated.quality
+      truthvalue = contrapolated.truthvalue
+
+    quantity.label.should == "universal" &&
+        subject.label == "non-mortal things" &&
+        quality.label.should == "affirmative" &&
+        predicate.label.should == "non-dogs" &&
+        truthvalue.should == true
+  end
+  it 'can return the correct position of a designated middle term -- in this case dogs' do
+    middleterm = Term.new('dogs')
+    position = $propositionAtrue.position_of_term(middleterm)
+    position.should == 'subject'
+  end
+  it 'can return a human readable version of an A proposition' do
+    label = $propositionAtrue.label
+    label.should == 'All dogs are mortal things'
+  end
+  it 'can return a human readable version of an I proposition' do
+    label = $propositionItrue.label
+    label.should == 'Some dogs are mortal things'
+  end
+
+  it 'can return distribution for a designated subject term position' do
+    distribution = $propositionAtrue.distribution('subject')
+    distribution.label.should == "distributed"
+  end
+
+  it 'can return distribution for a designated predicate term position' do
+    distribution = $propositionItrue.distribution('predicate')
+    distribution.label.should == "undistributed"
+  end
+
+  it 'can identify that a given proposition is repeated one time in given array' do 
+    premisesArray = [
+      Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true), 
+      Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true),
+      Proposition.new(Quantity.new("universal"), Term.new("Fun"), Quality.new("affirmative"), Term.new("Events"), true)
+    ]
+      
+      proposition = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true)
+      
+      result = proposition.number_of_occurences(premisesArray)
+      result.should == 1
+  end 
+
+  it 'can identify that a given proposition is repeated zero times in given array' do 
+    premisesArray = [
+      Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true), 
+      Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true),
+      Proposition.new(Quantity.new("universal"), Term.new("Fun"), Quality.new("affirmative"), Term.new("Events"), true)
+    ]
+      
+      proposition = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("affirmative"), Term.new("Caused Happenings"), true)
+      
+      result = proposition.number_of_occurences(premisesArray)
+      result.should == 0
+  end 
+  it 'can return answer true when proposition is unique (not included) in a given set' do
+
+    premisesArray = [
+      Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true), 
+      Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true),
+      Proposition.new(Quantity.new("universal"), Term.new("Fun"), Quality.new("affirmative"), Term.new("Events"), true)
+    ]
+      
+      proposition = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("affirmative"), Term.new("Caused Happenings"), true)
+
+      result = proposition.unique?(premisesArray)
+
+      result.should == true
+  end
+  it 'can return answer false when proposition is not unique (i.e. is included) in a given set' do
+
+    premisesArray = [
+      Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true), 
+      Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true),
+      Proposition.new(Quantity.new("universal"), Term.new("Fun"), Quality.new("affirmative"), Term.new("Events"), true)
+    ]
+      
+      proposition = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true)
+
+      result = proposition.unique?(premisesArray)
+
+      result.should == false
+  end
+end

data/spec/proposition_type_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'catlogic'
+
+describe 'proposition_type object' do
+  $typeA = PropositionType.new("A")
+  $typeE = PropositionType.new("E")
+  $typeI = PropositionType.new("I")
+  $typeO = PropositionType.new("O")
+
+  it 'can return the correct label for a proposition type A' do
+    result = $typeA.label
+    result.should == "A"
+  end
+
+  it 'can return the correct label for a proposition type O' do
+    result = $typeO.label
+    result.should == "O"
+  end
+
+  it 'can return the correct quantity for proposition type E' do
+    result = $typeE.quantity.label
+    result.should == "universal"
+  end
+
+  it 'can return the correct proposition for proposition type I' do
+    proposition = $typeI.proposition
+
+    # prefer a test on the object construction but I don't know how to do that
+    quantity = proposition.quantity.label
+    subject = proposition.subject.label
+    quality = proposition.quality.label
+    predicate = proposition.predicate.label
+    quantity.should == "particular" && subject.should == "S" && quality.should == "affirmative" && predicate.should == "P"
+
+  end
+
+end

data/spec/quality_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'catlogic'
+
+describe 'quality object' do
+  it 'can return quality as string' do
+    quality = Quality.new('affirmative')
+    result = quality.label
+    result.should == 'affirmative'
+  end
+
+  it 'can return term opposite as string' do
+    quality = Quality.new('affirmative')
+    opposite = quality.opposite
+    result = opposite.label
+    result.should == 'negative'
+  end
+end

data/spec/quantity_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'catlogic'
+require 'pry'
+
+describe 'quantity object' do
+  it 'can return quantity as string' do
+    quantity = Quantity.new('universal')
+    result = quantity.label
+    result.should == 'universal'
+  end
+
+  it 'can return term opposite as string' do
+    quantity = Quantity.new('particular')
+    opposite = quantity.opposite
+    result = opposite.label
+
+    result.should == 'universal'
+  end
+end