art-decomp 0.1.0 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/bin/ad-fsm-info

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative '../lib/art-decomp'
+
+$stdout.sync = true
+
+ARGV.each do |fsm_file|
+  fsm = ArtDecomp::FSM.from_kiss fsm_file
+  puts "#{fsm_file}: #{fsm.stats}"
+
+  f_seps = fsm.beta_f.seps
+  i_seps = Hash[(0...fsm.input_count).map { |i| [i, fsm.beta_x(Set[i]).seps & f_seps] }]
+  i_seps['Q'] = fsm.beta_q.seps & f_seps
+  o_seps = Hash[(0...fsm.output_count).map { |o| [o, fsm.beta_y(Set[o]).seps] }]
+  o_seps['Q’'] = fsm.beta_qp.seps
+
+  u_i_seps = i_seps.map { |i, seps| seps.reject { |s| i_seps.any? { |o, os| o != i and o != 'Q' and os.include? s } } }
+
+  puts "relevant separation counts: #{i_seps.values.map &:size}"
+  puts "unique relevant sep counts: #{u_i_seps.map &:size}"
+  puts "relevant separation counts by input: #{i_seps.values.map(&:size).each.with_index.sort.reverse.map &:last}"
+  puts "unique relevant sep counts by input: #{u_i_seps.map(&:size).each.with_index.sort.reverse.map &:last}"
+  puts "relevant state separations per pin: #{i_seps['Q'].size.to_f   / fsm.beta_q.pins}"
+  puts "unique relevant state seps per pin: #{u_i_seps.last.size.to_f / fsm.beta_q.pins}"
+  puts "unnecessary inputs: #{i_seps.select { |i, sep| sep.empty? }.keys.sort}"
+
+  i_seps.pairs.each do |(a, sep_a), (b, sep_b)|
+    next if sep_a.empty? or sep_b.empty?
+    puts "input inclusion: #{a} ⊂ #{b}" if sep_a.proper_subset?   sep_b
+    puts "input inclusion: #{a} = #{b}" if sep_a ==               sep_b
+    puts "input inclusion: #{a} ⊃ #{b}" if sep_a.proper_superset? sep_b
+  end
+
+  o_seps.each do |o, o_sep|
+    required = Set[]
+    o_sep.each do |separation|
+      required << i_seps.select { |i, s| s.include? separation }.keys.to_set
+    end
+    required.delete_if do |this|
+      required.any? { |other| this != other and this.superset? other }
+    end
+    puts "sufficient for o#{o}: #{required.map(&:to_a)}"
+  end
+
+  puts
+
+end

data/lib/art-decomp.rb

@@ -61,5 +61,7 @@ require_relative 'art-decomp/qv_generator/bipainting'
 require_relative 'art-decomp/qv_generator/graph_colouring'
 require_relative 'art-decomp/qv_generator/graph_merging'
 require_relative 'art-decomp/sep'
+require_relative 'art-decomp/uv_relevance_generator'
 require_relative 'art-decomp/uv_generator/braindead'
-require_relative 'art-decomp/uv_generator/relevance'
+require_relative 'art-decomp/uv_generator/general_relevance'
+require_relative 'art-decomp/uv_generator/unique_relevance'

data/lib/art-decomp/decomposer.rb

@@ -2,7 +2,8 @@ module ArtDecomp class Decomposer
 
   def initialize params
     @archs   = params[:archs]
-    @uv_gens = params[:uv_gens].map { |gen| gen.new params[:fsm], params[:archs] }
+    @fsm     = params[:fsm]
+    @uv_gens = params[:uv_gens].map &:new
     @qu_gens = params[:qu_gens].map &:new
     @qv_gens = params[:qv_gens].map &:new
   end
@@ -11,7 +12,7 @@ module ArtDecomp class Decomposer
     @seen = Set[]
     Enumerator.new do |yielder|
       @uv_gens.each do |uv_gen|
-        uv_gen.uv_pairs.each do |fsm, u, v|
+        uv_gen.uv_pairs(@fsm, @archs).each do |fsm, u, v|
           unless @seen.include? [fsm, u, v]
             @qu_gens.each do |qu_gen|
               qu_gen.blankets(fsm, u, v).each do |qu|

data/lib/art-decomp/executable.rb

@@ -9,7 +9,7 @@ module ArtDecomp class Executable
       opt :archs,        'Target architecture(s)',               :type => :strings
       opt :outdir,       'Output directory',                     :type => :string
       opt :iters,        'Number of iterations, 0 for infinite', :default => 1
-      opt :uv,           'UV generator(s)',                      :default => ['Relevance']
+      opt :uv,           'UV generator(s)',                      :default => ['GeneralRelevance']
       opt :qu,           'Qu generator(s)',                      :default => ['EdgeLabels']
       opt :qv,           'Qv generator(s)',                      :default => ['GraphColouring']
       opt :binary,       'Compute binary decompositions',        :default => false

data/lib/art-decomp/fsm.rb

