rlsm 0.2.4 → 0.4.0

data/lib/smon/commands/quit.rb

@@ -1,10 +0,0 @@
-#category base
-
-=begin help
-Exits the program.
-
-=end
-def quit
-  puts "Bye."
-  @quit = true
-end

data/lib/smon/commands/regexp.rb

@@ -1,20 +0,0 @@
-#category RLSM
-=begin help
-Creates a new Regular Expression.
-
-Usage: regexp "desc"
-
-+desc+ is here a description of the regexp.
-A regexp may consist of
- - normal characters like a,b,c, 1,2, ... 
- - Special characters are
-   - &   : the emmpty word
-   - |   : Union
-   - ( ) : Grouping of expressions
-   - *   : Kleene star
-
-=end
-
-def regexp(desc)
-  RLSM::RegExp.new desc
-end

data/lib/smon/commands/reload.rb

@@ -1,22 +0,0 @@
-#category base
-=begin help
-Reloads a command.
-
-Usage: reload "cmd"
-
-Unloads the command +cmd+ if it exists, then tries to reload it.
-For reloading, the program searches for an file "cmd.rb" in the load path.
-=end
-
-def reload(cmd)
-  return false unless Commands.include? cmd
-
-  #Removes the help entries and the command
-  Commands.delete cmd
-  CmdHelp.delete cmd
-  Categories.each do |cat|
-    cat.delete cmd
-  end
-
-  load(File.join(LoadPath, cmd + '.rb'))
-end

data/lib/smon/commands/show.rb

@@ -1,21 +0,0 @@
-#category RLSM
-=begin help
-Shows a monoid or a regexp.
-
-Usage: show obj
-
-+obj+ is either a regexp or a monoid. If regexp a string representation is shown
-if monoid, the binary operation is shown as a table.
-Example: show monoid("0")
-Not working: show "0" !
-=end
-
-def show(obj)
-  if obj.class == Array
-    obj.each { |o| puts Presenter.to_txt o }
-    puts 
-  else
-    puts Presenter.to_txt obj
-    puts
-  end
-end

data/lib/smon/presenter.rb

@@ -1,18 +0,0 @@
-require File.join(File.dirname(__FILE__), 'presenter', 'txt_presenter')
-
-class Presenter
-  #Returns a LaTeX representation of the given object as a string.
-  def self.to_tex(obj, opts = {})
-    puts "Not yet implemented"
-  end
-
-  #Returns an ASCII representation of the given object as a string.
-  def self.to_txt(obj)    
-    TxtPresenter.new.output obj
-  end
-
-  #Creates a pdf document in the tmp directory.
-  def self.to_pdf(obj, opts = {})
-    puts "Not yet implemented"
-  end
-end

data/lib/smon/presenter/txt_presenter.rb

