art-decomp 0.0.0

data/spec/art-decomp/graph_spec.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+
+module ArtDecomp describe Graph do
+
+  before do
+    blanket = Blanket[B[1,2], B[3,4], B[5,6], B[7], B[8,9]]
+    seps    = Set[Sep[4,6], Sep[5,9], Sep[5,7], Sep[7,9]]
+    @graph  = Graph.new blanket, seps
+  end
+
+  it 'should initialise properly from a Blanket and a Set of Seps' do
+    @graph.vertices.should == Set[B[1,2], B[3,4], B[5,6], B[7], B[8,9]]
+    @graph.edges.should    == Set[Set[B[3,4], B[5,6]], Set[B[5,6], B[7]], Set[B[8,9], B[7]], Set[B[5,6], B[8,9]]]
+  end
+
+  it 'should drop vertices covered by other vertices upon initialisation' do
+    Graph.new(Blanket[B[1,2], B[2]], Set[]).vertices.should == Set[B[1,2]]
+  end
+
+  it 'should properly compute vertex degrees' do
+    degrees = {B[1,2] => 0, B[3,4] => 1, B[5,6] => 3, B[7] => 2, B[8,9] => 2}
+    degrees.each { |vert, deg| @graph.degree(vert).should == deg }
+  end
+
+  it 'should return the proper Blanket obtained by colouring the vertices' do
+    blanket = @graph.blanket_from_colouring
+    blanket.size.should == 3
+    blanket.ints.should include(B[1,2,5,6])
+  end
+
+  it 'should report whether it’s complete' do
+    complete = Graph.new Blanket[B[1], B[2], B[3]], Set[Sep[1,2], Sep[1,3], Sep[2,3]]
+    complete.should   be_complete
+    @graph.should_not be_complete
+  end
+
+  it 'should properly merge until it’s complete and return self' do
+    @graph.merge_until_complete!.should be_a(Graph)
+    @graph.vertices.size.should == 3
+    @graph.vertices.should include(B[1,2,5,6])
+    @graph.should be_complete
+  end
+
+  it 'should properly merge based on edge weights and return self' do
+    b1234 = Blanket[B[1], B[2], B[3], B[4]]
+    graph = Graph.new b1234, b1234.seps
+    graph.merge_by_edge_labels! { |a, b| a | b }.should be_a(Graph)
+    graph.vertices.should == Set[B[1,2,3], B[4]]
+    graph.merge_by_edge_labels! { |a, b| a | b }.should be_a(Graph)
+    graph.vertices.should == Set[B[1,2,3,4]]
+    graph.merge_by_edge_labels! { |a, b| a | b }.should be_a(Graph)
+    graph.vertices.should == Set[B[1,2,3,4]]
+  end
+
+  it 'should properly merge based on vertex degrees and return self' do
+    graph = Graph.new Blanket[B[1], B[2], B[3], B[4], B[5], B[6]], Set[Sep[3,4], Sep[4,5], Sep[4,6], Sep[5,6]]
+    graph.merge_by_vertex_degrees!.should be_a(Graph)
+    graph.vertices.should == Set[B[1,2,4], B[3], B[5], B[6]]
+    graph.merge_by_vertex_degrees!.should be_a(Graph)
+    graph.vertices.size.should == 3
+  end
+
+  it 'should report a given vertex’s adjacent vertices' do
+    @graph.adjacent(B[3,4]).should == Set[B[5,6]]
+    @graph.adjacent(B[1,2]).should == Set[]
+    @graph.adjacent(B[5,6], B[7]).should == Set[B[3,4], B[8,9]]
+  end
+
+end end

data/spec/art-decomp/kiss_spec.rb

@@ -0,0 +1,30 @@
+module ArtDecomp describe KISS do
+
+  it 'should sort entries' do
+    kiss = KISS.new ['1 1', '0 0']
+    kiss.formatted.should == "0 0\n1 1\n"
+  end
+
+  it 'should drop non-unique entries' do
+    kiss = KISS.new ['0 0', '0 0']
+    kiss.formatted.should == "0 0\n"
+  end
+
+  it 'should drop overlapping entries' do
+    kiss = KISS.new ['0-0 0', '010 0', '1-1 1', '--1 1']
+    kiss.formatted.should == "--1 1\n0-0 0\n"
+  end
+
+  it 'should preserve overlapping entries which differ on subsequent column groups' do
+    kiss = KISS.new ['-- 1 0 1', '10 0 0 1']
+    kiss.formatted.should == "-- 1 0 1\n10 0 0 1\n"
+  end
+
+  it 'should combine matching entries' do
+    kiss = KISS.new ['00 0 1 1', '01 0 1 1', '10 1 0 0', '11 1 0 0']
+    kiss.formatted.should == "0- 0 1 1\n1- 1 0 0\n"
+    kiss = KISS.new ['00 0', '11 0', '10 0', '01 0']
+    kiss.formatted.should == "-- 0\n"
+  end
+
+end end