@@ -41,9 +41,16 @@ module ArtDecomp class FSM
     Blanket.from_array @state
   end
 
+  def beta_qp
+    Blanket.from_array @next_state
+  end
+
   def beta_x ins
-    return Blanket[B[*0...@state.size]] if ins.empty?
-    ins.map { |i| Blanket.from_array @inputs[i] }.inject :*
+    beta @inputs, ins
+  end
+
+  def beta_y ins
+    beta @outputs, ins
   end
 
   alias eql? ==
@@ -58,26 +65,22 @@ module ArtDecomp class FSM
     Arch[input_count + beta_q.pins, output_count + beta_q.pins].cells archs
   end
 
+  def general_relevance
+    relevance false
+  end
+
   def hash
     @inputs.hash ^ @outputs.hash ^ @state.hash ^ @next_state.hash
   end
 
   def implementable_in? archs
-    return true if @outputs.map { |output| Blanket.from_array output }.inject(:*).size < 2
-    input_count + beta_q.pins <= archs.map(&:pins).max
+    not fsm_cells(archs).nil?
   end
 
   def input_count
     @inputs.size
   end
 
-  def input_relevance
-    seps = beta_f.seps
-    perpin = (beta_q.seps & seps).size.to_f / beta_q.pins
-    more, less = (0...input_count).map { |i| [(beta_x(Set[i]).seps & seps).size, i] }.sort.reverse.reject { |rel, i| rel.zero? }.partition { |rel, i| rel > perpin }
-    more.map(&:last) + [nil] * beta_q.pins + less.map(&:last)
-  end
-
   def q_encoding rows
     # FIXME: consider tr DontCare, '*'
     encoding @state, rows
@@ -109,6 +112,10 @@ module ArtDecomp class FSM
     @state.all? { |s| s == DontCare } and @next_state.all? { |ns| ns == DontCare }
   end
 
+  def unique_relevance
+    relevance true
+  end
+
   def x_encoding ins, rows
     ins.map { |i| encoding @inputs[i], rows }.join
   end
@@ -123,6 +130,11 @@ module ArtDecomp class FSM
 
   private
 
+  def beta column, ins
+    return Blanket[B[*0...@state.size]] if ins.empty?
+    ins.map { |i| Blanket.from_array column[i] }.inject :*
+  end
+
   def encoding column, rows
     encs = rows.bits.map { |row| column[row] }.uniq - [DontCare]
     case encs.size
@@ -132,4 +144,15 @@ module ArtDecomp class FSM
     end
   end
 
+  def relevance unique
+    f_seps = beta_f.seps
+    i_seps = Hash[(0...input_count).map { |i| [i, beta_x(Set[i]).seps & f_seps] }]
+    q_seps = beta_q.seps & f_seps
+    q_seps -= i_seps.values.inject :+ if unique
+    perpin = q_seps.size.to_f / beta_q.pins
+    i_seps = Hash[i_seps.map { |i, seps| [i, seps - i_seps.reject { |o,| o == i }.values.inject(Set[], :+)] }] if unique
+    more, less = i_seps.map { |i, seps| [seps.size, i] }.sort.reverse.reject { |rel,| rel.zero? }.partition { |rel,| rel > perpin }
+    more.map(&:last) + [nil] * beta_q.pins + less.map(&:last)
+  end
+
 end end

data/lib/art-decomp/graph.rb

@@ -5,12 +5,10 @@ module ArtDecomp class Graph
   def initialize blanket, seps
     @vertices = blanket.ints.dup
     @vertices.delete_if { |this| @vertices.any? { |other| other != this and other & this == this } }
-    @edges    = Set[]
-    seps.each do |sep|
-      @vertices.pairs.each do |a, b|
-        @edges << Set[a,b] unless (a & sep).zero? or (b & sep).zero? or (a | b) & sep != sep
-      end
-    end
+    relevant = Hash[@vertices.map { |v| [v, seps.select { |s| v&s != 0 and v&s != s }.to_set] }]
+    @edges = @vertices.pairs.select do |a, b|
+      (relevant[a] & relevant[b]).any? { |s| a&s != b&s }
+    end.map(&:to_set).to_set
   end
 
   def adjacent *vertices

data/lib/art-decomp/logging.rb

@@ -19,6 +19,7 @@ module ArtDecomp class Logging < Gazer::Aspect::Base
     @@log.formatter = proc { |sev, date, name, msg| "#{date} #{msg}\n" }
     @@indent = ''
     apply!
+    @@start = Time.now
   end
 
   def self.off
@@ -27,14 +28,15 @@ module ArtDecomp class Logging < Gazer::Aspect::Base
   end
 
   after instances_of(Executable) => :run do |point|
