catlogic 0.0.2 → 0.0.3

data/scripts/displayInferredTruths.rb

@@ -7,253 +7,75 @@ rescue LoadError
   require 'catlogic'
 end
 
-premises2 = [Proposition.new("universal", "Mammals", "affirmative", "Mortal Things", true),
-            Proposition.new("universal", "People", "affirmative", "Mammals", true)]
+premises2 = [Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mortal Things"), true),
+            Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("People"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mammals"), true)]
 
-premises3 = [Proposition.new("universal", "Mammals", "affirmative", "Mortal Things", true),
-            Proposition.new("universal", "People", "affirmative", "Mammals", true), 
-            Proposition.new("universal", "Ants", "negative", "Mammals", true)]
+premises3 = [Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mortal Things"), true),
+            Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("People"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mammals"), true),
+            Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Ants"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Mammals"), true)]
 
 
-premises4 = [Proposition.new("universal", "planes", "affirmative", "things with wings", true),
-            Proposition.new("particular", "planes", "affirmative", "things with propellors", true),
-            Proposition.new("universal", "pilots", "affirmative", "things that fly planes", true),
-            Proposition.new("universal", "things that fly planes", "affirmative", "tall things", true)]
+premises4 = [Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("planes"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("things with wings"), true),
+            Catlogic::Proposition.new(Catlogic::Quantity.new("particular"), Catlogic::Term.new("planes"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("things with propellors"), true),
+            Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("pilots"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("things that fly planes"), true),
+            Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("things that fly planes"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("tall things"), true)]
 
-premises5 = [Proposition.new("universal", "dogs", "affirmative", "animals", true),
-            Proposition.new("universal", "cats", "affirmative", "animals", true),
-            Proposition.new("universal", "animals", "affirmative", "mortals", true),
-            Proposition.new("universal", "mortals", "affirmative", "things that disintegrate", true),
-            Proposition.new("particular", "dogs", "affirmative", "brown", true)]
+premises5 = [Catlogic::Proposition.new("universal", "dogs", "affirmative", "animals", true),
+            Catlogic::Proposition.new("universal", "cats", "affirmative", "animals", true),
+            Catlogic::Proposition.new("universal", "animals", "affirmative", "mortals", true),
+            Catlogic::Proposition.new("universal", "mortals", "affirmative", "things that disintegrate", true),
+            Catlogic::Proposition.new("particular", "dogs", "affirmative", "brown", true)]
             
-
-
-
-
-        	
-
-collection = PremiseCollection.new(premises4)
-
-
-puts "==============="
-puts "intial set"
-puts premises4.count
-puts 
-premises4.each do |proposition|
-proposition.displayProposition
-end
-puts "==============="
-
-collection.displayLoopedInferredTruths
-#puts "#{collection.getNumberOfInferredTruths} / #{collection.getNumberOfInputTruths}: #{collection.getRatioInputToInferred}/1"
-
-=begin
- 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
-=end
-
-=begin
-  def getUniqueInferredTruths
-
-    uniquevalidsyllogisms = self.getUniqueValidSyllogisms
-    uniqueinferredtruths = []
-
-    uniquevalidsyllogisms.each do |syllogism|
-      uniqueinferredtruths << syllogism.getConclusion
-    end
-
-    return uniqueinferredtruths
-  end
-=end
-
-=begin
-def getAllInferredTruths
-  inputconclusions = @collection
-  inferredconclusions = []
-
-  validsyllogisms = self.getAllValidSyllogisms
-  validsyllogisms.each do |syllogism|
-    validconclusion = syllogism.getConclusion
-
-    if (validconclusion.isUnique?(inputconclusions))
-      inferredconclusions << validconclusion
-    end
+def display_inferences(collection, iteration) 
+  puts "==============="
+  puts "inference set number #{iteration}"
+  puts "---------------"
+  puts "Number of initial propositions: #{collection.unique_propositions.count}"
+  puts "---------------"
+  puts "Number of new inference #{collection.inferred_truths_new.count}"
+  puts "----------------"
+  puts "inferred propositions for iteration #{iteration}:"
+  puts "----------------"
+  collection.inferred_truths_new.each do |proposition|
+    puts proposition.label
   end
-  return inferredconclusions
+  puts "==============="
+  puts ""
 end
 
-
-def getUniqueInferredTruths
-  newset = PremiseCollection.new(self.getAllInferredTruths)
-  unique_inferredconclusions = newset.reduceToUniqueSet
-  return unique_inferredconclusions
+# create first combined set or propositions
+def combine_sets(oldarray, newarray)
+  combinedset = []
+  combinedset << oldarray
+  combinedset << newarray
+  return combinedset.flatten
 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
+#Set up        	
+collection = Catlogic::PremiseCollection.new(premises4)
+puts ""
+puts "==============="
+puts "Initial Set"
+puts "---------------"
+puts "intial set size: #{collection.size}"
+puts "---------------"
+puts "input propositions"
+puts "----------------"
+collection.unique_propositions.each do |proposition|
+  puts proposition.label
 end
-def getRatioInputToInferred
-  self.getNumberOfInferredTruths / self.getNumberOfInputTruths
+puts "==============="
+puts ""
+
+
+iteration = 1
+## basic idea of loop is simply to keep combing input propositions and inferred propositions until there are no more new inferred propositions
+while (collection.inferred_truths_new.count != 0)
+  display_inferences(collection, iteration)
+  iteration += 1
+  
+  combinedset = combine_sets(collection.unique_propositions, collection.inferred_truths_new)
+  collection = Catlogic::PremiseCollection.new(combinedset)
+  
 end
 
-=end

data/scripts/getAllValidPropositions.rb

@@ -17,8 +17,8 @@ numberArray.each do |i|
 
 		typeArray.each do |secondtype|
 			typeArray.each do |thirdtype|
-        mood = Mood.new(PropositionType.new(type), PropositionType.new(secondtype), PropositionType.new(thirdtype))
-				form = Form.new(mood, Figure.new(i))
+        mood = Catlogic::Mood.new(Catlogic::PropositionType.new(type), Catlogic::PropositionType.new(secondtype), Catlogic::PropositionType.new(thirdtype))
+				form = Catlogic::Form.new(mood, Catlogic::Figure.new(i))
 	
 			if form.validity == true
 				puts form.label + " " + form.name

data/scripts/testCombineSets.rb

@@ -7,22 +7,22 @@ rescue LoadError
   require 'catlogic'
 end
 
-premises1 = [Proposition.new("universal", "dogs", "affirmative", "animals", true),
-             Proposition.new("universal", "cats", "affirmative", "animals", true),
-             Proposition.new("universal", "animals", "affirmative", "mortals", true),
-             Proposition.new("universal", "mortals", "affirmative", "things that disintegrate", true),
-             Proposition.new("particular", "dogs", "affirmative", "brown", true),
-             Proposition.new("particular", "cats", "negative", "mean things", true),
-             Proposition.new("particular", "cats", "negative", "mean things", true),
-             Proposition.new("universal", "animals", "negative", "divine things", true),
-             Proposition.new("particular", "animals", "affirmative", "carnivores", true)]
-
-
-premises2 = [Proposition.new("universal", "Events", "affirmative", "Caused Happenings", true),
-             Proposition.new("universal", "Free Decisions", "negative", "Caused Happenings", true),
-             Proposition.new("universal", "Caused Happenings", "affirmative", "Physical", true)]
-
-collection = PremiseCollection.new(premises1)
+premises1 = [Catlogic::Proposition.new("universal", "dogs", "affirmative", "animals", true),
+             Catlogic::Proposition.new("universal", "cats", "affirmative", "animals", true),
+             Catlogic::Proposition.new("universal", "animals", "affirmative", "mortals", true),
+             Catlogic::Proposition.new("universal", "mortals", "affirmative", "things that disintegrate", true),
+             Catlogic::Proposition.new("particular", "dogs", "affirmative", "brown", true),
+             Catlogic::Proposition.new("particular", "cats", "negative", "mean things", true),
+             Catlogic::Proposition.new("particular", "cats", "negative", "mean things", true),
+             Catlogic::Proposition.new("universal", "animals", "negative", "divine things", true),
+             Catlogic::Proposition.new("particular", "animals", "affirmative", "carnivores", true)]
+
+
+premises2 = [Catlogic::Proposition.new("universal", "Events", "affirmative", "Caused Happenings", true),
+             Catlogic::Proposition.new("universal", "Free Decisions", "negative", "Caused Happenings", true),
+             Catlogic::Proposition.new("universal", "Caused Happenings", "affirmative", "Physical", true)]
+
+collection = Catlogic::PremiseCollection.new(premises1)
 
 newcollection = collection.combineSets(premises2)
 

data/scripts/testIfUnique.rb

@@ -7,13 +7,13 @@ rescue LoadError
   require 'catlogic'
 end
 
-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)]
+premisesArray = [Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Events"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true),
+            Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), true),
+            Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Fun"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Events"), true)]
 
 
 
 
-proposition = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true)
+proposition = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), true)
 
 puts proposition.number_of_occurences(premisesArray)