data/spec/art-decomp/logging_spec.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+
+require_relative '../../lib/art-decomp/logging'
+
+module ArtDecomp describe Logging do
+
+  before do
+    @dir = "#{Dir.tmpdir}/#{rand.to_s}"
+    @log = StringIO.new
+    Logging.log = @log
+  end
+
+  after do
+    Logging.off
+    FileUtils.rmtree @dir if Dir.exists? @dir
+  end
+
+  def log
+    @log.rewind
+    @log.read
+  end
+
+  it 'should log Executable’s decompositions calls on simple cases' do
+    args = ['-a', '5/1', '4/2', '-o', @dir, 'spec/fixtures/lion']
+    Executable.new(args).run
+    log.should =~ rex('final best decomposition: 2')
+  end
+
+  it 'should log Executable’s decompositions calls on typical cases' do
+    Decomposer.should_receive(:new).and_return mock(Decomposer, :decompositions => [].each)
+    args = ['-a', '5/1', '4/2', '-o', @dir, 'spec/fixtures/fsm']
+    Executable.new(args).run
+    log.should =~ rex('FSM 4/2+10s → 5/1+4/2 () with Relevance, EdgeLabels, GraphColouring – best so far: ')
+    log.should =~ rex('final best decomposition: ')
+  end
+
+  it 'should log UVGenerators’ uv_pairs calls' do
+    uv = UVGenerator::Braindead.new mock(FSM, :input_count => 2), Set[Arch[5,1]]
+    uv.uv_pairs
+    log.should =~ rex('UV with Braindead')
+  end
+
+  it 'should log QuGenerators’ blankets calls' do
+    qu = QuGenerator::BlockTable.new
+    [[Set[0], Set[1]], [Set[1], Set[0]]].each do |u, v|
+      qu.blankets mock(FSM), u, v
+    end
+    log.should =~ rex('U = [0], V = [1], Qu with BlockTable')
+    log.should =~ rex('U = [1], V = [0], Qu with BlockTable')
+  end
+
+  it 'should log QvGenerators’ blankets calls (on the DEBUG level)' do
+    Logging.level = Logger::DEBUG
+    qv = QvGenerator::GraphColouring.new
+    [mock(Blanket, :size => 8), mock(Blanket, :size => 4)].each do |qu|
+      qv.blankets mock(FSM), Set[0], Set[1], qu
+    end
+    log.should =~ rex('|Qu| = 8, Qv+G with GraphColouring')
+    log.should =~ rex('|Qu| = 4, Qv+G with GraphColouring')
+  end
+
+end end

data/spec/art-decomp/qu_generator/block_table_spec.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module ArtDecomp describe QuGenerator::BlockTable do
+
+  context 'when generating Qu blankets' do
+
+    def qus
+      fsm   = mock FSM, :beta_f => @beta_f, :beta_q => @beta_q, :beta_x => @beta_x
+      archs = Set[Arch[3,1]]
+      bt    = QuGenerator::BlockTable.new
+      bt.blankets(fsm, Set[0], Set[1]).to_a
+    end
+
+    it 'should fold Q blocks that match in the first go' do
+      @beta_f = Blanket[]
+      @beta_q = Blanket[B[1,2], B[2], B[3]]
+      @beta_x = Blanket[B[1], B[2], B[3]]
+      qus.first.should == Blanket[B[1,2,3], B[2]]
+    end
+
+    it 'shouldn’t fold Q blocks if they don’t match' do
+      @beta_f = Blanket[]
+      @beta_q = Blanket[B[1,2], B[2,3]]
+      @beta_x = Blanket[B[1], B[2], B[3]]
+      qus.first.should == Blanket[B[1,2], B[2,3]]
+    end
+
+    it 'should first try to fold matching blocks and then fold by r-admissibility' do
+      @beta_f = mock Blanket, :seps => Set[Sep[1,2], Sep[2,3]]
+      @beta_q = Blanket[B[1], B[2], B[3]]
+      @beta_x = Blanket[B[1,2,3], B[1,3]]
+      qus.should == [Blanket[B[1], B[2], B[3]], Blanket[B[1,3], B[2]], Blanket[B[1,2,3]]]
+    end
+
+  end
+
+end end