-    @@log.info "final best decomposition: #{point.object.best} cells"
+    secs = (Time.now - @@start).to_i
+    @@log.info "#{point.object.best ? "final best decomposition: #{point.object.best} cells" : 'no final decomposition'}; done in #{secs}s (#{secs / 60 / 60}h #{secs / 60 % 60}m #{secs % 60}s)"
   end
 
   before instances_of(Executable) => :decompositions do |point|
     @@indent = '  ' * (point.object.iters - point.args[1])
     path     = point.args[2][point.object.dir.size+1..-1]
     archs    = point.object.archs.map(&:to_s).sort.reverse.join '+'
-    @@log.info "#{@@indent}FSM #{point.args[0].stats} → #{archs} (#{path}) with #{point.object.gens} – best so far: #{point.object.best} cells"
+    @@log.info "#{@@indent}FSM #{point.args[0].stats} → #{archs} (#{path}) with #{point.object.gens} – #{point.object.best ? "best so far: #{point.object.best} cells" : 'no decomposition so far'}"
   end
 
   before instances_of(UVGenerator.constants.map { |c| eval("UVGenerator::#{c}") }) => :uv_pairs do |point|

data/lib/art-decomp/qu_generator/block_table.rb

@@ -1,11 +1,11 @@
 module ArtDecomp class QuGenerator::BlockTable
 
   def blankets fsm, u, v
+    @seps   = fsm.beta_f.seps
+    @rows   = fsm.beta_q.ints.dup
+    @cols   = fsm.beta_x(u).ints
+    @r_adms = {}
     Enumerator.new do |yielder|
-      @seps   = fsm.beta_f.seps
-      @rows   = fsm.beta_q.ints.dup
-      @cols   = fsm.beta_x(u).ints
-      @r_adms = {}
       fold_matching!
       yielder.yield Blanket.new @rows
       while @rows.size > 1

data/lib/art-decomp/qu_generator/edge_labels.rb

@@ -1,9 +1,9 @@
 module ArtDecomp class QuGenerator::EdgeLabels
 
   def blankets fsm, u, v
+    seps   = fsm.beta_f.seps - fsm.beta_x(u).seps
+    @graph = Graph.new fsm.beta_q, seps
     Enumerator.new do |yielder|
-      seps = fsm.beta_f.seps - fsm.beta_x(u).seps
-      @graph = Graph.new fsm.beta_q, seps
       initial_merge
       yielder.yield Blanket.new @graph.vertices
       while @graph.vertices.size > 1

data/lib/art-decomp/qv_generator/bipainting.rb

@@ -1,10 +1,10 @@
 module ArtDecomp class QvGenerator::Bipainting
 
   def blankets fsm, u, v, beta_qu
+    beta_u    = fsm.beta_x u
+    beta_v    = fsm.beta_x v
+    bipainter = Bipainter.new fsm.beta_q, beta_v, fsm.beta_f.seps - beta_u.seps - beta_qu.seps
     Enumerator.new do |yielder|
-      beta_u = fsm.beta_x u
-      beta_v = fsm.beta_x v
-      bipainter = Bipainter.new fsm.beta_q, beta_v, fsm.beta_f.seps - beta_u.seps - beta_qu.seps
       yielder.yield bipainter.blankets
     end
   end

data/lib/art-decomp/qv_generator/graph_colouring.rb

@@ -1,9 +1,9 @@
 module ArtDecomp class QvGenerator::GraphColouring
 
   def blankets fsm, u, v, beta_qu
+    beta_u = fsm.beta_x u
+    beta_v = fsm.beta_x v
     Enumerator.new do |yielder|
-      beta_u  = fsm.beta_x u
-      beta_v  = fsm.beta_x v
       beta_g  = Graph.new(fsm.beta_q * beta_v, fsm.beta_f.seps - beta_u.seps - beta_qu.seps).blanket_from_colouring
       beta_qv = Graph.new(fsm.beta_q, beta_g.seps - beta_v.seps).blanket_from_colouring
       yielder.yield beta_qv, beta_g

data/lib/art-decomp/qv_generator/graph_merging.rb

@@ -1,10 +1,10 @@
 module ArtDecomp class QvGenerator::GraphMerging
 
   def blankets fsm, u, v, beta_qu
+    beta_u   = fsm.beta_x u
+    beta_v   = fsm.beta_x v
+    qv_graph = Graph.new fsm.beta_q, fsm.beta_f.seps - beta_u.seps - beta_qu.seps - beta_v.seps
     Enumerator.new do |yielder|
-      beta_u = fsm.beta_x u
-      beta_v = fsm.beta_x v
-      qv_graph = Graph.new fsm.beta_q, fsm.beta_f.seps - beta_u.seps - beta_qu.seps - beta_v.seps
       loop do
         beta_qv = Blanket.new qv_graph.vertices
         g_graph = Graph.new beta_qv * beta_v, fsm.beta_f.seps - beta_u.seps - beta_qu.seps

data/lib/art-decomp/uv_generator/braindead.rb

@@ -1,20 +1,16 @@
 module ArtDecomp class UVGenerator::Braindead
 