@@ -1,157 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'rlsm')
-
-class TxtPresenter
-  #Returns a string with a txt representation of the given object.
-  def output(obj)
-    self.send obj.class.to_s[(6..-1)].downcase.to_sym, obj
-  end
-
-  private
-  def monoid(m, with_syntactic_stuff = true)
-    out = "Monoid '#{m.hash}':\n"
-
-    #The binary operation:
-    out += binop_to_txt(m)
-
-    #The properties
-    out += basic_props(m)
-    out += submonoids_to_txt(m)
-    out += classes_to_txt(m)
-    out += special_elements(m)
-
-    out += syntactic_stuff(m) if with_syntactic_stuff and m.syntactic?
-
-    out
-  end
-
-  def regexp(re)
-    out = "RegExp: #{re.to_s}\n\n"
-    out += "Corresponding DFA:\n"
-    dfa = re.to_dfa
-    out += dfa.to_s + "\n\n"
-    out += "Corresponding syntactic monoid:\n"
-    out + monoid(dfa.syntactic_monoid, false)
-  end
-
-  def dfa(dfa)
-    min = dfa.minimal?
-    
-    out = "DFA"
-    if min
-      out += " (is minimal):\n"
-    else
-      out += " (not minimal):\n"
-    end
-    
-    out += dfa.to_s
-    out += "\nCorresponding RegExp: #{dfa.to_regexp}\n\n"
-    
-    if min     
-      out += "Transition monoid:\n"
-      out += monoid(dfa.syntactic_monoid, false)
-    else
-      out += "Transition monoid:\n"
-      out += binop_to_txt(dfa.transition_monoid)
-      out += "\n\nSyntactic Monoid (the transition monoid of the minimal DFA):\n"
-      out += monoid(dfa.syntactic_monoid, false)
-    end
-
-    out
-  end
-
-  def set_to_list(set, names)
-    set.map {|x| names[x]}.join(', ')
-  end
-
-  def translate_binop(m)
-   m.binary_operation.flatten.map { |c| m.elements[c] } / m.order
-  end
-
-  def binop_to_txt(m)
-    table = translate_binop(m)
-    col_width = (0...m.order).to_a.map { |i| table.map { |r| r[i].length }.max }
-
-    i = -1
-    table.map! do |row|
-      i += 1
-      row.inject("|") { |r,x| r + " #{x} " + " "*(col_width[i]-x.length) + "|" }
-    end
-
-    row_sep = "\n" + table.first.scan(/./m).map { |c| c == '|' ? '+' : '-' }.join + "\n"
-
-    row_sep + table.join(row_sep) + row_sep + "\n"
-  end
-
-  def basic_props(m)
-    out = "Order:      #{m.order}\n"
-    out += "Generators: #{set_to_list m.generating_subset, m.elements}\n"
-    out + "Properties: #{props m}\n\n"
-  end
-
-  def props(m)
-    str = ['commutative', 'idempotent', 'aperiodic', 'syntactic', 'group'].select do |p|
-      m.send((p + '?').to_sym)
-    end.join(', ')
-  end
-
-  def submonoids_to_txt(m)
-    psm = m.proper_submonoids
-    out = "Submonoids: "    
-    
-    if psm.empty?
-      out += "none\n\n"
-    else
-      out += psm.map! do |sm|
-        translate_binop(sm).map { |r| r.join(sm.order > 10 ? ',' : '') }.join(" ")
-      end.join("; ")
-      
-      out += "\n\n"
-    end
-
-    out
-  end
-
-  def classes_to_txt(m)
-    out = "L-Classes: " + m.l_classes.map { |c| "{#{ set_to_list c, m.elements}}" }.join('; ')
-    out += "\n"
-    out += "R-Classes: " + m.r_classes.map { |c| "{#{ set_to_list c, m.elements}}" }.join('; ')
-    out += "\n"
-    out += "H-Classes: " + m.h_classes.map { |c| "{#{ set_to_list c, m.elements}}" }.join('; ')
-    out += "\n"
-    out += "D-Classes: " + m.d_classes.map { |c| "{#{ set_to_list c, m.elements}}" }.join('; ')
-    out + "\n\n"
-  end
-
-  def special_elements(m)
-    out = "Special Elements:\n"
-    out += "Null Element: " + (m.null_element ? m.elements[m.null_element] : 'none') + "\n"
-    out += "Idempotents: #{set_to_list m.idempotents, m.elements}\n"
-
-    unless m.null_element
-      rn, ln = m.right_nulls, m.left_nulls
-      unless rn.empty?
-        out += "Right Nulls: #{set_to_list rn, m.elements}\n"
-      end
-
-      unless ln.empty?
-        out += "Left Nulls: #{set_to_list ln, m.elements}\n"
-      end
-    end
-
-    out + "\n"
-  end
-
-  def syntactic_stuff(m)
-    out = "Disjunctive Subsets: " + m.all_disjunctive_subsets.map do |dss|
-      "{"+ set_to_list(dss, m.elements) + "}"
-    end.join("; ") + "\n"
-
-    dfa = m.to_dfa
-    re = dfa.to_regexp
-    
-    out += "DFA for {#{set_to_list m.disjunctive_subset, m.elements}}:\n"
-    out += dfa.to_s + "\n\n"
-      
-    out + "Corresponding RegExp: #{re.to_s}\n\n"
-  end
-end

data/lib/smon/smon.rb