data/spec/art-decomp/qu_generator/edge_labels_spec.rb

@@ -0,0 +1,35 @@
+module ArtDecomp describe QuGenerator::EdgeLabels do
+
+  context 'when generating Qu blankets' do
+
+    def qus
+      fsm   = mock FSM, :beta_f => @beta_f, :beta_q => @beta_q, :beta_x => @beta_x
+      archs = Set[Arch[3,1]]
+      el    = QuGenerator::EdgeLabels.new
+      el.blankets(fsm, Set[0], Set[1]).to_a
+    end
+
+    it 'should fist merge until its graph is complete' do
+      @beta_f = mock Blanket, :seps => Set[Sep[1,2], Sep[2,3]]
+      @beta_q = Blanket[B[1], B[2], B[3]]
+      @beta_x = Blanket[]
+      qus.first.should == Blanket[B[1,3], B[2]]
+    end
+
+    it 'should then merge blocks based on r-admissibility of the merged block, all the way down' do
+      @beta_f = Blanket[B[1], B[2,3], B[4], B[5], B[6]]
+      @beta_q = Blanket[B[1], B[2,3], B[4,5,6]]
+      @beta_x = Blanket[]
+      qus.should == [Blanket[B[1], B[2,3], B[4,5,6]], Blanket[B[1,2,3], B[4,5,6]], Blanket[B[1,2,3,4,5,6]]]
+    end
+
+    it 'should merge blocks based on the number of separations lost (if the r-admissibility is the same)' do
+      @beta_f = Blanket[B[1,2], B[3,4,5], B[6]]
+      @beta_q = Blanket[B[1,2], B[3,4,5], B[6]]
+      @beta_x = Blanket[]
+      qus.should == [Blanket[B[1,2], B[3,4,5], B[6]], Blanket[B[1,2,6], B[3,4,5]], Blanket[B[1,2,3,4,5,6]]]
+    end
+
+  end
+
+end end

data/spec/art-decomp/qv_generator/bipainting_spec.rb

@@ -0,0 +1,28 @@
+module ArtDecomp describe QvGenerator::Bipainting do
+
+  context 'when generating G and Qv blankets' do
+
+    it 'should use graph bicolouring' do
+      beta_f  = mock Blanket, :seps => Set[Sep[1,2], Sep[1,3], Sep[1,6], Sep[2,6], Sep[3,4], Sep[3,6], Sep[4,5], Sep[5,6]]
+      beta_q  = Blanket[B[1,2], B[3,4], B[5,6]]
+      beta_u  = Blanket[]
+      beta_v  = Blanket[B[1,3,5], B[2,4,6]]
+      beta_qu = Blanket[]
+
+      fsm = mock FSM, :beta_f => beta_f, :beta_q => beta_q
+      fsm.should_receive(:beta_x).with(Set[0]).and_return beta_u
+      fsm.should_receive(:beta_x).with(Set[1]).and_return beta_v
+      archs = Set[Arch[3,1]]
+      bi = QvGenerator::Bipainting.new
+
+      beta_qv, beta_g = bi.blankets(fsm, Set[0], Set[1], beta_qu).to_a.first
+      beta_qv.should == Blanket[B[1,2], B[3,4,5,6]]
+      beta_g.should  == Blanket[B[1], B[2,3,5], B[4,6]]
+
+      beta_f.seps.should be_subset(beta_u.seps + beta_qu.seps + beta_g.seps)
+      beta_g.seps.should be_subset(beta_v.seps + beta_qv.seps)
+    end
+
+  end
+
+end end

data/spec/art-decomp/qv_generator/graph_colouring_spec.rb