-  def initialize fsm, archs
-    @fsm         = fsm
-    @input_count = fsm.input_count
-    @max_v_size  = archs.map(&:pins).max
-  end
-
-  def uv_pairs
+  def uv_pairs fsm, archs
+    input_count = fsm.input_count
+    inputs      = (0...input_count).to_a
+    max_v_size  = archs.map(&:pins).max
     Enumerator.new do |yielder|
-      inputs = (0...@input_count).to_a
-      (0...2**@input_count).each do |vector|
+      (0...2**input_count).each do |vector|
         u, v = Set[], Set[]
-        @input_count.times do |bit|
+        input_count.times do |bit|
           (vector[bit].zero? ? u : v) << inputs[bit]
         end
-        yielder.yield @fsm.expand_x(v), u, v if v.size <= @max_v_size
+        yielder.yield fsm.expand_x(v), u, v if v.size <= max_v_size
       end
     end
   end

data/lib/art-decomp/uv_generator/general_relevance.rb

@@ -0,0 +1,7 @@
+module ArtDecomp class UVGenerator::GeneralRelevance < UVRelevanceGenerator
+
+  def uv_pairs fsm, archs
+    super fsm, archs, :general_relevance
+  end
+
+end end

data/lib/art-decomp/uv_generator/unique_relevance.rb

@@ -0,0 +1,7 @@
+module ArtDecomp class UVGenerator::UniqueRelevance < UVRelevanceGenerator
+
+  def uv_pairs fsm, archs
+    super fsm, archs, :unique_relevance
+  end
+
+end end

data/lib/art-decomp/uv_relevance_generator.rb

@@ -0,0 +1,19 @@
+module ArtDecomp class UVRelevanceGenerator
+
+  def uv_pairs fsm, archs, method
+    relevance   = fsm.send(method).reverse
+    max_v_sizes = archs.map(&:pins).to_set
+    cache       = Set[]
+    Enumerator.new do |yielder|
+      (0...2**relevance.size).each do |vector|
+        bits = vector.bits
+        next unless max_v_sizes.include? bits.size
+        v = relevance.values_at(*bits).compact.to_set
+        u = (relevance - v.to_a).compact.to_set
+        yielder.yield fsm.expand_x(v), u, v unless cache.include? v
+        cache << v
+      end
+    end
+  end
+
+end end

data/spec/art-decomp/decomposer_spec.rb

@@ -6,8 +6,7 @@ module ArtDecomp describe Decomposer do
     uv1, uv2 = mock('UVGenerator class'), mock('UVGenerator class')
     qu1, qu2 = mock('QuGenerator class'), mock('QuGenerator class')
     qv1, qv2 = mock('QvGenerator class'), mock('QvGenerator class')
-    [uv1, uv2].each           { |gen| gen.should_receive(:new).with fsm, archs }
-    [qu1, qu2, qv1, qv2].each { |gen| gen.should_receive(:new).with no_args }
+    [uv1, uv2, qu1, qu2, qv1, qv2].each { |gen| gen.should_receive(:new).with no_args }
     Decomposer.new :fsm => fsm, :archs => archs, :uv_gens => [uv1, uv2], :qu_gens => [qu1, qu2], :qv_gens => [qv1, qv2]
   end
 
@@ -26,6 +25,7 @@ module ArtDecomp describe Decomposer do
 
     it 'should poll the generators and yield the resulting decompositions one by one' do
       fsm = mock FSM, :beta_q => mock(Blanket, :pins => 3, :size => 5), :input_count => 4
+      archs = Set[Arch[5,1]]
 
       u_a, v_a = Set[0,1], Set[2] # for this U/V pair: two Qu generating one Qv/G pair each
       qu_a1, qv_a1, g_a1 = mock(Blanket, :pins => 2, :size => 4), mock(Blanket, :pins => 3, :size => 5), mock(Blanket, :pins => 2)
@@ -36,14 +36,14 @@ module ArtDecomp describe Decomposer do
       qv_bA, g_bA = mock(Blanket, :pins => 3, :size => 5), mock(Blanket, :pins => 2)
       qv_bB, g_bB = mock(Blanket, :pins => 3, :size => 5), mock(Blanket, :pins => 2)
 
-      uv_gen = mock UVGenerator, :new => StubGenerator.new({[] => [[fsm, u_a, v_a], [fsm, u_b, v_b]]})
+      uv_gen = mock UVGenerator, :new => StubGenerator.new({[fsm, archs] => [[fsm, u_a, v_a], [fsm, u_b, v_b]]})
       qu_gen = mock QuGenerator, :new => StubGenerator.new({[fsm, u_a, v_a] => [qu_a1, qu_a2],
                                                             [fsm, u_b, v_b] => [qu_b]})
       qv_gen = mock QvGenerator, :new => StubGenerator.new({[fsm, u_a, v_a, qu_a1] => [[qv_a1, g_a1]],
                                                             [fsm, u_a, v_a, qu_a2] => [[qv_a2, g_a2]],
                                                             [fsm, u_b, v_b, qu_b]  => [[qv_bA, g_bA], [qv_bB, g_bB]]})
 