@@ -1,79 +0,0 @@
-require "readline"
-require "abbrev"
-require "rubygems"
-require File.join(File.dirname(__FILE__), '..', 'rlsm')
-require File.join(File.dirname(__FILE__), 'presenter')
-
-class Smon
-  Commands = []
-  CmdHelp = {}
-  Categories = {}
-  LoadPath = File.join(File.dirname(__FILE__), 'commands')
-
-  def initialize
-    #Load all commands
-    cmds = Dir.glob(File.join(LoadPath, '*.rb'))
-    cmds.each do |cmd|
-      load cmd, false
-    end
-
-    #Add the built-in commands to the help system
-    Commands << 'load'
-    CmdHelp['load'] = ["Loads a command into the system.\n",
-                       "\nUsage: load /path/to/cmd\n",
-                       "\n Loads the file at the given location and prints a small message if loading succeded."]
-    Categories['built-in'] = ['load']
-
-    #Initialize the help system
-    @cmd_abbrev = Commands.abbrev
-
-    #Setting up readline
-    Readline.completion_proc = lambda { |str| @cmd_abbrev[str] }
-
-    loop do
-      begin
-        instance_eval Readline.readline("rlsm (help for help) :> ", true)
-      rescue Exception => e
-        puts "Something went wrong."
-        puts e
-      end
-
-      break if @quit
-    end    
-  end
-
-  def load(file, reinit = true)
-    #Parsing the file
-    cat = nil
-    name = nil
-    help = []
-    parse_help = false
-    input = []
-    File.open(file).each_line do |line|
-      #Extracting the help
-      parse_help = false if line =~ Regexp.new("=end.*") 
-      help << line if parse_help
-      parse_help = true if line =~ Regexp.new("=begin.*")
-      
-
-      #Getting the category
-      cat = $1.dup if line =~ Regexp.new("#category\\s\+\(\\w\+\)")
-
-      #Getting the name
-      name = $1.dup if line =~ /def\s+(\w+)/
-
-      input << line
-    end
-
-    #Adding the method
-    self.class.class_eval input.join
-
-    #Setting up the help system
-    (Categories[cat] ||= []) << name
-    Commands << name
-    CmdHelp[name] = help
-    
-    @cmd_abbrev = Commands.abbrev if reinit
-  end
-end
-

data/test/dfa_spec.rb

@@ -1,99 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'lib', 'rlsm', 'dfa')
-
-describe RLSM::DFA do
-  before :each do
-    @dfa = RLSM::DFA.new ['a'],[0],0,[0],[['a',0,0]]
-    @dfa2 = RLSM::DFA.new( ['a', 'b'], [0,1,2], 0, [2],
-                           [['a',0,0], ['a',1,2], ['a',2,2],
-                            ['b',0,1], ['b',1,1], ['b',2,2]])
-    @dfa3 = RLSM::DFA.new( ['a', 'b'], [0,1,2], 0, [2],
-                           [['a',0,0], ['a',1,2], ['a',2,2],
-                            ['b',0,1], ['b',1,1]])
-
-    @dfa4 = RLSM::DFA.new( ['a', 'b'], [0,1,2,3,4], 0, [2,3],
-                           [['a',0,0], ['a',1,2], ['a',2,2],
-                            ['b',0,1], ['b',1,1], 
-                            ['a',3,4], ['a',4,3], ['b',3,2]])
-
-    @dfa5 = RLSM::DFA.new( ['a', 'b'], [0,1,2], 0, [1],
-                           [['a',0,0], ['a',1,2], ['a',2,2],
-                            ['b',0,1], ['b',1,1]])
-
-    @dfa5b = RLSM::DFA.new( ['a', 'b'], [0,1,'c'], 0, [1],
-                           [['a',0,0], ['a',1,'c'], ['a','c','c'],
-                            ['b',0,1], ['b',1,1]])
-  end
-
-  it "should have an initial state" do
-    @dfa.initial_state.should_not be_nil
-    @dfa.initial_state.label.should == '0'
-    @dfa2.initial_state.should_not be_nil
-    @dfa2.initial_state.label.should == '0'
-  end
-
-  it "should know the number of states" do
-    @dfa.num_states.should == 1
-    @dfa2.num_states.should == 3
-  end
-
-  it "should know the number of final states" do
-    @dfa.num_finals.should == 1
-    @dfa2.num_finals.should == 1
-  end
-
-  it "should know if it is complete" do
-    @dfa.complete?.should == true
-    @dfa2.complete?.should == true
-    @dfa3.complete?.should == false
-  end
-
-  it "should complete a non complete DFA if requested" do
-    @dfa3.complete.should be_complete
-  end
-
-  it "should find dead states" do
-    [@dfa,@dfa2,@dfa3].each { |d| d.dead_states?.should == false }
-
-    @dfa5.dead_states?.should == true
-    @dfa5.dead_states.map { |s| s.label }.should == ['2']
-  end
-
-  it "should find unreachable states" do
-    [@dfa,@dfa2,@dfa3].each { |d| d.unreachable_states?.should == false }
-
-    @dfa4.unreachable_states?.should == true
-    @dfa4.unreachable_states.size.should == 2
-    @dfa4.unreachable_states.map { |s| s.label }.sort.should == ['3','4']
-  end
-
-  it "should remove dead states" do
-    @dfa5.remove_dead_states.states.map { |s| s.label }.should == ['0','1']
-  end
-
-  it "should remove unreachable states" do
-    d = @dfa4.remove_unreachable_states
-    d.states.map { |s| s.label }.sort.should == ['0','1','2']
-  end
-
-  it "should minimize a DFA" do
-    d = RLSM::DFA.new(['a','b','c'], [0,1,2,3,4], 0, [4],
-                  [['a',0,1], ['b',0,2], ['c',1,3], ['c',2,3], ['c',3,4]])
-
-    d.minimize!
-    d.states.map { |s| s.label }.sort.should == ['0','12', '3','4']
-  end
-
-  it "should check for isomorphisms" do
-    @dfa2.should be_isomorph_to(@dfa2)
-    @dfa5.should be_isomorph_to(@dfa5b)
-    @dfa3.should_not be_isomorph_to(@dfa2)
-  end
-
-  it "should calculate the transition monoid" do
-    @dfa.transition_monoid.should == RLSM::Monoid.new('0')
-  end
-  
-  it "should caclulate a RegExp representation" do
-    @dfa.to_regexp.to_s.should == 'a*'
-  end
-end