@@ -0,0 +1,31 @@
+module ArtDecomp describe QvGenerator::GraphColouring do
+
+  context 'when generating G and Qv blankets' do
+
+    it 'should use graph colouring of the proper incompatibility graphs' do
+      beta_f  = mock Blanket, :seps => Set[Sep[1,2], Sep[1,3], Sep[1,6], Sep[2,6], Sep[3,4], Sep[3,6], Sep[4,5], Sep[5,6]]
+      beta_q  = Blanket[B[1,2], B[3,4], B[5,6]]
+      beta_u  = Blanket[]
+      beta_v  = Blanket[B[1,3,5], B[2,4,6]]
+      beta_qu = Blanket[]
+
+      fsm = mock FSM, :beta_f => beta_f, :beta_q => beta_q
+      fsm.should_receive(:beta_x).with(Set[0]).and_return beta_u
+      fsm.should_receive(:beta_x).with(Set[1]).and_return beta_v
+      archs = Set[Arch[3,1]]
+      gc = QvGenerator::GraphColouring.new
+
+      pairs = gc.blankets(fsm, Set[0], Set[1], beta_qu).to_a
+      pairs.size.should  == 2
+      pairs.first.should == [Blanket[B[1,2], B[3,4], B[5,6]], Blanket[B[1,5], B[2,3], B[4,6]]]
+      pairs.last.should  == [Blanket[B[1,2], B[3,4,5,6]], Blanket[B[1], B[2,3,5], B[4,6]]]
+
+      pairs.each do |beta_qv, beta_g|
+        beta_f.seps.should be_subset(beta_u.seps + beta_qu.seps + beta_g.seps)
+        beta_g.seps.should be_subset(beta_v.seps + beta_qv.seps)
+      end
+    end
+
+  end
+
+end end

data/spec/art-decomp/qv_generator/graph_merging_spec.rb

@@ -0,0 +1,30 @@
+module ArtDecomp describe QvGenerator::GraphMerging do
+
+  context 'when generating G and Qv blankets' do
+
+    it 'should merge vertices of the proper incompatibility graphs' do
+      beta_f  = mock Blanket, :seps => Set[Sep[1,2], Sep[1,3], Sep[1,6], Sep[2,6], Sep[3,4], Sep[3,6], Sep[4,5], Sep[5,6]]
+      beta_q  = Blanket[B[1,2], B[3,4], B[5,6]]
+      beta_u  = Blanket[]
+      beta_v  = Blanket[B[1,3,5], B[2,4,6]]
+      beta_qu = Blanket[]
+
+      fsm = mock FSM, :beta_f => beta_f, :beta_q => beta_q
+      fsm.should_receive(:beta_x).with(Set[0]).and_return beta_u
+      fsm.should_receive(:beta_x).with(Set[1]).and_return beta_v
+      archs = Set[Arch[3,1]]
+      gm = QvGenerator::GraphMerging.new
+
+      pairs = gm.blankets(fsm, Set[0], Set[1], beta_qu).to_a
+      pairs.first.should == [Blanket[B[1,2], B[3,4], B[5,6]], Blanket[B[1,5], B[2,3], B[4,6]]]
+      pairs.last.should  == [Blanket[B[1,2], B[3,4,5,6]],     Blanket[B[1], B[2,3,5], B[4,6]]]
+
+      pairs.each do |beta_qv, beta_g|
+        beta_f.seps.should be_subset(beta_u.seps + beta_qu.seps + beta_g.seps)
+        beta_g.seps.should be_subset(beta_v.seps + beta_qv.seps)
+      end
+    end
+
+  end
+
+end end

data/spec/art-decomp/sep_spec.rb

@@ -0,0 +1,13 @@
+module ArtDecomp describe Sep do
+
+  it 'should be an Integer with bits representing the separated values' do
+    Sep[1,2].should  == 0b110
+    Sep[0,69].should == 2**69 + 0b1
+  end
+
+  it 'should be usable as a Set element' do
+    Sep[1,2].hash.should  == 0b110.hash
+    Sep[0,69].hash.should == (2**69 + 0b1).hash
+  end
+
+end end

data/spec/art-decomp/uv_generator/braindead_spec.rb