-      decomposer = Decomposer.new :archs => Set[Arch[5,1]], :fsm => fsm, :uv_gens => [uv_gen], :qu_gens => [qu_gen], :qv_gens => [qv_gen]
+      decomposer = Decomposer.new :archs => archs, :fsm => fsm, :uv_gens => [uv_gen], :qu_gens => [qu_gen], :qv_gens => [qv_gen]
       results = decomposer.decompositions.to_a
       results.size.should  == 4
       results.first.should == Decomposition.new(fsm, u_a, v_a, qu_a1, qv_a1, g_a1)

data/spec/art-decomp/executable_spec.rb

@@ -3,7 +3,6 @@
 module ArtDecomp describe Executable do
 
   before do
-    @orig_stderr = $stderr
     $stderr = StringIO.new
     @fsm = 'spec/fixtures/fsm'
     @dir = "#{Dir.tmpdir}/#{rand.to_s}"
@@ -11,7 +10,7 @@ module ArtDecomp describe Executable do
   end
 
   after do
-    $stderr = @orig_stderr
+    $stderr = STDERR
     FileUtils.rmtree @dir if Dir.exists? @dir
   end
 
@@ -84,7 +83,7 @@ module ArtDecomp describe Executable do
     dec = Decomposition.new fsm, Set[0], Set[1], Blanket[B[0],B[1],B[2]], Blanket[], Blanket[]
 
     decomposer = mock Decomposer, :decompositions => [dec, dec].each
-    Decomposer.should_receive(:new).with(:fsm => fsm, :archs => an_instance_of(Set), :uv_gens => [UVGenerator::Relevance], :qu_gens => [QuGenerator::EdgeLabels], :qv_gens => [QvGenerator::GraphColouring]).and_return decomposer
+    Decomposer.should_receive(:new).with(:fsm => fsm, :archs => an_instance_of(Set), :uv_gens => [UVGenerator::GeneralRelevance], :qu_gens => [QuGenerator::EdgeLabels], :qv_gens => [QvGenerator::GraphColouring]).and_return decomposer
 
     Executable.new(@args).run false
     Marshal.load(File.read("#{@dir}/decompositions")).should == [dec, dec]
@@ -120,7 +119,7 @@ module ArtDecomp describe Executable do
     FSM.should_receive(:from_kiss).with(@fsm).and_return fsm
 
     decomposer = mock Decomposer, :decompositions => [].each
-    Decomposer.should_receive(:new).with(:fsm => fsm, :archs => Set[Arch[5,1]], :uv_gens => [UVGenerator::Braindead, UVGenerator::Relevance], :qu_gens => [QuGenerator::BlockTable, QuGenerator::EdgeLabels], :qv_gens => [QvGenerator::Bipainting, QvGenerator::GraphColouring,QvGenerator::GraphMerging]).and_return decomposer
+    Decomposer.should_receive(:new).with(:fsm => fsm, :archs => Set[Arch[5,1]], :uv_gens => [UVGenerator::Braindead, UVGenerator::GeneralRelevance, UVGenerator::UniqueRelevance], :qu_gens => [QuGenerator::BlockTable, QuGenerator::EdgeLabels], :qv_gens => [QvGenerator::Bipainting, QvGenerator::GraphColouring,QvGenerator::GraphMerging]).and_return decomposer
 
     args = ['--archs', '5/1', '--uv', 'all', '--qu', 'all', '--qv', 'all', '--outdir', @dir, @fsm]
     Executable.new(args).run

data/spec/art-decomp/fsm_spec.rb

@@ -47,6 +47,12 @@ module ArtDecomp describe FSM do
       @mc.beta_q.should   == Blanket[B[0,1,2], B[3,4], B[5,6,7], B[8,9]]
     end
 
+    it 'should properly generate the Q’ Blanket' do
+      @opus.beta_qp.should == Blanket[B[0,1], B[2,3,9], B[4,14], B[5,6], B[7,8,20,21], B[10,16], B[11,18], B[12,15], B[13,17], B[19]]
+      @lion.beta_qp.should == Blanket[B[0,1,4], B[2,3,7], B[5,6,10], B[8,9]]
+      @mc.beta_qp.should   == Blanket[B[0,1,9], B[2,3], B[4,5], B[6,7,8]]
+    end
+
     it 'should properly generate the F Blanket' do
       @opus.beta_f.should == Blanket[B[0,1], B[2,3,9], B[4,14], B[5,6], B[7,8,20,21], B[10,16], B[11,18], B[12,15], B[13,17], B[19]]
       @lion.beta_f.should == Blanket[B[0,1,4], B[2], B[2,3,7], B[5,6,10], B[8,9]]
@@ -59,6 +65,12 @@ module ArtDecomp describe FSM do
       @mc.beta_x(Set[]).should    == Blanket[B[0,1,2,3,4,5,6,7,8,9]]
     end
 