data/test/monoid_spec.rb

@@ -1,270 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'lib', 'rlsm', 'monoid')
-
-describe RLSM::Monoid, "basic stuff" do
-  before :each do
-    @m1 = RLSM::Monoid.new '0'
-    @m2 = RLSM::Monoid.new '00 01' #-> 01 11
-    @m3 = RLSM::Monoid.new '012 112 212'
-  end
-
-  it "should have '0' as the neutral element" do
-    @m1[0,0].should == 0
-    
-    [0,1].each { |x| @m2[0,x].should == x; @m2[x,0].should == x } 
-    [0,1,2].each { |x| @m3[0,x].should == x; @m3[x,0].should == x } 
-  end
-
-  it "should decide if an other monoid is isomorphic" do
-    @m2.should == RLSM::Monoid.new('01 11')
-    @m3.should == RLSM::Monoid.new('002 012 022')
-
-    @m2.should_not == @m3
-
-    @m2.should_not == RLSM::Monoid.new('01 10')
-  end
-  
-end
-
-describe RLSM::Monoid do
-  before :each do
-    @m0 = RLSM::Monoid.new '0'
-    @m1 = RLSM::Monoid.new '01 11'
-    @m2 = RLSM::Monoid.new '0123 1032 2323 3232'
-  end
-
-  [[],[0],[1], [2], [1,2], [1,3], [2,3], [1,2,3]].each do |set|
-    @m0 = RLSM::Monoid.new '0'
-    @m1 = RLSM::Monoid.new '01 11'
-    @m2 = RLSM::Monoid.new '0123 1032 2323 3232'
-
-    case set
-    when [], [0]
-      [@m0, @m1, @m2].each do |m|
-        it "should calculate the submonoid of #{m} generated by #{set}" do
-          sm = m.get_submonoid(set)
-          sm.should_not be_nil
-          sm.should == RLSM::Monoid.new('0')
-        end
-      end
-    when [1]
-      it "should calculate the submonoid of #{@m1} generated by #{set}" do
-        @m1.get_submonoid(set).should == @m1
-      end
-
-      it "should calculate the submonoid of #{@m2} generated by #{set}" do
-        @m2.get_submonoid(set).should == RLSM::Monoid.new('01 10')
-      end
-    when [2]
-      it "should calculate the submonoid of #{@m2} generated by #{set}" do
-        @m2.get_submonoid(set).should == @m1
-      end
-    when [1,2]
-      it "should calculate the submonoid of #{@m2} generated by #{set}" do
-        @m2.get_submonoid(set).should == @m2
-      end
-    when [1,3]
-      it "should calculate the submonoid of #{@m2} generated by #{set}" do
-        @m2.get_submonoid(set).should == @m2
-      end
-    when [2,3]
-      it "should calculate the submonoid of #{@m2} generated by #{set}" do
-        @m2.get_submonoid(set).should == RLSM::Monoid.new('012 112 221')
-      end
-    when [1,2,3]
-      it "should calculate the submonoid of #{@m2} generated by #{set}" do
-        @m2.get_submonoid(set).should == @m2
-      end
-    end
-  end
-
-  it "should calculate the generator subset of #{RLSM::Monoid.new('0')}" do
-    RLSM::Monoid.new('0').generating_subset.should == []
-  end
-
-  it "should calculate the generator subset of #{RLSM::Monoid.new('01 11')}" do
-    RLSM::Monoid.new('01 11').generating_subset.should == [1]
-  end
-
-  it "should calculate the generator subset of #{RLSM::Monoid.new('0123 1032 2323 3232')}" do
-    RLSM::Monoid.new('0123 1032 2323 3232').generating_subset.should == [1,2]
-  end
-end
-
-
-describe RLSM::Monoid do
-  before :each do
-    @m1 = RLSM::Monoid.new '012345 113315 245255 315355 442245 555555'
-    @m2 = RLSM::Monoid.new '012345 103254 235454 324545 455454 544545'
-  end
-
-  it "should calculate left ideals of elements" do
-    @m1.left_ideal_of(0).should == [0,1,2,3,4,5]
-    @m1.left_ideal_of(1).should == [1,4,5]
-    @m1.left_ideal_of(2).should == [2,3,5]
-    @m1.left_ideal_of(3).should == [2,3,5]
-    @m1.left_ideal_of(4).should == [1,4,5]
-    @m1.left_ideal_of(5).should == [5]
-  end
-
-  it "should calculate right ideals of elements" do
-    @m1.right_ideal_of(0).should == [0,1,2,3,4,5]
-    @m1.right_ideal_of(1).should == [1,3,5]
-    @m1.right_ideal_of(2).should == [2,4,5]
-    @m1.right_ideal_of(3).should == [1,3,5]
-    @m1.right_ideal_of(4).should == [2,4,5]
-    @m1.right_ideal_of(5).should == [5]
-  end
-
-  it "should calculate ideals of elements" do
-    @m1.ideal_of(0).should == [0,1,2,3,4,5]
-    @m1.ideal_of(1).should == [1,2,3,4,5]
-    @m1.ideal_of(2).should == [1,2,3,4,5]
-    @m1.ideal_of(3).should == [1,2,3,4,5]
-    @m1.ideal_of(4).should == [1,2,3,4,5]
-    @m1.ideal_of(5).should == [5]
-  end
-
-  it "should calculate L-classes of elements" do
-    @m1.l_class_of(0).should == [0]
-    @m1.l_class_of(1).should == [1,4]
-    @m1.l_class_of(2).should == [2,3]
-    @m1.l_class_of(3).should == [2,3]
-    @m1.l_class_of(4).should == [1,4]
-    @m1.l_class_of(5).should == [5]
-  end
-
-  it "should calculate R-classes of elements" do
-    @m1.r_class_of(0).should == [0]
-    @m1.r_class_of(1).should == [1,3]
-    @m1.r_class_of(2).should == [2,4]
-    @m1.r_class_of(3).should == [1,3]
-    @m1.r_class_of(4).should == [2,4]
-    @m1.r_class_of(5).should == [5]
-  end
-
-#  it "should calculate J-classes of elements" do
-#    @m1.j_class_of(0).should == [0]
-#    @m1.j_class_of(1).should == [1,2,3,4]
-#    @m1.j_class_of(2).should == [1,2,3,4]
-#    @m1.j_class_of(3).should == [1,2,3,4]
-#    @m1.j_class_of(4).should == [1,2,3,4]
-#    @m1.j_class_of(5).should == [5]
-#  end
-
-  it "should calculate H-classes of elements" do
-    @m1.h_class_of(0).should == [0]
-    @m1.h_class_of(1).should == [1]
-    @m1.h_class_of(2).should == [2]
-    @m1.h_class_of(3).should == [3]
-    @m1.h_class_of(4).should == [4]
-    @m1.h_class_of(5).should == [5]
-  end
-
-  it "should calculate D-classes of elements" do
-    @m1.d_class_of(0).should == [0]
-    @m1.d_class_of(1).should == [1,2,3,4]
-    @m1.d_class_of(2).should == [1,2,3,4]
-    @m1.d_class_of(3).should == [1,2,3,4]
-    @m1.d_class_of(4).should == [1,2,3,4]
-    @m1.d_class_of(5).should == [5]
-  end
-
-  it "should detect aperiodicity" do 
-    @m1.aperiodic?.should == true
-    @m2.aperiodic?.should == false
-  end
-end
-
-describe RLSM::Monoid do
-  before :each do
-    @m1 = RLSM::Monoid.new '0'
-    @m2 = RLSM::Monoid.new '01 10'
-    @m3 = RLSM::Monoid.new '01 11'
-    @m4 = RLSM::Monoid.new '012 102 222'
-  end
-
-  it "should detect a null element" do
-    @m1.null_element.should == false
-    @m2.null_element.should == false
-    @m3.null_element.should == 1
-    @m4.null_element.should == 2
-  end
-
-  it "should detect idempotent elements" do
-    [@m1, @m2, @m3].each { |m| m.idempotent?(0).should == true }
-    @m2.idempotent?(1).should == false
-    @m3.idempotent?(1).should == true
-    @m4.idempotent?(2).should == true
-    @m4.idempotent?(1).should == false
-  end
-
-  it "should find all idempotents" do
-    @m1.idempotents.should == [0]
-    @m2.idempotents.should == [0]
-    @m3.idempotents.should == [0,1]
-    @m4.idempotents.should == [0,2]
-  end
-
-  it "should decide if all elements are idempotent" do
-    @m1.idempotent?.should == true
-    @m2.idempotent?.should == false
-    @m3.idempotent?.should == true
-    @m4.idempotent?.should == false
-  end
-end
-
-describe RLSM::Monoid do
-  before :each do
-    @m1 = RLSM::Monoid.new('0123 1032 2323 3232')
-  end
-
-  it "should calculate all submonoids of a given order upto to isomorphie" do
-    @m1.submonoids_of_order(1).should == [RLSM::Monoid.new('0')]
-    @m1.submonoids_of_order(2).should == [RLSM::Monoid.new('01 10'), RLSM::Monoid.new('01 11')]
-    @m1.submonoids_of_order(3).should == [RLSM::Monoid.new('012 112 221')]
-    @m1.submonoids_of_order(4).should == [@m1]
-  end
-
-  it "should calculate all submonoids upto to isomorphie" do
-    @m1.submonoids.should == [RLSM::Monoid.new('0'), RLSM::Monoid.new('01 10'), RLSM::Monoid.new('01 11'),RLSM::Monoid.new('012 112 221'), @m1]
-
-    RLSM::Monoid.new('0').submonoids.should == [RLSM::Monoid.new('0')]
-  end
-
-  it "should calculate all proper submonoids upto to isomorphie" do
-    @m1.proper_submonoids.should == [RLSM::Monoid.new('01 10'), RLSM::Monoid.new('01 11'),RLSM::Monoid.new('012 112 221')]
-
-    RLSM::Monoid.new('0').proper_submonoids.should == []
-  end
-end
-
-describe RLSM::Monoid do
-  ['0', '01 11', '012 112 212', '01234 11111 21212 31133 41234'].each do |tab|
-    it "should detect syntacticity of #{tab}" do
-      RLSM::Monoid.new(tab).syntactic?.should == true
-    end
-
-    it "should find a disjunctive subset of #{tab}" do
-      case tab
-      when '0' 
-        RLSM::Monoid.new(tab).disjunctive_subset.should == []
-      when '01 11'
-        RLSM::Monoid.new(tab).disjunctive_subset.should == [0]
-      when '012 112 212'
-        RLSM::Monoid.new(tab).disjunctive_subset.should == [1]
-      when '01234 11111 21212 31133 41234'
-        RLSM::Monoid.new(tab).disjunctive_subset.should == [0,4]
-      end
-    end
-  end
-
-  ['0123 1111 2222 3333', '01234 10234 22222 33222 44222'].each do |tab|
-    it "should detect nonsyntacticity of #{tab}" do
-      RLSM::Monoid.new(tab).syntactic?.should == false
-    end
-
-    it "should not find a disjunctive subset of #{tab}" do
-      RLSM::Monoid.new(tab).disjunctive_subset.should be_nil
-    end
-  end
-end