@@ -0,0 +1,33 @@
+module ArtDecomp describe UVGenerator::Braindead do
+
+  context 'given a certain FSM and a Set of Archs' do
+
+    it 'should yield all non-insane U and V combinations' do
+      fsm = mock FSM, :input_count => 4
+      fsm.stub!(:expand_x).and_return fsm
+      archs = Set[Arch[3,1]]
+      uv_gen = UVGenerator::Braindead.new fsm, archs
+      uvs = uv_gen.uv_pairs.to_a
+      uvs.size.should  == 15
+      uvs.first.should == [fsm, Set[0,1,2,3], Set[]]
+      uvs[7].should    == [fsm, Set[3], Set[0,1,2]]
+      uvs.last.should  == [fsm, Set[0], Set[1,2,3]]
+    end
+
+    it 'should yield V-expanded FSMs' do
+      fsm = mock FSM, :input_count => 2
+      fsm0, fsm1, fsm2, fsm3 = mock(FSM), mock(FSM), mock(FSM), mock(FSM)
+      fsm.should_receive(:expand_x).exactly(4).times.and_return(fsm0, fsm1, fsm2, fsm3)
+      archs = Set[Arch[3,1]]
+      uv_gen = UVGenerator::Braindead.new fsm, archs
+      uv_gen.uv_pairs.to_a.should == [
+        [fsm0, Set[0,1], Set[]],
+        [fsm1, Set[1],   Set[0]],
+        [fsm2, Set[0],   Set[1]],
+        [fsm3, Set[],    Set[0,1]],
+      ]
+    end
+
+  end
+
+end end

data/spec/art-decomp/uv_generator/relevance_spec.rb

@@ -0,0 +1,61 @@
+module ArtDecomp describe UVGenerator::Relevance do
+
+  context 'given a certain FSM and a Set of Archs' do
+
+    it 'should yield U and V combinations in a relevance-based order' do
+      fsm = mock FSM, :input_count => 6, :input_relevance => [0, 1, 2, nil, nil, nil, 3, 4, 5]
+      fsm.stub!(:expand_x).and_return fsm
+      archs = Set[Arch[3,1]]
+      uv_gen = UVGenerator::Relevance.new fsm, archs
+      uvs = uv_gen.uv_pairs.to_a
+      uvs.size.should == 42
+      uvs[0].should   == [fsm, Set[0,1,2], Set[3,4,5]]
+      uvs[1].should   == [fsm, Set[0,1,2,3], Set[4,5]]
+      uvs[2].should   == [fsm, Set[0,1,2,4], Set[3,5]]
+      uvs[3].should   == [fsm, Set[0,1,2,5], Set[3,4]]
+      uvs[4].should   == [fsm, Set[0,1,2,3,4], Set[5]]
+      uvs[5].should   == [fsm, Set[0,1,2,3,5], Set[4]]
+      uvs[6].should   == [fsm, Set[0,1,2,4,5], Set[3]]
+      uvs[7].should   == [fsm, Set[0,1,2,3,4,5], Set[]]
+      uvs[8].should   == [fsm, Set[0,1,3], Set[2,4,5]]
+      uvs.last.should == [fsm, Set[3,4,5], Set[0,1,2]]
+    end
+
+    it 'should consider all architecture widths when generating the UV sets' do
+      fsm = mock FSM, :input_count => 6, :input_relevance => [0, 1, 2, nil, nil, nil, 3, 4, 5]
+      fsm.stub!(:expand_x).and_return fsm
+      archs = Set[Arch[3,1], Arch[2,1]]
+      uv_gen = UVGenerator::Relevance.new fsm, archs
+      uvs = uv_gen.uv_pairs.to_a
+      uvs.size.should == 42
+      uvs[0].should   == [fsm, Set[0,1,2,3], Set[4,5]]
+      uvs[1].should   == [fsm, Set[0,1,2,4], Set[3,5]]
+      uvs[2].should   == [fsm, Set[0,1,2,5], Set[3,4]]
+      uvs[3].should   == [fsm, Set[0,1,2], Set[3,4,5]]
+      uvs[4].should   == [fsm, Set[0,1,2,3,4], Set[5]]
+      uvs[5].should   == [fsm, Set[0,1,2,3,5], Set[4]]
+      uvs[6].should   == [fsm, Set[0,1,2,4,5], Set[3]]
+      uvs[7].should   == [fsm, Set[0,1,2,3,4,5], Set[]]
+      uvs[8].should   == [fsm, Set[0,1,3,4], Set[2,5]]
+      uvs[9].should   == [fsm, Set[0,1,3,5], Set[2,4]]
+      uvs[10].should  == [fsm, Set[0,1,3], Set[2,4,5]]
+      uvs.last.should == [fsm, Set[3,4,5], Set[0,1,2]]
+    end
+
+    it 'should yield V-expanded FSMs' do
+      fsm = mock FSM, :input_count => 2, :input_relevance => [1, 0, nil, nil, nil]
+      fsm0, fsm1, fsm2, fsm3 = mock(FSM), mock(FSM), mock(FSM), mock(FSM)
+      fsm.should_receive(:expand_x).exactly(4).times.and_return(fsm0, fsm1, fsm2, fsm3)
+      archs = Set[Arch[3,1]]
+      uv_gen = UVGenerator::Relevance.new fsm, archs
+      uv_gen.uv_pairs.to_a.should == [
+        [fsm0, Set[0,1], Set[]],
+        [fsm1, Set[1],   Set[0]],
+        [fsm2, Set[0],   Set[1]],
+        [fsm3, Set[],    Set[0,1]],
+      ]
+    end
+
+  end
+
+end end