+    it 'should properly generate selected output Blankets' do
+      @mc.beta_y(Set[4]).should   == Blanket[B[0,1,2,3,4,5,6,7], B[8,9]]
+      @mc.beta_y(Set[2,3]).should == Blanket[B[0,1,2], B[3,4], B[5,6,7,8,9]]
+      @mc.beta_y(Set[]).should    == Blanket[B[0,1,2,3,4,5,6,7,8,9]]
+    end
+
     it 'should properly generate its KISS representation' do
       @opus.to_kiss.should == File.read('spec/fixtures/opus.to_kiss')
       @lion.to_kiss.should == File.read('spec/fixtures/lion.to_kiss')
@@ -139,15 +151,26 @@ module ArtDecomp describe FSM do
       @s8.fsm_cells(Set[Arch[4,1]]).should   == 0
     end
 
-    it 'should report its input relevance, and drop irrelevant inputs' do
-      @ex4.input_relevance.should   == [nil, nil, nil, nil, 2, 1, 5, 4, 3]
-      @fsm.input_relevance.should   == [2, 1, 3, 0, nil, nil, nil, nil]
-      @lion.input_relevance.should  == [0, nil, nil, 1]
-      @mark1.input_relevance.should == [nil, nil, nil, nil, 0, 3, 2, 4, 1]
-      @mc.input_relevance.should    == [nil, nil, 2, 1, 0]
-      @opus.input_relevance.should  == [nil, nil, nil, nil, 2, 3, 4, 0, 1]
-      @s8.input_relevance.should    == [3, 2, 1, 0, nil, nil, nil]
-      @tt.input_relevance.should    == [1, 3, 2]
+    it 'should report its general input relevance, and drop irrelevant inputs' do
+      @ex4.general_relevance.should   == [nil, nil, nil, nil, 2, 1, 5, 4, 3]
+      @fsm.general_relevance.should   == [2, 1, 3, 0, nil, nil, nil, nil]
+      @lion.general_relevance.should  == [0, nil, nil, 1]
+      @mark1.general_relevance.should == [nil, nil, nil, nil, 0, 3, 2, 4, 1]
+      @mc.general_relevance.should    == [nil, nil, 2, 1, 0]
+      @opus.general_relevance.should  == [nil, nil, nil, nil, 2, 3, 4, 0, 1]
+      @s8.general_relevance.should    == [3, 2, 1, 0, nil, nil, nil]
+      @tt.general_relevance.should    == [1, 3, 2]
+    end
+
+    it 'should report its unique input relevance, and drop irrelevant inputs' do
+      @ex4.unique_relevance.should   == [nil, nil, nil, nil, 2, 1, 5, 4, 3]
+      @fsm.unique_relevance.should   == [2, 1, 0, 3, nil, nil, nil, nil]
+      @lion.unique_relevance.should  == [0, nil, nil, 1]
+      @mark1.unique_relevance.should == [nil, nil, nil, nil, 0, 3, 2, 4, 1]
+      @mc.unique_relevance.should    == [nil, nil, 2, 1, 0]
+      @opus.unique_relevance.should  == [2, nil, nil, nil, nil, 3, 4, 1, 0]
+      @s8.unique_relevance.should    == [nil, nil, nil]
+      @tt.unique_relevance.should    == [1, 3, 2]
     end
 
     it 'should report whether it’s a truth table or a full-blown FSM' do

data/spec/art-decomp/graph_spec.rb

@@ -66,4 +66,9 @@ module ArtDecomp describe Graph do
     @graph.adjacent(B[5,6], B[7]).should == Set[B[3,4], B[8,9]]
   end
 
+  it 'should only create the necessary edges' do
+    blanket = Blanket[B[1,2,3], B[1,2,4], B[1,5], B[2,6]]
+    Graph.new(blanket, Set[Sep[1,2]]).edges.should == Set[Set[B[1,5], B[2,6]]]
+  end
+
 end end

data/spec/art-decomp/logging_spec.rb

@@ -6,6 +6,7 @@ module ArtDecomp describe Logging do
 
   before do
     @dir = "#{Dir.tmpdir}/#{rand.to_s}"
+    @fsm = mock FSM, :beta_f => Blanket[], :beta_q => Blanket[], :beta_x => Blanket[]
     @log = StringIO.new
     Logging.log = @log
   end
@@ -23,27 +24,37 @@ module ArtDecomp describe Logging do
   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')
+    log.should =~ rex('final best decomposition: 2 cells; done in 0s (0h 0m 0s)')
   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']
+    ex = Executable.new(args)
+    ex.stub!(:best).and_return 69
+    ex.run
+    log.should =~ rex('FSM 4/2+10s → 5/1+4/2 () with GeneralRelevance, EdgeLabels, GraphColouring – best so far: 69 cells')
+    log.should =~ rex('final best decomposition: 69 cells; done in 0s (0h 0m 0s)')
+  end
+
+  it 'should log Executable’s decompositions calls on problematic 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: ')
+    log.should =~ rex('FSM 4/2+10s → 5/1+4/2 () with GeneralRelevance, EdgeLabels, GraphColouring – no decomposition so far')
+    log.should =~ rex('no final decomposition; done in 0s (0h 0m 0s)')
   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