data/scripts/testPremisePair.rb

@@ -7,9 +7,9 @@ rescue LoadError
   require 'catlogic'
 end
 
-premise1 = Proposition.new("universal", "Mammals", "affirmative", "Dogs", true)
-premise2 = Proposition.new("universal", "Mammals", "affirmative", "Mortal Things", true)
+premise1 = Catlogic::Proposition.new("universal", "Mammals", "affirmative", "Dogs", true)
+premise2 = Catlogic::Proposition.new("universal", "Mammals", "affirmative", "Mortal Things", true)
 
 
-pair = PremisePair.new(premise1, premise2)
+pair = Catlogic::PremisePair.new(premise1, premise2)
 puts pair.isThreeTermPair?;

data/scripts/testProposition.rb

@@ -7,7 +7,7 @@ rescue LoadError
   require 'catlogic'
 end
 
-proposition = Proposition.new(Quantity.new("particular"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), false)
+proposition = Catlogic::Proposition.new(Catlogic::Quantity.new("particular"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), false)
 
 #converse = proposition.getContrapolated
 #converse.displayProposition

data/scripts/testPropositionType.rb

@@ -7,7 +7,7 @@ rescue LoadError
   require 'catlogic'
 end
 
-type = PropositionType.new("O", true)
+type = Catlogic::PropositionType.new("O", true)
 proposition = type.proposition
 
 ## this is repeated from testProposition.rb

