prop_logic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 37cd959dffbbeeb64bde6b241794bec73c4415a6
+  data.tar.gz: 3a836ab88dd8e721b0e10ed4f1d0d7ffdb93fdd1
+SHA512:
+  metadata.gz: 50f268b87efd5333fcbffbe2e72a48e13e87c25ed79e12d570f37043e692dae4d5eb02d9e7291e1262ee26e18509e0274dc018a801fb4d62ad60b4f2c214e37f
+  data.tar.gz: 1c74a4734264ed6395a0eba5806e03902c138b65f2ddc45551f01e9fd2ad36aa2f6e1ead12006749e4af542c064c015339f40853cf8ac6eefae0b4d46b40660f

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 2.3.0
+  - 2.2.4
+  - 2.1.6
+  - 2.0.0
+  - rbx-3.9
+  - jruby-9.0.1.0
+  

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in prop_logic.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jkr2255
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,140 @@
+# PropLogic
+
+[![Build Status](https://travis-ci.org/jkr2255/prop_logic.svg?branch=master)](https://travis-ci.org/jkr2255/prop_logic)
+
+PropLogic implements propositional logic in Ruby, usable like normal variables.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'prop_logic'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install prop_logic
+
+### Requirements
+Using with CRuby, Version >= 2.0.0 is required. Doesn't work stably on 1.9.x due to unreliable behaviors on weak reference.
+
+In JRuby and Rubinus it should work.
+
+## Usage
+### Overview
+First, variables can be declared using `PropLogic.new_variable`. Next, it can be calculated using normal Ruby operators
+such as `&`, `|`, `~`, and some methods. Finally, you can test satisfiability of these expressions.
+
+```ruby
+# declartion
+a = PropLogic.new_variable 'a'
+b = PropLogic.new_variable 'b'
+c = PropLogic.new_variable 'c'
+
+# calculation
+expr1 = (a & b) | c
+expr2 = ~(a.then(b))
+expr3 = expr1 | expr2
+
+# conversion
+nnf = expr3.to_nnf
+cnf = expr3.to_cnf
+sat = expr3.sat?
+
+# comparement
+diff = (~a | ~b).equiv?(~(a & b)) # true
+
+# assignment
+(a & b).assign_true(a).assign_false(b).reduce # PropLogic::False
+```
+
+## Restriction
+SAT solver bundled with this gem is brute-force solver (intended only for testing), so it is inappropriate to use for
+real-scale problems.
+
+## References
+`PropLogic::Term` is immutable, meaning that all calculations return new Terms.
+### `PropLogic::Term` instance methods
+#### `#and(*others)`, `#&(*others)`
+calculate `self & others[0] & others[1] & ...`.
+#### `#or(*others)`, `#|(*others)`
+calculate `self | others[0] | others[1] & ...`.
+
+#### Warning for reducing with `&` / `|`
+Because of immutability and internal system of and/or terms, `many_terms.reduce(&:and)` is exteremely slow.
+Use `PropLogic.all_and`/`PropLogic.all_or` or `one_term.and(*others)` to avoid this pitfall.
+
+#### `#not()`,`#~()`, `#-@()`
+calculate `Not(self)`. `#!` is not present because it confuses Ruby behavior. (if present, `!term` is always *truthy*)
+
+#### `#then(other), #>>(other)`
+caslculate `If self then other`.
+
+#### NNF
+NNF doesn't contain following terms:
+- If-then
+- Negation of And/Or
+- Double negation
+
+`#nnf?` checks if the term is NNF, and `#to_nnf` returns term converted to NNF.
+
+#### Reduction
+Term is regarded as reduced if it is NNF and it contains no constants (`PropLogic::True`/`PropLogic::False`).
+
+`#reduced?` checks if the term is reduced, and `#reduce` returns reduced term.
+
+#### Reduction
+CNF is one of these:
+1. Variable and its negation
+2. Logical sum of multiple 1
+3. Logical product of multiple (1 or 2)
+
+`#cnf?` checks if the term is CNF, and `#to_cnf` returns terms converted to CNF (may use extra variables).
+
+#### SAT judgement
+`#sat?` returns:
+- boolean `false` if unsatisfiable
+- `nil` if satisfiability is undetermined
+- One term satisfying original term if satisfiable
+
+`#unsat?` returns `true` if unsatisfiable, `false` otherwise.
+
+### `PropLogic` module methods
+#### `PropLogic.new_variable(name = nil)`
+declare new variable with name `name`. if `name` is not supplied, unique name is set.
+
+Notice that even if the same `name` as before specified, it returns *different* variable.
+
+#### `PropLogic.all_and(*terms)`/`PropLogic.all_or(*terms)`
+calculate all and/or of `terms`. Use this when and/or calculation for many variables.
+
+#### `PropLogic.sat_solver`/ PropLogic.sat_solver=`
+set/get SAT solver object. It shoud have `#call(term)` method and return value is described in `Term#sat?`.
+
+### Information
+`PropLogic::Term` has some subclasses, but these classes are subject to change.
+Using subclasses of `PropLogic::Term` directly is not recommended.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/prop_logic/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## ToDo
+
+- Introduce special blocks to build terms inside
+- Add nontrivial SAT solver for practical usage

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+task :default => [:spec]
+
+RSpec::Core::RakeTask.new

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "prop_logic"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/prop_logic/and_term.rb

@@ -0,0 +1,77 @@
+module PropLogic
+  class AndTerm < Term
+    def initialize(*terms)
+      @terms = terms.map{|t| t.is_a?(AndTerm) ? t.terms : t}.flatten.freeze
+      @is_nnf = @terms.all?(&:nnf?)
+      # term with negative terms are no longer terated as reduced
+      @is_reduced = @is_nnf && @terms.all? do |term|
+        if term.is_a?(Constant) || !term.reduced?
+          false
+        elsif !(term.is_a?(NotTerm))
+          true
+        else
+          # NotTerm
+          term.terms[0].is_a?(Variable)
+        end
+      end
+      return unless @is_reduced
+      # check contradicted variables (mark as unreduced)
+      # Negated terms (except variables) doesn't come here
+      not_terms = @terms.select{ |t| t.is_a?(NotTerm) }
+      negated_variales = not_terms.map{|t| t.terms[0]}
+      @is_reduced = false unless (negated_variales & @terms).empty?
+    end
+    
+    def to_s(in_term = false)
+      str = @terms.map(&:to_s_in_term).join(' & ')
+      in_term ? "( #{str} )" : str
+    end
+    
+    def nnf?
+      @is_nnf
+    end
+
+    def reduced?
+      @is_reduced
+    end
+    
+    def reduce
+      return self if reduced?
+      reduced_terms = @terms.map(&:reduce)
+      reduced_terms.reject!{|term| term.equal?(True)}
+      return True if reduced_terms.empty?
+      if reduced_terms.any?{|term| term.equal?(False)}
+        False
+      elsif reduced_terms.length == 1
+        reduced_terms[0]
+      else
+        # detect contradicted terms
+        not_terms = reduced_terms.select{|term| term.is_a?(NotTerm)}
+        negated_terms = not_terms.map{|term| term.terms[0]}
+        return False unless (negated_terms & reduced_terms).empty?
+        Term.get self.class, *reduced_terms
+      end
+    end
+    
+    def cnf?
+      return false unless reduced?
+      @terms.all?(&:cnf?)
+    end
+    
+    def to_cnf
+      return super unless reduced?
+      return self if cnf?
+      pool = []
+      without_pools = PropLogic.all_and(*@terms.map{|t| t.tseitin(pool)})
+      PropLogic.all_and(without_pools, *pool)
+    end
+    
+    def tseitin(pool)
+      val = Variable.new
+      terms = @terms.map{|t| t.cnf? ? t : t.tseitin(pool)}
+      pool.concat terms.map{|t| ~val | t }
+      val
+    end
+    
+  end
+end

data/lib/prop_logic/brute_force_sat_solver.rb

@@ -0,0 +1,20 @@
+module PropLogic
+  module BruteForceSatSolver
+    class << self
+      def call(term)
+        # obvious value
+        return True if term == True
+        variables = term.variables
+        PropLogic.all_combination(variables) do |trues|
+          falses = variables - trues
+          next unless term.assign(trues, falses).reduce == True
+          # SAT
+          negated_falses = falses.map(&:not)
+          return PropLogic.all_and(*trues, *negated_falses)
+        end
+        # UNSAT
+        false
+      end
+    end
+  end
+end

data/lib/prop_logic/constants.rb

@@ -0,0 +1,45 @@
+require 'singleton'
+
+module PropLogic
+  class Constant < Variable
+    def variables
+      []
+    end
+  
+    def to_cnf
+      self
+    end
+    
+  end
+  
+  class TrueConstant < Constant
+    include Singleton
+    def to_s(*)
+      'true'
+    end
+    
+    def assign(trues, falses, variables = nil)
+      if falses.include?(self)
+        raise ArgumentError, 'Contradicted assignment'
+      end
+      self
+    end
+    
+  end
+  
+  class FalseConstant < Constant
+    include Singleton
+    def to_s(*)
+      'false'
+    end
+    def assign(trues, falses, variables = nil)
+      if trues.include?(self)
+        raise ArgumentError, 'Contradicted assignment'
+      end
+      self
+    end
+  end
+  
+  True = TrueConstant.instance.freeze
+  False = FalseConstant.instance.freeze
+end

data/lib/prop_logic/functions.rb

@@ -0,0 +1,26 @@
+module PropLogic
+  module Functions
+    def all_or(*args)
+      Term.get OrTerm, *args
+    end
+    
+    def all_and(*args)
+      Term.get AndTerm, *args
+    end
+    
+    def new_variable(*args)
+      Variable.new *args
+    end
+  end
+  
+  extend Functions
+  
+  def all_combination(arr)
+    0.upto(arr.length) do |num|
+      arr.combination(num){|c| yield c}
+    end
+  end
+  
+  module_function :all_combination
+  
+end

data/lib/prop_logic/not_term.rb

@@ -0,0 +1,68 @@
+module PropLogic
+  class NotTerm < Term
+    def initialize(term)
+      @terms = [term].freeze
+    end
+    
+    def to_s(*)
+      "~" + @terms[0].to_s(true)
+    end
+    
+    def nnf?
+      @terms[0].is_a?(Variable)
+    end
+    
+    def to_nnf
+      term = @terms[0]
+      case term
+      when NotTerm
+        term.terms[0].to_nnf
+      when Variable
+        self
+      when ThenTerm
+        (~(term.to_nnf)).to_nnf
+      when AndTerm
+        PropLogic.all_or(*term.terms.map{|t| (~t).to_nnf})
+      when OrTerm
+        PropLogic.all_and(*term.terms.map{|t| (~t).to_nnf})
+      end
+    end
+    
+    def reduced?
+      nnf? && ! (@terms[0].is_a?(Constant))
+    end
+    
+    def reduce
+      return self if reduced?
+      reduced_term = @terms[0].reduce
+      case reduced_term
+      when TrueConstant
+        False
+      when FalseConstant
+        True
+      else
+        (~reduced_term).to_nnf
+      end
+    end
+    
+    def to_cnf
+      if reduced?
+        self
+      else
+        super
+      end
+    end
+    
+    def tseitin(pool)
+      if nnf?
+        self
+      elsif @terms[0].is_a?(NotTerm) && @terms[0].terms[0].is_a(Variable)
+        @terms[0].terms[0]
+      else
+        raise 'Non-NNF terms cannot be converted to Tseitin form.' + self.to_s
+      end
+    end
+    
+    alias_method :cnf?, :reduced?
+  end
+end

data/lib/prop_logic/or_term.rb

@@ -0,0 +1,75 @@
+module PropLogic
+  class OrTerm < Term
+    def initialize(*terms)
+      @terms = terms.map{|t| t.is_a?(OrTerm) ? t.terms : t}.flatten.freeze
+      @is_nnf = @terms.all?(&:nnf?) 
+      @is_reduced = @is_nnf && @terms.all? do |term|
+        if term.is_a?(Constant) || !(term.reduced?)
+          false
+        elsif !(term.is_a?(NotTerm))
+          true
+        else
+          # NotTerm
+          term.terms[0].is_a?(Variable)
+        end
+      end
+      return unless @is_reduced
+      # check obvious variables (mark as unreduced)
+      # Negated terms (except variables) doesn't come here
+      not_terms = @terms.select{ |t| t.is_a?(NotTerm) }
+      negated_variales = not_terms.map{|t| t.terms[0]}
+      @is_reduced = false unless (negated_variales & @terms).empty?
+    end
+    
+    def to_s(in_term = false)
+      str = @terms.map(&:to_s_in_term).join(' | ')
+      in_term ? "( #{str} )" : str
+    end
+    
+    def nnf?
+      @is_nnf
+    end
+    
+    def reduced?
+      @is_reduced
+    end
+    
+    def reduce
+      return self if reduced?
+      reduced_terms = @terms.map(&:reduce)
+      reduced_terms.reject!{|term| term.equal?(False)}
+      return False if reduced_terms.empty?
+      if reduced_terms.any?{|term| term.equal?(True)}
+        True
+      elsif reduced_terms.length == 1
+        reduced_terms[0]
+      else
+        not_terms = reduced_terms.select{|term| term.is_a?(NotTerm)}
+        negated_terms = not_terms.map{|term| term.terms[0]}
+        return True unless (negated_terms & reduced_terms).empty?
+        Term.get self.class, *reduced_terms
+      end
+    end
+    
+    def cnf?
+      return false unless reduced?
+      ! @terms.any?{ |term| term.is_a?(AndTerm) }
+    end
+    
+    def to_cnf
+      return super unless reduced?
+      return self if cnf?
+      pool = []
+      without_pools = tseitin(pool)
+      PropLogic.all_and(without_pools, *pool)
+    end
+    
+    def tseitin(pool)
+      val = Variable.new
+      terms = @terms.map{|t| t.tseitin(pool)}
+      pool << (~val | PropLogic.all_or(*terms))
+      val      
+    end
+
+  end
+end

data/lib/prop_logic/sat_solver.rb

@@ -0,0 +1,13 @@
+module PropLogic
+  #default
+  @@sat_solver = PropLogic::BruteForceSatSolver
+  
+  def self.sat_solver
+    @@sat_solver
+  end
+  
+  def self.sat_solver=(engine)
+    raise TypeError unless engine.respond_to?(:call)
+    @@sat_solver = engine
+  end
+end

data/lib/prop_logic/term.rb

@@ -0,0 +1,149 @@
+require 'ref'
+
+module PropLogic
+  class Term
+    def initialize
+      raise NotImplementedError, 'Term cannot be initialized'
+    end
+    
+    def initialize_copy(*)
+      raise TypeError, 'Term cannot be duplicated (immutable, not necessary)'
+    end
+    
+    class << self
+      protected :new
+    end
+
+    attr_reader :terms
+    
+    def and(*others)
+      others.unshift self
+      Term.get AndTerm, *others
+    end
+    
+    alias_method :&, :and
+    
+    def or(*others)
+      others.unshift self
+      Term.get OrTerm, *others
+    end
+    
+    alias_method :|, :or
+    
+    def not
+      Term.get NotTerm, self
+    end
+    
+    alias_method :~, :not
+    alias_method :-@, :not
+    
+    def then(other)
+      Term.get ThenTerm, self, other
+    end
+    
+    alias_method :>>, :then
+    
+    def to_s_in_term
+      to_s true
+    end
+    
+    def to_nnf
+      if nnf?
+        self
+      else
+        Term.get self.class, *@terms.map(&:to_nnf)
+      end
+    end
+    
+    def nnf?
+      false
+    end
+    
+    def reduce
+      if reduced?
+        self
+      else
+        Term.get self.class, *@terms.map(&:reduce)
+      end
+    end
+    
+    def reduced?
+      false
+    end
+    
+    def to_cnf
+      reduce.to_cnf
+    end
+    
+    def self.validate_terms(*terms)
+      terms.map do |term|
+        case term
+        when TrueClass
+          True
+        when FalseClass
+          False
+        when Term
+          term
+        else
+          raise TypeError, "#{term.class} cannot be treated as term"
+        end
+      end
+    end
+    
+    def self.get(klass, *terms)
+      @table ||= Ref::WeakValueMap.new
+      terms = validate_terms(*terms)
+      if klass == AndTerm || klass == OrTerm
+        terms = terms.map{|t| t.is_a?(klass) ? t.terms : t}.flatten
+      end 
+      key = klass.name + terms.map(&:object_id).join(',')
+      return @table[key] if @table[key]
+      ret = klass.__send__ :new, *terms
+      @table[key] = ret
+      ret.freeze
+    end
+    
+    def cnf?
+      false
+    end
+    
+    def variables
+      @terms.map(&:variables).flatten.uniq
+    end
+    
+    def assign(trues, falses, variables = nil)
+      # contradicted assignment
+      raise ArgumentError, 'Contradicted assignment' unless (trues & falses).empty?
+      variables ||= trues | falses
+      assigned_terms = terms.map do |term|
+        if (term.variables & variables).empty?
+          term
+        else
+          term.assign(trues, falses, variables)
+        end
+      end
+      Term.get self.class, *assigned_terms
+    end
+    
+    def assign_true(*variables)
+      assign variables, []
+    end
+    
+    def assign_false(*variables)
+      assign [], variables
+    end
+        
+    def sat?
+      PropLogic.sat_solver.call(self)
+    end
+    
+    def unsat?
+      sat? == false
+    end
+    
+    def equiv?(other)
+      ((self | other) & (~self | ~other)).unsat? 
+    end
+    
+  end
+end

data/lib/prop_logic/then_term.rb

@@ -0,0 +1,25 @@
+module PropLogic
+  class ThenTerm < Term
+    def initialize(term1, term2)
+      @terms = [term1, term2].freeze
+    end
+    
+    def to_s(in_term = false)
+      str = "#{@terms[0].to_s(true)} => #{@terms[1].to_s(true)}"
+      in_term ? "( #{str} )" : str
+    end
+    
+    def nnf?
+      false
+    end
+    
+    def to_nnf
+      (~@terms[0]).to_nnf | @terms[1].to_nnf
+    end
+    
+    def reduce
+      to_nnf.reduce
+    end
+  end
+
+end

data/lib/prop_logic/variable.rb

@@ -0,0 +1,49 @@
+module PropLogic
+  class Variable < Term
+    def initialize(name = nil)
+      @name = name || "v_#{object_id}"
+      @terms = [].freeze
+      freeze
+    end
+    
+    public_class_method :new
+    
+    def to_s(*)
+      @name
+    end
+    
+    def nnf?
+      true
+    end
+    
+    def reduced?
+      true
+    end
+    
+    def to_cnf
+      self
+    end
+    
+    def tseitin(pool)
+      self
+    end
+    
+    def cnf?
+      true
+    end
+    
+    def variables
+      [self]
+    end
+    
+    def assign(trues, falses, variables = nil)
+      if trues.include? self
+        True
+      elsif falses.include? self
+        False
+      else
+        self
+      end
+    end
+  end
+end

data/lib/prop_logic/version.rb

@@ -0,0 +1,3 @@
+module PropLogic
+  VERSION = "0.1.0"
+end

data/lib/prop_logic.rb

@@ -0,0 +1,11 @@
+require "prop_logic/version"
+require "prop_logic/term"
+require "prop_logic/and_term"
+require "prop_logic/or_term"
+require "prop_logic/not_term"
+require "prop_logic/then_term"
+require 'prop_logic/variable'
+require 'prop_logic/constants'
+require 'prop_logic/functions'
+require 'prop_logic/brute_force_sat_solver'
+require 'prop_logic/sat_solver'

data/prop_logic.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'prop_logic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "prop_logic"
+  spec.version       = PropLogic::VERSION
+  spec.authors       = ["Jkr2255"]
+  spec.email         = ["magnesium.oxide.play@gmail.com"]
+
+  spec.summary       = %q{Propositional logic for Ruby}
+  spec.description   = %q{Write propositional logic formulae using Ruby DSL.}
+  spec.homepage      = "https://github.com/jkr2255/prop_logic"
+  spec.license       = "MIT"
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency "ref", '~> 2.0'
+  spec.required_ruby_version = '>= 2.0.0'
+
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", '~> 3.0'
+  # spec.add_development_dependency "pry-byebug", '~> 3.3'
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: prop_logic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jkr2255
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ref
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Write propositional logic formulae using Ruby DSL.
+email:
+- magnesium.oxide.play@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/prop_logic.rb
+- lib/prop_logic/and_term.rb
+- lib/prop_logic/brute_force_sat_solver.rb
+- lib/prop_logic/constants.rb
+- lib/prop_logic/functions.rb
+- lib/prop_logic/not_term.rb
+- lib/prop_logic/or_term.rb
+- lib/prop_logic/sat_solver.rb
+- lib/prop_logic/term.rb
+- lib/prop_logic/then_term.rb
+- lib/prop_logic/variable.rb
+- lib/prop_logic/version.rb
+- prop_logic.gemspec
+homepage: https://github.com/jkr2255/prop_logic
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Propositional logic for Ruby
+test_files: []