+    uv = UVGenerator::Braindead.new
+    uv.uv_pairs mock(FSM, :input_count => 2), Set[Arch[5,1]]
     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
+      qu.blankets @fsm, u, v
     end
     log.should =~ rex('U = [0], V = [1], Qu with BlockTable')
     log.should =~ rex('U = [1], V = [0], Qu with BlockTable')
@@ -53,7 +64,7 @@ module ArtDecomp describe Logging 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
+      qv.blankets @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')

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

@@ -6,8 +6,8 @@ module ArtDecomp describe UVGenerator::Braindead 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
+      uv_gen = UVGenerator::Braindead.new
+      uvs = uv_gen.uv_pairs(fsm, archs).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]]
@@ -19,8 +19,8 @@ module ArtDecomp describe UVGenerator::Braindead do
       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 == [
+      uv_gen = UVGenerator::Braindead.new
+      uv_gen.uv_pairs(fsm, archs).to_a.should == [
         [fsm0, Set[0,1], Set[]],
         [fsm1, Set[1],   Set[0]],
         [fsm2, Set[0],   Set[1]],

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

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module ArtDecomp describe UVGenerator::GeneralRelevance do
+
+  it 'should call UVRelevanceGenerator’s uv_pairs method with proper args' do
+    fsm = mock FSM
+    fsm.should_receive(:general_relevance).and_return []
+    UVGenerator::GeneralRelevance.new.uv_pairs fsm, Set[Arch[5,1]]
+  end
+
+end end

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

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module ArtDecomp describe UVGenerator::UniqueRelevance do
+
+  it 'should call UVRelevanceGenerator’s uv_pairs method with proper args' do
+    fsm = mock FSM
+    fsm.should_receive(:unique_relevance).and_return []
+    UVGenerator::UniqueRelevance.new.uv_pairs fsm, Set[Arch[5,1]]
+  end
+
+end end

data/spec/art-decomp/{uv_generator/relevance_spec.rb → uv_relevance_generator_spec.rb}

@@ -1,13 +1,13 @@
-module ArtDecomp describe UVGenerator::Relevance do
+module ArtDecomp describe UVRelevanceGenerator 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 = mock FSM, :input_count => 6, :common_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
+      uv_gen = UVRelevanceGenerator.new
+      uvs = uv_gen.uv_pairs(fsm, archs, :common_relevance).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]]
@@ -22,11 +22,11 @@ module ArtDecomp describe UVGenerator::Relevance do
     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 = mock FSM, :input_count => 6, :common_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
+      uv_gen = UVRelevanceGenerator.new
+      uvs = uv_gen.uv_pairs(fsm, archs, :common_relevance).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]]
@@ -43,12 +43,12 @@ module ArtDecomp describe UVGenerator::Relevance do
     end
 
     it 'should yield V-expanded FSMs' do