data/scripts/testQuantity.rb

@@ -7,6 +7,6 @@ rescue LoadError
   require 'catlogic'
 end
 
-quantity = Quantity.new("universal")
+quantity = Catlogic::Quantity.new("universal")
 
 puts quantity.label

data/scripts/testReduceToUniqueSet.rb

@@ -7,14 +7,14 @@ rescue LoadError
   require 'catlogic'
 end
 
-premisesArray = [Proposition.new("universal", "Events", "affirmative", "Caused Happenings", true),
-                 Proposition.new("universal", "Free Decisions", "negative", "Caused Happenings", true),
-                 Proposition.new("universal", "Fun", "affirmative", "Events", true),
-                 Proposition.new("universal", "Fun", "affirmative", "Events", true),
-                 Proposition.new("universal", "Fun", "affirmative", "Events", true)]
+premisesArray = [Catlogic::Proposition.new("universal", "Events", "affirmative", "Caused Happenings", true),
+                 Catlogic::Proposition.new("universal", "Free Decisions", "negative", "Caused Happenings", true),
+                 Catlogic::Proposition.new("universal", "Fun", "affirmative", "Events", true),
+                 Catlogic::Proposition.new("universal", "Fun", "affirmative", "Events", true),
+                 Catlogic::Proposition.new("universal", "Fun", "affirmative", "Events", true)]
 
 
-collection = PremiseCollection.new(premisesArray)
+collection = Catlogic::PremiseCollection.new(premisesArray)
 
 reducedcollection = collection.reduceToUniqueSet
 

