automata 0.1.0 → 1.0.0

data/.gitignore

@@ -15,3 +15,6 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.sublime-project
+*.sublime-workspace
+*.tmproj

data/README.md

@@ -39,26 +39,24 @@ We can easily define a machine's _n_-tuples in a YAML file. For example, let's c
       - C
       - D
     alphabet:
-      - '0'
-      - '1'
+      - 0
+      - 1
     start: A
     accept:
       - C
     transitions:
       A:
-        '0': B
-        '1': D
+        0: B
+        1: D
       B:
-        '0': C
-        '1': D
+        0: C
+        1: D
       C:
-        '0': C
-        '1': C
+        0: C
+        1: C
       D:
-        '0': D
-        '1': D
-        
-__Note:__ Integer hash keys are currently unsupported, hence they must be wrapped in quotes.
+        0: D
+        1: D
 
 With our machine defined, we can create a new DFA object from the file.
 
@@ -87,11 +85,11 @@ Now that we've built a machine, we can pass it input and let it work its magic.
     >> dfa.accepts? '0101'
     => false
     
-Awesomesauce.
+Awesomesauce. Please refer to the [wiki](https://github.com/jico/automata/wiki "automata wiki") for more details.
 
 ## Special Characters
 
-* _&_ - Represents an ε-transition (epsilon transition)
+* _&_ - Represents an ε-transition (epsilon transition). Note that you must wrap the symbol in quotes.
 
 ## Contributing
 

data/automata.gemspec

@@ -2,7 +2,7 @@
 require File.expand_path('../lib/automata/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Jico Baligod"]
+  gem.authors       = ["Jico Baligod", "Lukas Sabota"]
   gem.email         = ["jico@baligod.com"]
   gem.description   = %q{Create and simulate automaton.}
   gem.summary       = %q{This gem provides a number of classes to create and simulate Deterministic/Nondeterministic Finite Automata, Push-down Automata, and Turing Machines.}

data/examples/pda_sample.yml

@@ -0,0 +1,38 @@
+## # Sample PDA file.
+#
+# Accepts balanced parentheses only.
+#
+# '@' to represent delta
+# 'ACCEPT' to represent unique, single start state
+states:
+  - S
+  - A
+  - B
+  - ha
+alphabet:
+  - '('
+  - ')'
+start: S
+accept: ha
+transitions:
+  S:
+    '&':
+      to: 'A'
+      push: '@'
+  A:
+    '(':
+      to: 'A'
+      push: 'x'
+    ')':
+      to: 'B'
+      pop: 'x'
+  B:
+    '(':
+      to: 'A'
+      push: 'x'
+    ')':
+      to: 'B'
+      pop: 'x'
+    '&':
+      to: 'ha'
+      pop: '@'

data/examples/turing_1.yml

@@ -0,0 +1,49 @@
+##
+# Sample TM build file
+#
+# Accepts all binary strings containing
+# the substring 101.
+#
+# Notes:
+# '@' denotes the blank for the tape alphabet
+# 'ACCEPT' denotes unique accept state (include in transition)
+# 'REJECT' denotes unique reject state (include in transition)
+states:
+  - A
+  - B
+  - C
+inputAlphabet:
+  - 0
+  - 1
+tapeAlphabet:
+  - 0
+  - 1
+start: A
+transitions:
+  A:
+    0:
+      to: A
+      write: 0
+      move: R
+    1:
+      to: B
+      write: 1
+      move: R
+  B:
+    1:
+      to: B
+      write: 1
+      move: R
+    0:
+      to: C
+      write: 0
+      move: R
+  C:
+    1:
+      to: ACCEPT
+      write: 1
+      move: R
+    0:
+      to: A
+      write: 0
+      move: R

data/lib/automata.rb

@@ -3,6 +3,8 @@ require 'yaml'
 require "automata/state_diagram"
 require "automata/dfa"
 require "automata/nfa"
+require "automata/pda"
+require "automata/turing"
 
 module Automata
 
@@ -18,4 +20,4 @@ class Hash
     obj = obj.inject({}){|h,(k,v)| h[k.to_s] = Hash.keys_to_strings(v); h}
     return obj
   end
-end
+end

data/lib/automata/dfa.rb

@@ -18,14 +18,33 @@ module Automata
       return true
     end
     
+    # Runs the input on the machine and returns a Hash describing
+    # the machine's final state after running.
+    #
+    # @param [String] input the string to use as input for the DFA
+    # @return [Hash] a hash describing the DFA state after running
+    #   * :input [String] the original input string
+    #   * :accept [Boolean] whether or not the DFA accepted the string
+    #   * :head [String] the state which the head is currently on
+    def feed(input)
+      head = @start.to_s
+      input.each_char { |symbol| head = @transitions[head][symbol] }
+      accept = is_accept_state? head
+      resp = {
+        input: input,
+        accept: accept,
+        head: head 
+      }
+      resp
+    end
+
     # Determines whether the DFA accepts a given string.
     #
     # @param [String] input the string to use as input for the DFA.
     # @return [Boolean] whether or not the DFA accepts the string.
     def accepts?(input)
-      head = @start.to_s
-      input.each_char { |symbol| head = @transitions[head][symbol] }
-      is_accept_state? head
+      resp = feed(input)
+      resp[:accept]
     end
     
     # Determines if a given state is an accept state.

data/lib/automata/nfa.rb

@@ -5,11 +5,15 @@ module Automata
     #   Iterate through each states to verify the graph
     #   is not disjoint.
     
-    # Determines whether the NFA accepts a given string.
+    # Runs the input on the machine and returns a Hash describing
+    # the machine's final state after running.
     #
-    # @param [String] input the string to use as input for the NFA.
-    # @return [Boolean] Whether or not the NFA accepts the input string.
-    def accepts?(input)
+    # @param [String] input the string to use as input for the NFA
+    # @return [Hash] a hash describing the NFA state after running
+    #   * :input [String] the original input string
+    #   * :accept [Boolean] whether or not the NFA accepted the string
+    #   * :heads [Array] the state which the head is currently on
+    def feed(input)
       heads = [@start]
       
       # Move any initial e-transitions
@@ -41,8 +45,23 @@ module Automata
         break if heads.empty?
       end
       
-      heads.each { |head| return true if accept_state? head }
-      false
+      accept = false
+      heads.each { |head| accept = true if accept_state? head }
+
+      resp = {
+        input: input,
+        accept: accept,
+        heads: heads
+      }
+    end
+
+    # Determines whether the NFA accepts a given string.
+    #
+    # @param [String] input the string to use as input for the NFA.
+    # @return [Boolean] Whether or not the NFA accepts the input string.
+    def accepts?(input)
+      resp = feed(input)
+      resp[:accept]
     end
     
     # Determines the transition states, if any, from a given 

data/lib/automata/pda.rb

@@ -0,0 +1,159 @@
+module Automata
+  # Push Down Automata
+  class PDA < NFA
+    attr_accessor :stack
+
+    # Initialize a PDA object.
+    def initialize(params={})
+      super(params)
+      @alphabet << '&' unless !@alphabet || @alphabet.include?('&')
+      @stack = []
+    end
+
+    # Runs the input on the machine and returns a Hash describing
+    # the machine's final state after running.
+    #
+    # @param [String] input the string to use as input for the PDA
+    # @return [Hash] a hash describing the PDA state after running
+    #   * :input [String] the original input string
+    #   * :accept [Boolean] whether or not the PDA accepted the string
+    #   * :heads [Array] the state which the head is currently on
+    def feed(input)
+      heads, @stack, accept = [@start], [], false
+      
+      # Move any initial e-transitions
+      eTrans = transition(@start, '&') if has_transition?(@start, '&')
+      heads += eTrans
+
+      puts "initial heads: #{heads}"
+      puts "initial stack: #{@stack}"
+
+      # Iterate through each symbol of input string
+      input.each_char do |symbol|
+        newHeads = []
+        
+        puts "Reading symbol: #{symbol}"
+
+        heads.each do |head|
+          puts "At head #{head}"
+
+          # Check if head can transition read symbol
+          # Head dies if no transition for symbol
+          if has_transition?(head, symbol)
+            puts "Head #{head} transitions #{symbol}"
+            puts "stack: #{@stack}"
+            transition(head, symbol).each { |t| newHeads << t }
+            puts "heads: #{newHeads}"
+            puts "stack: #{@stack}"
+          end
+
+        end
+        
+        heads = newHeads
+        break if heads.empty?
+      end
+
+      puts "Loop finished"
+      
+      accept = includes_accept_state? heads
+
+      puts "heads: #{heads}"
+      puts "stack: #{stack}"
+      puts "accept: #{accept}"
+
+      resp = {
+        input: input,
+        accept: accept,
+        heads: heads,
+        stack: stack
+      }
+    end
+
+
+    # Determines whether the PDA accepts a given string.
+    #
+    # This method is intended to override the parent accepts method.
+    #
+    # @param [String] input the string to use as input for PDA.
+    # @return [Boolean] whether or not the PDA accepts the string.
+    def accepts?(input)
+      resp = feed(input)
+      resp[:accept]
+    end
+
+    # Determines the transition states, if any, from a given 
+    # beginning state and input symbol pair.
+    #
+    # @param [String] state state label for beginning state.
+    # @param [String] symbol input symbol.
+    # @return [Array] Array of destination transition states.
+    def transition(state, symbol, stackTop=nil)
+      dests = []
+
+      if has_transition?(state, symbol)
+        actions = @transitions[state][symbol]
+        stackTop ||= @stack.last
+        able = true
+        @stack.push actions['push'] if actions['push']
+        if actions['pop']
+          able = false unless stackTop == actions['pop']
+          @stack.pop if able
+        end
+        if able
+          dests << actions['to']
+
+          if has_transition?(actions['to'], '&')
+            actions = @transitions[actions['to']]['&']
+            able = true
+            @stack.push actions['push'] if actions['push']
+            if actions['pop']
+              able = false unless @stack.last == actions['pop']
+              @stack.pop if able
+            end
+            if able
+              dests << actions['to']
+            end
+          end
+          dests
+        else
+          return dests
+        end
+      else
+        return []
+      end
+    end
+
+    def pop?(symbol)
+      @stack.last == symbol
+    end
+
+    # Determines whether or not any transition states exist
+    # given a beginning state and input symbol pair.
+    #
+    # @param (see #transition)
+    # @return [Boolean] Whether or not a transition exists.
+    def has_transition?(state, symbol)
+      return false unless @transitions.has_key? state
+      if @transitions[state].has_key? symbol
+        actions = @transitions[state][symbol]
+        return false if actions['pop'] && @stack.last != actions['pop']
+        return true
+      else
+        return false
+      end
+    end
+
+    # Determines if a given state is an accept state.
+    #
+    # @param [String] state the state label to check.
+    # @return [Boolean] whether or not the state is an accept state.
+    def accept_state?(state)
+      @accept.include? state
+    end
+
+    def includes_accept_state?(states)
+      states.each { |s| return true if accept_state? s }
+      return false
+    end
+  end
+end

data/lib/automata/turing.rb

@@ -0,0 +1,157 @@
+module Automata
+  # Turing Machine
+  class Turing < StateDiagram
+    attr_accessor :inputAlphabet, :tapeAlphabet, :tape, :reject
+
+    # @todo Check that each state is connected.
+    #   Iterate through each states to verify the graph
+    #   is not disjoint.
+
+    def initialize(params={})
+      yaml = {}
+      yaml = YAML::load_file(params[:file]) if params.has_key? :file
+      super(params)
+      @inputAlphabet = params[:inputAlphabet] || yaml['inputAlphabet']
+      @tapeAlphabet = params[:tapeAlphabet] || yaml['tapeAlphabet']
+      @tape = Tape.new
+      @accept = false
+      @reject = false
+    end
+    
+    # Runs the input on the turing machine and returns a Hash describing
+    # the machine's final state after running.
+    #
+    # @param [String] input the string to use as input/tape for the TM
+    # @return [Hash] a hash describing the TM state after running
+    #   * :input [String] the original input string
+    #   * :accept [Boolean] whether or not the TM halted in an accept state
+    #   * :reject [Boolean] whether or not the TM halted in a reject state
+    #   * :head [String] the state which the head halted
+    #   * :tape [String] the resulting tape string
+    def feed(input) 
+      @tape = Tape.new(input)
+      @accept = false
+      @reject = false
+
+      stateHead = @start.to_s
+      input.each_char do |symbol|
+        toState = transition(stateHead, symbol)
+        if @accept || @reject
+          break
+        else
+          stateHead = toState
+        end
+      end
+      
+      resp = {
+        input: input,
+        accept: @accept,
+        reject: @reject,
+        head: stateHead,
+        tape: @tape.memory,
+        output: @tape.output
+      }
+      resp
+    end
+
+    # Determines whether the TM halts in an accept state.
+    #
+    # @param [String] input the string to use as input for the TM.
+    # @return [Boolean] Whether or not the TM accepts the input string.
+    def accepts?(input)
+      resp = feed(input)
+      resp[:accept]
+    end
+    
+    # Determines whether the TM halts in an reject state.
+    #
+    # @param [String] input the string to use as input for the TM.
+    # @return [Boolean] Whether or not the TM rejects the input string.
+    def rejects?(input)
+      resp = feed(input)
+      resp[:reject]
+    end
+
+    # Determines the transition states, if any, from a given 
+    # beginning state and input symbol pair.
+    #
+    # @note Turing machines have two unique states:
+    #   * +ACCEPT+ Unique accept state 
+    #   * +REJECT+ Unique reject state
+    # @param [String] state state label for beginning state.
+    # @param [String] symbol input symbol.
+    # @return [Array] Array of destination transition states.
+    def transition(state, symbol)
+      actions = @transitions[state][symbol]
+      @tape.transition(symbol, actions['write'], actions['move'])
+
+      # Flip the bits for halting states
+      @accept = true if actions['to'] == 'ACCEPT'
+      @reject = true if actions['to'] == 'REJECT'
+      @head = actions['to']
+    end
+    
+    # Determines whether or not any transition states exist
+    # given a beginning state and input symbol pair.
+    #
+    # @param (see #transition)
+    # @return [Boolean] Whether or not a transition exists.
+    def has_transition?(state, read)
+      return false unless @transitions.include? state
+      @transitions[state].has_key? read
+    end
+    
+  end
+
+  # Turing Machine tape
+  class Tape
+    attr_accessor :memory
+
+    # Creates a new tape.
+    # 
+    # @param [String] string the input string
+    def initialize(string=nil)
+      if string
+        @memory = []
+        @memory << '@' unless string[0] == '@'
+        @memory += string.split('')
+        @memory << '@' unless string[-1] == '@'
+        @head = 1
+      end
+    end
+
+    # Transitions the tape.
+    #
+    # @param [String] read the input symbol read
+    # @param [String] write the symbol to write
+    # @param [String] move Either 'L', 'R', or 'S' (default) to 
+    #   move left, right, or stay, respectively.
+    # @return [Boolean] whether the transition succeeded
+    def transition(read, write, move)
+      if read == @memory[@head]
+        @memory[@head] = write
+        case move
+        when 'R'
+          # Move right
+          @memory << '@' if @memory[@head + 1]
+          @head += 1
+        when 'L'
+          # Move left
+          @memory.unshift('@') if @head == 0
+          @head -= 1
+        end
+        return true
+      else
+        return false
+      end
+    end
+
+    # Trims the memory empty cells and outputs the tape string.
+    #
+    # @return [String] the tape memory string
+    def output
+      @memory.join.sub(/^@*/, '').sub(/@*$/, '')
+    end
+
+  end
+end

data/lib/automata/version.rb

@@ -1,3 +1,3 @@
 module Automata
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/spec/pda_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Automata::PDA do
+  
+  ##
+  # balanced bracket pda
+  #
+  context "Initializing from a valid file" do
+    before do
+      @pda = Automata::PDA.new(file: 'examples/pda_sample.yml')
+    end
+
+    it "should have transition S, &" do
+      @pda.has_transition?('S','&').should == true
+    end
+
+    it "should have transition A, (" do
+      @pda.has_transition?('S','&').should == true
+    end
+    
+    it "should accept '()'" do
+      @pda.accepts?('()').should == true
+    end
+    
+    it "should accept '(())'" do
+      @pda.accepts?('(())').should == true
+    end
+    
+    it "should not accept the empty string" do
+      @pda.accepts?('').should == false
+    end
+    
+    it "should not accept '(('" do
+      @pda.accepts?('((').should == false
+    end
+    
+    it "should not accept '())'" do
+      @pda.accepts?('())').should == false
+    end
+    
+    it "should accept '(()())'" do
+      @pda.accepts?('(()())').should == true
+    end
+    
+    it "should not accept '(()'" do
+      @pda.accepts?('(()').should == false
+    end
+  end
+  
+  context "Initializing an empty pda" do
+    before do
+      @pda = Automata::PDA.new
+    end
+    
+    it "should be created successfully" do
+      @pda.should be_an_instance_of Automata::PDA
+    end
+  end
+end

data/spec/turing_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe Automata::Turing do
+  
+  ##
+  # Turing from file
+  #
+  context "Initializing from a valid file" do
+    before do
+      @turing = Automata::Turing.new(file: 'examples/turing_1.yml')
+    end
+    
+    it "should not accept '0'" do
+      @turing.accepts?('0').should == false
+    end
+    
+    it "should not accept '1'" do
+      @turing.accepts?('1').should == false
+    end
+    
+    it "should not accept the empty string" do
+      @turing.accepts?('').should == false
+    end
+    
+    it "should not accept '01'" do
+      @turing.accepts?('01').should == false
+    end
+    
+    it "should accept '101'" do
+      @turing.accepts?('101').should == true
+    end
+    
+    it "should accept '1010'" do
+      @turing.accepts?('1010').should == true
+    end
+    
+    it "should accept '01011'" do
+      @turing.accepts?('01011').should == true
+    end
+  end
+  
+  context "Initializing an empty Turing" do
+    before do
+      @turing = Automata::Turing.new
+    end
+    
+    it "should be created successfully" do
+      @turing.should be_an_instance_of Automata::Turing
+    end
+  end
+  
+  ##
+  # Turing params
+  #
+  context "Initializing a Turing by params" do
+    before do
+      states = ['A','B','C']
+      inputAlphabet = [0,1]
+      tapeAlphabet = [0,1]
+      start = 'A'
+      transitions = {
+        'A' => {
+          0 => {
+            to: 'A',
+            write: 0,
+            move: 'R'
+          },
+          1 => {
+            to: 'B',
+            write: 1,
+            move: 'R'
+          }
+        },
+        'B' => {
+          0 => {
+            to: 'C',
+            write: 0,
+            move: 'R'
+          },
+          1 => {
+            to: 'B',
+            write: 1,
+            move: 'R'
+          }
+        },
+        'C' => {
+          0 => {
+            to: 'A',
+            write: 0,
+            move: 'R'
+          },
+          1 => {
+            to: 'ACCEPT',
+            write: 1,
+            move: 'R'
+          }
+        }
+      }
+      params = {
+        states: states,
+        inputAlphabet: inputAlphabet,
+        tapeAlphabet: tapeAlphabet,
+        start: start,
+        transitions: transitions
+      }
+      @turing = Automata::Turing.new(params)
+    end
+    
+    it "should be created successfully" do
+      @turing.should be_an_instance_of Automata::Turing
+    end
+    
+    it "should not accept '0'" do
+      @turing.accepts?('0').should == false
+    end
+    
+    it "should not accept '1'" do
+      @turing.accepts?('1').should == false
+    end
+    
+    it "should not accept the empty string" do
+      @turing.accepts?('').should == false
+    end
+    
+    it "should not accept '01'" do
+      @turing.accepts?('01').should == false
+    end
+    
+    it "should accept '101'" do
+      @turing.accepts?('101').should == true
+    end
+    
+    it "should accept '1010'" do
+      @turing.accepts?('1010').should == true
+    end
+    
+    it "should accept '01011'" do
+      @turing.accepts?('01011').should == true
+    end
+  end
+end

metadata

@@ -1,19 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: automata
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
 - Jico Baligod
+- Lukas Sabota
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-27 00:00:00.000000000 Z
+date: 2012-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70286071406040 !ruby/object:Gem::Requirement
+  requirement: &70159780666060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70286071406040
+  version_requirements: *70159780666060
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70286071405420 !ruby/object:Gem::Requirement
+  requirement: &70159780280380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +33,7 @@ dependencies:
         version: 2.9.0
   type: :development
   prerelease: false
-  version_requirements: *70286071405420
+  version_requirements: *70159780280380
 description: Create and simulate automaton.
 email:
 - jico@baligod.com
@@ -50,14 +51,20 @@ files:
 - examples/dfa_sample.yml
 - examples/nfa_1.yml
 - examples/nfa_2.yml
+- examples/pda_sample.yml
+- examples/turing_1.yml
 - lib/automata.rb
 - lib/automata/dfa.rb
 - lib/automata/nfa.rb
+- lib/automata/pda.rb
 - lib/automata/state_diagram.rb
+- lib/automata/turing.rb
 - lib/automata/version.rb
 - spec/dfa_spec.rb
 - spec/nfa_spec.rb
+- spec/pda_spec.rb
 - spec/spec_helper.rb
+- spec/turing_spec.rb
 homepage: http://github.com/jico/automata
 licenses: []
 post_install_message: 
@@ -72,7 +79,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3744273630478255702
+      hash: -3684933468062137733
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -81,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3744273630478255702
+      hash: -3684933468062137733
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.17
@@ -92,4 +99,6 @@ summary: This gem provides a number of classes to create and simulate Determinis
 test_files:
 - spec/dfa_spec.rb
 - spec/nfa_spec.rb
+- spec/pda_spec.rb
 - spec/spec_helper.rb
+- spec/turing_spec.rb