-      fsm = mock FSM, :input_count => 2, :input_relevance => [1, 0, nil, nil, nil]
+      fsm = mock FSM, :input_count => 2, :common_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 == [
+      uv_gen = UVRelevanceGenerator.new
+      uv_gen.uv_pairs(fsm, archs, :common_relevance).to_a.should == [
         [fsm0, Set[0,1], Set[]],
         [fsm1, Set[1],   Set[0]],
         [fsm2, Set[0],   Set[1]],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: art-decomp
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Piotr Szotkowski
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-05 00:00:00 +01:00
+date: 2009-12-13 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -77,8 +77,7 @@ email: p.szotkowski@tele.pw.edu.pl
 executables: 
 - ad-validate
 - ad-console
-- ad-analyse
-- ad-inputs
+- ad-fsm-info
 - art-decomp
 extensions: []
 
@@ -90,9 +89,8 @@ files:
 - README
 - Rakefile
 - VERSION
-- bin/ad-analyse
 - bin/ad-console
-- bin/ad-inputs
+- bin/ad-fsm-info
 - bin/ad-validate
 - bin/art-decomp
 - lib/art-decomp.rb
@@ -115,7 +113,9 @@ files:
 - lib/art-decomp/qv_generator/graph_merging.rb
 - lib/art-decomp/sep.rb
 - lib/art-decomp/uv_generator/braindead.rb
-- lib/art-decomp/uv_generator/relevance.rb
+- lib/art-decomp/uv_generator/general_relevance.rb
+- lib/art-decomp/uv_generator/unique_relevance.rb
+- lib/art-decomp/uv_relevance_generator.rb
 - lib/core/enumerable.rb
 - lib/core/file.rb
 - lib/core/integer.rb
@@ -139,7 +139,9 @@ files:
 - spec/art-decomp/qv_generator/graph_merging_spec.rb
 - spec/art-decomp/sep_spec.rb
 - spec/art-decomp/uv_generator/braindead_spec.rb
-- spec/art-decomp/uv_generator/relevance_spec.rb
+- spec/art-decomp/uv_generator/general_relevance_spec.rb
+- spec/art-decomp/uv_generator/unique_relevance_spec.rb
+- spec/art-decomp/uv_relevance_generator_spec.rb
 - spec/core/enumerable_spec.rb
 - spec/core/file_spec.rb
 - spec/core/integer_spec.rb
@@ -209,6 +211,7 @@ test_files:
 - spec/art-decomp/fsm_spec.rb
 - spec/art-decomp/sep_spec.rb
 - spec/art-decomp/bipainter_spec.rb
+- spec/art-decomp/uv_relevance_generator_spec.rb
 - spec/art-decomp/blanket_spec.rb
 - spec/art-decomp/kiss_spec.rb
 - spec/art-decomp/qv_generator/graph_colouring_spec.rb
@@ -218,7 +221,8 @@ test_files:
 - spec/art-decomp/decomposer_spec.rb
 - spec/art-decomp/qu_generator/edge_labels_spec.rb
 - spec/art-decomp/qu_generator/block_table_spec.rb
-- spec/art-decomp/uv_generator/relevance_spec.rb
+- spec/art-decomp/uv_generator/general_relevance_spec.rb
+- spec/art-decomp/uv_generator/unique_relevance_spec.rb
 - spec/art-decomp/uv_generator/braindead_spec.rb
 - spec/art-decomp/decomposition_spec.rb
 - spec/art-decomp/b_spec.rb

data/bin/ad-analyse

@@ -1,30 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require 'rubygems'      if RUBY_VERSION < '1.9'
-require 'backports/1.9' if RUBY_VERSION < '1.9'
-
-require_relative '../lib/art-decomp'
-
-input_limit = ARGV.first.to_i.zero? ? 0 : ARGV.shift.to_i
-
-$stdout.sync = true
-
-ARGV.each do |fsm_file|
-  fsm = ArtDecomp::FSM.from_kiss fsm_file
-  seps = fsm.beta_f.seps
-  input_seps = (0...fsm.input_count).map { |i| fsm.beta_x(Set[i]).seps & seps }
-
-  puts
-  puts fsm_file
-  puts "X seps: #{input_seps.map(&:size).inspect}"
-
-  input_seps.each_with_index { |a, i| puts "#{i} insignificant" if a.empty? }
-
-  (0...input_seps.size).pairs.to_a.each do |a, b|
-    next if input_seps[a].empty? or input_seps[b].empty?
-    puts "#{a} ⊂ #{b}" if input_seps[a].proper_subset?   input_seps[b]
-    puts "#{a} = #{b}" if input_seps[a] ==               input_seps[b]
-    puts "#{a} ⊃ #{b}" if input_seps[a].proper_superset? input_seps[b]
-  end
-end

data/bin/ad-inputs

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require 'rubygems'      if RUBY_VERSION < '1.9'
-require 'backports/1.9' if RUBY_VERSION < '1.9'
-
-require_relative '../lib/art-decomp'
-
-input_limit = ARGV.first.to_i.zero? ? 0 : ARGV.shift.to_i
-
-$stdout.sync = true
-
-ARGV.each do |fsm_file|
-  fsm = ArtDecomp::FSM.from_kiss fsm_file
-  next if fsm.input_count < input_limit
-  seps = fsm.beta_f.seps
-  rel_q = (fsm.beta_q.seps & seps).size
-  puts
-  puts fsm_file
-  puts "inputs: #{fsm.input_count}"
-  puts "βf sep: #{seps.size}"
-  puts "βq sep: #{rel_q}"
-  puts "βq.pin: #{fsm.beta_q.pins}"
-  puts "perpin: #{rel_q.to_f / fsm.beta_q.pins}"
-  puts "X seps: #{(0...fsm.input_count).map { |i| (fsm.beta_x(Set[i]).seps & seps).size }.sort.reverse.inspect}"
-end

data/lib/art-decomp/uv_generator/relevance.rb

@@ -1,23 +0,0 @@
-module ArtDecomp class UVGenerator::Relevance
-
-  def initialize fsm, archs
-    @fsm         = fsm
-    @relevance   = fsm.input_relevance.reverse
-    @max_v_sizes = archs.map(&:pins).to_set
-  end
-
-  def uv_pairs
-    @cache = Set[]
-    Enumerator.new do |yielder|
-      (0...2**@relevance.size).each do |vector|
-        bits = vector.bits
-        next unless @max_v_sizes.include? bits.size
-        v = @relevance.values_at(*bits).compact.to_set
-        u = (@relevance - v.to_a).compact.to_set
-        yielder.yield @fsm.expand_x(v), u, v unless @cache.include? v
-        @cache << v
-      end
-    end
-  end
-
-end end