data/scripts/testSyllogism.rb

@@ -7,17 +7,17 @@ rescue LoadError
   require 'catlogic'
 end
 
-major = Proposition.new(Quantity.new("universal"), Term.new("pollution free"), Quality.new("negative"), Term.new("completely efficient"), true)
-minor = Proposition.new(Quantity.new("universal"), Term.new("automobile"), Quality.new("negative"), Term.new("completely efficient"), true)
-conclusion = Proposition.new(Quantity.new("universal"), Term.new("automobile"), Quality.new("negative"), Term.new("pollution free"), true)
-syllogism = Syllogism.new(major, minor, conclusion)
+major = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("pollution free"), Catlogic::Quality.new("negative"), Catlogic::Term.new("completely efficient"), true)
+minor = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("automobile"), Catlogic::Quality.new("negative"), Catlogic::Term.new("completely efficient"), true)
+conclusion = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("automobile"), Catlogic::Quality.new("negative"), Catlogic::Term.new("pollution free"), true)
+syllogism = Catlogic::Syllogism.new(major, minor, conclusion)
 
 puts "=========="
 puts "Testing syllogism (#{syllogism.form.label}):"
 puts "====Syllogism======"
 puts syllogism.label
 puts "====Propositional Form===="
-puts Form.new(syllogism.mood, syllogism.figure).syllogism.label
+puts Catlogic::Form.new(syllogism.mood, syllogism.figure).syllogism.label
 puts "=====Validity===="
 puts "Validity: #{syllogism.validity}"
 puts "=========="

data/scripts/testSyllogismForm.rb

@@ -7,9 +7,9 @@ rescue LoadError
   require 'catlogic'
 end
 
-mood = Mood.new(PropositionType.new("A"), PropositionType.new("A"), PropositionType.new("A"))
-figure = Figure.new(3)
-form = Form.new(mood, figure)
+mood = Catlogic::Mood.new(Catlogic::PropositionType.new("A"), Catlogic::PropositionType.new("A"), Catlogic::PropositionType.new("A"))
+figure = Catlogic::Figure.new(3)
+form = Catlogic::Form.new(mood, figure)
 puts "====================="
 puts "Testing: #{form.label}"
 

data/spec/distribution_spec.rb

@@ -4,20 +4,20 @@ require 'pry'
 
 describe 'distribution object' do
   it 'can return distribution label as string' do
-    term = Distribution.new('distributed')
+    term = Catlogic::Distribution.new('distributed')
     result = term.label
     result.should == 'distributed'
   end
 
   it 'can return distribution opposite label as string' do
-    term = Distribution.new('distributed')
+    term = Catlogic::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')
+    term = Catlogic::Distribution.new('undistributed')
     opposite = term.opposite
     result = opposite.label
     result.should == 'distributed'

data/spec/figure_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "catlogic"
 
 describe "figure object" do
-  $figure_1 = Figure.new(1)
+  $figure_1 = Catlogic::Figure.new(1)
 
   it "should return the label of the figure type object" do
     label = $figure_1.label

data/spec/form_spec.rb

@@ -2,9 +2,9 @@ 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)
+  mood_aaa = Catlogic::Mood.new(Catlogic::PropositionType.new('A'), Catlogic::PropositionType.new('A'), Catlogic::PropositionType.new('A'))
+  figure_1 = Catlogic::Figure.new(1)
+  $form = Catlogic::Form.new(mood_aaa, figure_1)
 
   it "should return form label" do
     label = $form.label

data/spec/mood_spec.rb

@@ -3,7 +3,7 @@ require "catlogic"
 
 describe "mood object" do
 
-  $moodobject_aaa = Mood.new(PropositionType.new('A'), PropositionType.new('A'), PropositionType.new('A'))
+  $moodobject_aaa = Catlogic::Mood.new(Catlogic::PropositionType.new('A'), Catlogic::PropositionType.new('A'), Catlogic::PropositionType.new('A'))
 
   it 'can display the label of the mood object' do
     mood = $moodobject_aaa.label