data/spec/core/enumerable_spec.rb

@@ -0,0 +1,20 @@
+describe Enumerable do
+
+  it 'should provide an Enumerator for consecutive element pairs' do
+    set = Set[1,2,3,4]
+    set.pairs.to_a.should == [[1,2], [1,3], [1,4], [2,3], [2,4], [3,4]]
+  end
+
+  it 'should fall back to #combination for the pair selection if possible' do
+    array = [1,2,3,4]
+    array.should_receive(:combination).with 2
+    array.pairs
+  end
+
+  it 'should have a method to get all possible combinations of the passed elements' do
+    source = [[:a,:b], [:c], [:d,:e,:f]]
+    Enumerable.all_combinations(source).should == [[:a,:c,:d], [:a,:c,:e], [:a,:c,:f],
+                                                   [:b,:c,:d], [:b,:c,:e], [:b,:c,:f]]
+  end
+
+end

data/spec/core/file_spec.rb

@@ -0,0 +1,15 @@
+describe File do
+
+  it 'should be able to marshal an object to a given file' do
+    file = Tempfile.new rand
+    File.dump_object [:answer, 42, 'Deep Thought'], file.path
+    Marshal.load(File.read(file.path)).should == [:answer, 42, 'Deep Thought']
+  end
+
+  it 'should be able to dump arbitrary data to a given file' do
+    file = Tempfile.new rand
+    File.write_data '42', file.path
+    File.read(file.path).should == '42'
+  end
+
+end

data/spec/core/integer_spec.rb

@@ -0,0 +1,16 @@
+describe Integer do
+
+  it 'should return set bits' do
+    0.bits.should        == []
+    0b111.bits.should    == [0,1,2]
+    0b1000.bits.should   == [3]
+    0b101010.bits.should == [1,3,5]
+    (2**69).bits.should  == [69]
+  end
+
+  it 'should return ceil of base-2 logarithm' do
+    (0..9).map(&:log2_ceil).should == [0,0,1,2,2,3,3,3,3,4]
+    (2**69).log2_ceil.should == 69
+  end
+
+end

data/spec/core/set_spec.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+describe Set do
+
+  it 'should side-step a MRI bug with Set#hash' do
+    Set[2305860601668175887].hash.should == Set[2305860601668175887].hash
+  end
+
+  context 'of Separations' do
+
+    B, Sep = ArtDecomp::B, ArtDecomp::Sep
+
+    it 'should provide a given block’s r-admissibility' do
+      b = B[1,2,3,4]
+      Set[Sep[1,5]].r_adm(b).should == 0
+      Set[Sep[1,4]].r_adm(b).should == 1
+      Set[Sep[1,2], Sep[5,6]].r_adm(b).should == 1
+      Set[Sep[1,2], Sep[3,4]].r_adm(b).should == 1
+      Set[Sep[1,3], Sep[1,4], Sep[2,3], Sep[2,4]].r_adm(b).should == 1
+      Set[Sep[1,3], Sep[1,4], Sep[2,3], Sep[2,4], Sep[3,4]].r_adm(b).should == 2
+      ArtDecomp::Blanket[B[1],B[2],B[3],B[4]].seps.r_adm(b).should == 2
+    end
+
+  end
+
+end

data/spec/core/string_spec.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+describe String do
+
+  it 'should provide an expansion of don’t-cares when representing boolean inputs' do
+    '0'.dc_expand.should   == ['0']
+    '-'.dc_expand.should   == ['0', '1']
+    '-1-'.dc_expand.should == ['010', '011', '110', '111']
+  end
+
+  it 'the expansion should be limitable to just a given set of columns' do
+    '---'.dc_expand.should == ['000', '001', '010', '011', '100', '101', '110', '111']
+    '---'.dc_expand(Set[0,2]).should == ['0-0', '0-1', '1-0', '1-1']
+    '---'.dc_expand(Set[1]).should   == ['-0-', '-1-']
+  end
+
+end

data/spec/fixtures/ex5

@@ -0,0 +1,36 @@
+.i 2
+.o 2
+.p 32
+.s 9
+00 1 0 --
+01 1 7 00
+10 1 5 11
+11 1 4 --
+00 2 1 --
+01 2 4 --
+10 2 0 --
+11 2 0 00
+00 3 3 --
+01 3 0 00
+10 3 0 --
+11 3 7 11
+00 4 5 00
+01 4 0 --
+10 4 1 --
+11 4 0 --
+00 5 0 11
+01 5 6 --
+10 5 0 11
+11 5 0 11
+00 6 0 11
+01 6 5 --
+10 6 1 11
+11 6 0 11
+00 7 6 --
+01 7 0 11
+10 7 2 --
+11 7 8 --
+00 8 3 --
+01 8 0 --
+10 8 1 00
+11 8 0 --

data/spec/fixtures/fsm

@@ -0,0 +1,24 @@
+.i 4
+.o 2
+.p 20
+.s 10
+--00 init0 init1 00
+0100 init1 init1 00
+--1- init1 init2 10
+1-10 init2 init4 10
+-111 init4 init4 10
+--01 init4 IOwait 01
+000- IOwait IOwait 01
+100- IOwait init1 01
+0110 IOwait read0 00
+1100 IOwait write0 11
+0111 IOwait RMACK 11
+1101 IOwait WMACK 00
+-01- IOwait init2 01
+0010 RMACK RMACK 11
+0111 RMACK read0 00
+1100 WMACK WMACK 00
+1001 WMACK write0 01
+0001 read0 read1 11
+0010 read1 IOwait 01
+0100 write0 IOwait 01

data/spec/fixtures/fsm.exp

@@ -0,0 +1,40 @@
+0000 IOwait IOwait 01
+0000 init0 init1 00
+0001 IOwait IOwait 01
+0001 init4 IOwait 01
+0001 read0 read1 11
+0010 IOwait init2 01
+0010 RMACK RMACK 11
+0010 init1 init2 10
+0010 read1 IOwait 01
+0011 IOwait init2 01
+0011 init1 init2 10
+0100 init0 init1 00
+0100 init1 init1 00
+0100 write0 IOwait 01
+0101 init4 IOwait 01
+0110 IOwait read0 00
+0110 init1 init2 10
+0111 IOwait RMACK 11
+0111 RMACK read0 00
+0111 init1 init2 10
+0111 init4 init4 10
+1000 IOwait init1 01
+1000 init0 init1 00
+1001 IOwait init1 01
+1001 WMACK write0 01
+1001 init4 IOwait 01
+1010 IOwait init2 01
+1010 init1 init2 10
+1010 init2 init4 10
+1011 IOwait init2 01
+1011 init1 init2 10
+1100 IOwait write0 11
+1100 WMACK WMACK 00
+1100 init0 init1 00
+1101 IOwait WMACK 00
+1101 init4 IOwait 01
+1110 init1 init2 10
+1110 init2 init4 10
+1111 init1 init2 10
+1111 init4 init4 10

data/spec/fixtures/fsm.f

@@ -0,0 +1,20 @@
+--00 init0 init1 00
+--01 init4 IOwait 01
+--1- init1 init2 10
+-01- IOwait init2 01
+-111 init4 init4 10
+000- IOwait IOwait 01
+0001 read0 read1 11
+0010 RMACK RMACK 11
+0010 read1 IOwait 01
+0100 init1 init1 00
+0100 write0 IOwait 01
+0110 IOwait read0 00
+0111 IOwait RMACK 11
+0111 RMACK read0 00
+1-10 init2 init4 10
+100- IOwait init1 01
+1001 WMACK write0 01
+1100 IOwait write0 11
+1100 WMACK WMACK 00
+1101 IOwait WMACK 00

data/spec/fixtures/fsm.g

@@ -0,0 +1,4 @@
+00 0
+01 1
+10 1
+11 0