rlsm 0.4.0 → 1.0.0

data/lib/smon/base.rb

@@ -0,0 +1,284 @@
+module SMONLIBbase
+  def quit
+    exit
+  end
+
+  def monoid(mon, options = {})
+    @objects << RLSM::Monoid.new(mon, options)
+    puts "=> #{@objects.last.inspect}" if @interactive
+    @monoid = @objects.last
+  end
+
+  def dfa(dfa)
+    @objects << RLSM::DFA.create(dfa)
+    puts "=> #{@objects.last.inspect}" if @interactive
+    @dfa = @objects.last
+  end
+
+  def regexp(re)
+    @objects << RLSM::RE.new(re)
+    puts "=> #{@objects.last.inspect}" if @interactive
+    @re = @objects.last
+  end
+
+  def show(obj = nil)
+    obj ||= @objects.last
+    if obj
+      @out.puts obj.to_s
+      @out.puts
+    else
+      STDERR.puts "No object present."
+    end
+  end
+
+  def describe(obj = nil)
+    obj ||= @objects.last
+
+    if obj
+      monoid, dfa = obj.to_monoid, obj.to_dfa
+      print_language(monoid, dfa)
+      print_monoid_properties(monoid)
+      print_submonoids(monoid)
+      print_syntactic_properties(monoid)
+    else
+      STDERR.puts "No object present."
+    end
+  end
+
+
+  def self.included(mod)
+    #Setting up the help system
+    mod.add_help :type => 'cmd',
+    :name => 'quit',
+    :usage => 'quit',
+    :summary => "Quits the program.",
+    :description => <<DESC
+The 'quit' command is a synonym for the 'exit' command.
+Only needed in interactive mode.
+DESC
+
+    mod.add_help :type => 'cmd',
+    :name => 'monoid',
+    :usage => "monoid '<mon>' [<options>]",
+    :summary => "Creates a new monoid.",
+    :description => <<DESC
+The <mon> parameter is a description of the binary operation
+of the monoid as a table. The <mon> parameter is parsed as follows:
+  * Rows are seperated by spaces.
+  * Elements in a row are seperated by commas (',').
+    Commas are optional if each element consists of a single letter.
+  * IMPORTANT: The first row and column belongs to the neutral element!
+  * IMPORTANT: The <mon> parameter must be enclosed
+    in single or double quotes.
+
+EXAMPLES:
+monoid '1ab aab bbb'
+monoid 'e,a1,a2 a1,a2,e a2,e,a1'
+
+The optional <options> parameter is a Hash and can take the following keys:
+ :elements  -> an array
+               The value of this key is used to rename
+               the elements of the monoid.
+ :normalize -> true|false
+               If true, the monoid will be normalized, i.e.
+               the generating elements will be moved to the beginning.
+ :rename    -> true|false
+               If true, the elements ill be renamed to 1 a b c ...
+
+Adds the  created monoid to the @objects array
+and sets the variable @monoid to the created monoid.
+DESC
+
+    mod.add_help :type => 'cmd',
+    :name => 'dfa',
+    :usage => "dfa <hash>",
+    :summary => "Creates a new DFA.",
+    :description => <<DESC
+The <hash> parameter must have the following keys:
+ :initial     -> label
+                 The label of the initial state.
+ :finals      -> an Array
+                 The array contains the labels of the final states.
+ :transitions -> an Array
+                 The array contains the transitions of the monoid.
+                 A transition is an array consisting of
+                  the label of the transition
+                  the starting state of the transition
+                  the destination of the transition
+
+EXAMPLE:
+dfa :initial => '0', :finals => ['1'], :transitions => [['a','0','1']]
+
+Adds the  created DFA to the @objects array
+and sets the variable @dfa to the created DFA.
+DESC
+
+    mod.add_help :type => 'cmd',
+    :name => 'regexp',
+    :usage => "regexp '<re>'",
+    :summary => "Creates a new Regular Expression.",
+    :description => <<DESC
+The <re> parameter is simply a regular expression. Special Symbols are
+ #{RLSM::RE::Lambda} -> the empty word
+ #{RLSM::RE::Star} -> the Kleene star
+ #{RLSM::RE::Union} -> the union of two regexps
+ #{RLSM::RE::LeftBracket}, #{RLSM::RE::RightBracket} -> Parenthesis to group a subregexp
+
+IMPORTANT: The <re> parameter must be enclosed in single or double quotes.
+           Parentheses must be balanced.
+
+EXAMPLES:
+regexp 'a'
+regexp
+'#{RLSM::RE::Lambda}#{RLSM::RE::Union}#{RLSM::RE::LeftBracket}a#{RLSM::RE::Union}aab#{RLSM::RE::Star}#{RLSM::RE::RightBracket}'
+
+Adds the  created regular expression to the @objects array
+and sets the variable @re to the created regular expression.
+DESC
+
+    mod.add_help :type => 'cmd',
+    :name => 'show',
+    :usage => "show [<obj>]",
+    :summary => "Prints a very concise description of <obj>.",
+    :description => <<DESC
+The optional <obj> parameter is either a monoid, a DFA or a RE.
+If none is given the last created object will be used.
+DESC
+
+    mod.add_help :type => 'cmd',
+    :name => 'describe',
+    :usage => "describe [<obj>]",
+    :summary => "Prints a verbose description of <obj>.",
+    :description => <<DESC
+The optional <obj> parameter is either a monoid, a DFA or a RE.
+If none is given the last created object will be used.
+DESC
+  end
+
+  private
+  def print_syntactic_properties(m)
+    if m.syntactic?
+      @out.puts "SYNTACTIC PROPERTIES:"
+
+      m.all_disjunctive_subsets.each do |ds|
+        @out.puts "{#{ds.join(',')}} => #{m.to_dfa(ds).to_re}"
+      end
+      @out.puts
+    end
+  end
+
+  def print_submonoids(m)
+    subs = m.proper_submonoids.map do |sm|
+      binary_operation(sm)
+    end
+
+    if subs.empty?
+      @out.puts "SUBMONOIDS: none"
+      @out.puts
+    else
+      @out.puts "SUBMONOIDS:"
+      rows = [[]]
+      width = 0
+      subs.each do |sm|
+        spl = sm.split("\n")
+        if (width + spl[0].length) <= 30
+          rows.last << spl
+          width += spl[0].length
+        else
+          rows << [spl]
+          width = spl[0].length
+        end
+      end
+      rows.each do |row|
+        max_lines = row.map { |sm| sm.size }.max
+
+        row.map! { |sm| sm + [' '*sm[0].length]*(max_lines-sm.size) }
+        (0...row[0].size).each do |i|
+          @out.puts row.map { |sm| sm[i] }.join('  ')
+        end
+        @out.puts
+      end
+    end
+  end
+
+  def print_monoid_properties(m)
+    block1 = []
+    block1 << "PROPERTIES OF THE MONOID:"
+    block1 << "   Generator: {#{m.generating_subset.join(',')}}"
+    block1 << "       Group: #{m.group?}"
+    block1 << " Commutative: #{m.commutative?}"
+    block1 << "  Idempotent: #{m.idempotent?}"
+    block1 << "   Syntactic: #{m.syntactic?}"
+    block1 << "   Aperiodic: #{m.aperiodic?}"
+    block1 << "   L-trivial: #{m.l_trivial?}"
+    block1 << "   R-trivial: #{m.r_trivial?}"
+    block1 << "   D-trivial: #{m.d_trivial?}"
+    block1 << "Zero element: #{!m.zero_element.nil?}"
+
+    max_length = block1.map { |row| row.length }.max
+    block1.map! { |row| row + ' '*(max_length - row.length) }
+
+    block2 = []
+    block2 << "SPECIAL ELEMENTS:"
+    block2 << " Idempotents: #{m.idempotents.join(',')}"
+    if m.zero_element
+      block2 << "Zero element: #{m.zero_element}"
+    else
+      lz = (m.left_zeros.empty? ? ['none'] : m.left_zeros).join(',')
+      block2 << "  Left-Zeros: #{lz}"
+      rz = (m.right_zeros.empty? ? ['none'] : m.right_zeros).join(',')
+      block2 << " Right-Zeros: #{rz}"
+    end
+    block2 << ''
+    block2 << ''
+    block2 << "GREEN RELATIONS:"
+    lc = m.l_classes.map { |cl| '{' + cl.join(',') + '}' }.join(' ')
+    rc = m.r_classes.map { |cl| '{' + cl.join(',') + '}' }.join(' ')
+    hc = m.h_classes.map { |cl| '{' + cl.join(',') + '}' }.join(' ')
+    dc = m.d_classes.map { |cl| '{' + cl.join(',') + '}' }.join(' ')
+    block2 << "L-Classes: #{lc}"
+    block2 << "R-Classes: #{rc}"
+    block2 << "H-Classes: #{hc}"
+    block2 << "D-Classes: #{dc}"
+    block2 << ''
+
+    @out.puts block1.zip(block2).map { |row| row.join('  ') }.join("\n")
+    @out.puts
+  end
+
+  def print_language(m,d)
+    @out.puts "\nDFA:\n#{d.to_s}\n"
+    @out.puts "\nMONOID:\n"
+    @out.puts binary_operation(m)
+    @out.puts
+  end
+
+  def binary_operation(monoid)
+   max_length = monoid.elements.map { |e| e.length }.max
+    rows = monoid.binary_operation.map do |row|
+       row.map do |e|
+        space = ' '*((max_length - e.length)/2)
+        extra_space = ' '*((max_length - e.length)%2)
+        space + extra_space + e + space
+      end.join(' | ')
+    end
+
+    first =  ' '*(max_length + 2) + '| ' + rows[0].clone + ' |'
+    seperator = first.gsub(/[^|]/,'-').gsub('|', '+')
+
+    rows.map! do |row|
+      ' ' + row[/^[^|]+\|/] + ' ' + row + " |"
+    end
+
+    result = [first]
+    result << seperator
+    result << rows.join("\n" + seperator + "\n")
+    result << seperator
+
+    result.join("\n")
+  end
+
+  def get_elements(obj)
+    [obj.to_monoid, obj.to_dfa, obj.to_re]
+  end
+end

data/lib/smon/db.rb

@@ -0,0 +1,98 @@
+module SMONLIBdb
+  def db_stat
+    stat = RLSM::MonoidDB.statistic
+    result = stat.shift.join(' | ')
+
+    column_widths = result.scan(/./).inject([0]) do |res,char|
+      if char == '|'
+        res << 0
+      else
+        res << res.pop + 1
+      end
+
+      res
+    end
+
+    result += ("\n" + '   ' + result.gsub(/[^|]/, '-').gsub('|', '+'))
+
+    stat.each do |row|
+      justified = []
+      row.each_with_index do |col,i|
+        col = col.to_s
+        space = ' '*((column_widths[i] - col.length)/2)
+        extra_space = ' '*((column_widths[i] - col.length)%2)
+        justified << space + col + space + extra_space
+      end
+
+      result += ("\n" + '   ' + justified.join('|'))
+    end
+
+    @out.puts result
+    @out.puts
+  end
+
+  def db_find(args)
+    count = RLSM::MonoidDB.count(args)
+    STDOUT.puts "Found: #{count[0]} monoid(s) (#{count[1]} syntactic)"
+    STDOUT.puts "Saved result in variable '@search_result'"
+
+    @search_result = RLSM::MonoidDB.find(args).flatten
+  end
+
+  def self.included(mon)
+    #Check if database is usable
+    begin
+      require 'database'
+
+      mon.add_help :type => 'cmd',
+      :name => 'db_stat',
+      :summary => "Shows an overview of the database.",
+      :usage => 'db_stat',
+      :description => <<DESC
+Prints for each order of a monoid the number of monoids in the database
+and the number of monoids with certain properties.
+DESC
+
+      mon.add_help :type => 'cmd',
+      :name => 'db_find',
+      :summary => "Finds monoids in the database.",
+      :usage => 'db_find [<options>]',
+      :description => <<DESC
+Finds monoids which matches the given options and saves the result
+in the variable '@serach_result'.
+
+The optional <options> parameter is a Hash with the following keys:
+ :binop -> a String
+           Searches in the database for a monoid with this binary operation.
+           The :binop-value must have the same format as for the monoid command
+           and in the database the element names are 0 1 2 3 4 5 ...
+           (Not very useful in practice.)
+
+ :m_order -> an Integer
+             Searches for monoids with the given order.
+
+ :num_generators
+ :num_idempotents
+ :num_left_nulls
+ :num_right_nulls -> an Integer
+                     Seraches for monoids with the given number of special
+                     elements like idempotents or left-zeros.
+
+ :syntactic
+ :idempotent
+ :aperiodic
+ :commutative
+ :is_group
+ :has_null
+ :l_trivial
+ :r_trivial
+ :d_trivial   -> true|false
+                 Searches for monoids with the given attribute.
+DESC
+    rescue LoadError
+      STDERR.puts "W: Could not load 'db'."
+      remove_method :db_find
+      remove_method :db_stat
+    end
+  end
+end

data/lib/smon/dot.rb

@@ -0,0 +1,65 @@
+module SMONLIBdot
+  #Creates a picture of a DFA using dot.
+  def dfa2pic(dfa, options = {:format => 'png'})
+    filename = options[:filename] || SMON.tmp_filename
+    File.open(filename + ".dot", "w") { |f| f.puts dfa2dot(dfa) }
+    system "dot -T#{options[:format]} -o #{filename}.#{options[:format]} #{filename}.dot"
+    File.delete(filename + ".dot")
+  end
+
+  #Creates string which is a dot representation of a DFA.
+  def dfa2dot(dfa)
+    str = "digraph {\n"
+    str += "size=\"2,2\"\nratio=1.0\n"
+    str += "node [shape=circle]\n"
+    str += "preinit [shape=plaintext, label=\"\"]\n"
+    (dfa.states - dfa.finals).each do |state|
+      str += state + "\n"
+    end
+    str += "node [shape=doublecircle]\n"
+    dfa.finals.each do |state|
+      str += state + "\n"
+    end
+    str += "preinit -> #{dfa.initial_state}\n"
+    dfa.states.product(dfa.states).each do |s1,s2|
+      res = dfa.transitions.find_all { |tr| tr[1] == s1 and tr[2] == s2 }
+      unless res.empty?
+        label = res.map { |tr| tr[0] }.join(',')
+        str += s1 + "->" + s2 + "[label=\"#{label}\"]\n"
+      end
+    end
+
+    str + "}"
+  end
+
+  def self.included(mod)
+    unless system("which dot > /dev/null")
+      remove_method :dfa2pic
+      STDERR.puts "W: No 'dot' command found."
+    else
+      mod.add_help :type => 'cmd',
+      :name => 'dfa2pic',
+      :summary => 'Creates a picture of a DFA using dot.',
+      :usage => 'dfa2pic <dfa> [<options>]',
+      :description => <<DESC
+The parameter <dfa> is a DFA which will be transformed with the dot program.
+Possible optional parameters are
+ :format -> a String.
+            The output format. Defaults to 'png'. Could be all what dot
+            accepts.
+
+ :filename -> a String.
+              The filename of the output.
+DESC
+    end
+
+    mod.add_help :type => 'cmd',
+      :name => 'dfa2dot',
+      :summary => 'Creates a string with dot commands.',
+      :usage => 'dfa2pic <dfa>',
+      :description => <<DESC
+The parameter <dfa> is a DFA which will be transformed to a string
+which is a valid dot description of a digraph.
+DESC
+  end
+end

data/lib/smon/latex.rb

@@ -0,0 +1,313 @@
+require 'enumerator'
+
+module SMONLIBlatex
+  def m2tex(monoid)
+    buffer = ['\begin{tabular}{' +
+               (['c']*(monoid.order+1)).join('|') + '|}']
+
+    buffer << ' & ' + monoid.binary_operation[0].map do |el|
+      "\\textbf{#{el}}"
+    end.join(' & ') + "\\\\ \\hline"
+
+    monoid.binary_operation.each do |row|
+      buffer << "\\textbf{#{row[0]}} & " + row.join(' & ') + "\\\\ \\hline"
+    end
+
+    buffer << ['\end{tabular}']
+    buffer.join("\n")
+  end
+
+  def d2tex(dfa, opts = {:dot => true})
+    #Have we dot support
+    if opts[:dot] #and @__cmds.include? "dfa2pic"
+      filename = SMON.tmp_filename
+      dfa2pic dfa, :filename => filename, :format => 'plain'
+      str = "\\begin{xy}\n0;<1.27cm,0cm>:\n"
+
+      edges = []
+      File.open(filename + ".plain", 'r').each_line do |line|
+        values = line.split
+        if ['edge','node'].include? values.first
+          str += tex_xy_node(values)
+        end
+        edges << tex_xy_edge(values) if values.first == 'edge'
+      end
+
+      str += edges.join("\n")
+
+      File.delete(filename + ".plain")
+
+      return str + "\n\\end{xy}\n"
+    else
+      str = "\\begin{tabular}{r|" +
+        (['c']*dfa.alphabet.size).join('|') + "}\n"
+      str += " & " + dfa.alphabet.map do |l|
+        "\\textbf{#{l}}"
+      end.join(' & ') + " \\\\ \\hline\n"
+      dfa.states.each do |state|
+        tmp_str = ''
+        tmp_str += "\\ensuremath{*}" if dfa.finals.include? state
+        tmp_str += "\\ensuremath{\\rightarrow}" if dfa.initial_state == state
+        tmp_str += state + " & "
+        tmp_str += dfa.alphabet.map do |letter|
+          tmp = dfa[letter,state]
+          tmp ? tmp : 'nil'
+        end.join(' & ')
+        str+= tmp_str + " \\\\\n"
+      end
+
+      return str + "\\end{tabular}\n"
+    end
+  end
+
+  def r2tex(re)
+    re_str = re.pattern.
+      gsub(RLSM::RE::Lambda, "\\lambda ").
+      gsub(RLSM::RE::Union, "\\mid ").
+      gsub(RLSM::RE::Star, "^{*}")
+
+    "\\ensuremath{#{re_str}}"
+  end
+
+  def tex_describe(obj)
+    monoid = obj.to_monoid
+    dfa = obj.to_dfa
+
+    str = <<LATEX
+\\begin{tabular}[t]{c|c}
+\\textbf{Binary Operation} & \\textbf{DFA} \\\\ \\hline
+#{m2tex(monoid)} & #{d2tex(dfa)}
+\\end{tabular}\\\\[2ex]
+#{tex_properties(monoid)}\\\\[2ex]
+#{tex_submonoids(monoid)}\\\\[2ex]
+#{monoid.syntactic? ? tex_syntactic_properties(monoid) : ''}
+
+LATEX
+
+    @out.puts str if @interactive
+
+    str
+  end
+
+  def tex_preamble
+    <<PREAMBLE
+\\documentclass[a4paper,DIV15,halfparskip*]{scrartcl}
+\\usepackage[all]{xy}
+\\usepackage{amsmath}
+
+\\begin{document}
+PREAMBLE
+  end
+
+  def compile(opts = {:format => 'dvi'})
+    str = tex_preamble
+    if opts[:object]
+      str += tex_describe(opts[:object])
+    else
+      str += opts[:input]
+    end
+    str += "\n\\end{document}"
+
+    filename = opts[:filename] || SMON.tmp_filename
+
+    File.open(filename + ".tex", 'w') { |f| f.puts str }
+
+    cmd = "latex -interaction=nonstopmode "
+    cmd += "-output-format=#{opts[:format]} " + filename  + ".tex"
+
+    system cmd
+
+    clean_up filename
+  end
+
+  def self.included(mod)
+    unless system("which latex >/dev/null")
+      remove_method :complile
+      STDERR.puts "W: compile command disabled."
+    else
+      mod.add_help :type => 'cmd',
+      :name => 'compile',
+      :summary => 'Creates a dvi or pdf from the given string or object.',
+      :usage => 'compile <options>',
+      :description => <<DESC
+Possible options are
+ :input -> a String.
+           A string which contains a valid latex source file.
+
+ :object -> a DFA or Monoid or Regular Expression.
+            The object will be transformed using tex_describe
+            and then typsetted.
+
+ :format -> a String.
+            Either 'dvi' or 'pdf'. Determines the output format of the
+            latex command.
+
+ :filename -> a String.
+              The filename of the output.
+DESC
+    end
+
+    mod.add_help :type => 'cmd',
+    :name => 'm2tex',
+    :summary => 'Transforms a monoid to tex code.',
+    :usage => 'm2tex <monoid>',
+    :description => <<DESC
+Takes a monoid and returns a string containing tex code for
+representing the monoid in tex.
+DESC
+
+    mod.add_help :type => 'cmd',
+    :name => 'r2tex',
+    :summary => 'Transforms a regular expression to tex code.',
+    :usage => 'r2tex <re>',
+    :description => <<DESC
+Takes a regular expression and returns a string containing tex code for
+representing the regular expression in tex.
+DESC
+
+    mod.add_help :type => 'cmd',
+    :name => 'd2tex',
+    :summary => 'Transforms a DFA to tex code.',
+    :usage => 'd2tex <dfa> [<options>]',
+    :description => <<DESC
+Takes a DFA and returns a string containing tex code for
+representing the DFA in tex.
+
+Optional a parameter :dot can be given.
+ :dot -> true|false
+         If true and the dfa2pic command is found, uses dot and xy-pic
+         to genearte a graph for the DFA.
+         If false a simple table is used for representing the DFA.
+DESC
+
+    mod.add_help :type => 'cmd',
+    :name => 'tex_describe',
+    :summary => 'Returns tex code equivalent to the describe command.',
+    :usage => 'tex_describe <object>',
+    :description => <<DESC
+Takes an object and returns a string containing tex code for
+representing this object in tex. Focuses on the monoid properties.
+DESC
+
+    mod.add_help :type => 'cmd',
+    :name => 'tex_preamble',
+    :summary => 'Returns the tex preamble used by the compile command.',
+    :usage => 'tex_preamble',
+    :description => <<DESC
+Not very useful in interactive mode.
+DESC
+  end
+
+  private
+  def clean_up(file)
+    files = Dir.glob(file + ".*").reject { |f| f =~ /(dvi|pdf)$/ }
+    files.each { |f| system("rm " + f) }
+  end
+
+  def set(s)
+    "\\ensuremath{\\lbrace \\mbox{#{s.join(', ')}}\\rbrace}"
+  end
+
+  def list(s)
+    str = s.join(', ')
+    str.empty? ? 'none' : str
+  end
+
+  def tex_submonoids(m)
+    sm = m.proper_submonoids.map { |s| m2tex(s) }
+    buffer = nil
+    if sm.empty?
+      buffer = ["\\textbf{Submonoids:} none"]
+    else
+      buffer = ["\\textbf{Submonoids:}\\\\[.5\\baselineskip]"]
+      buffer << sm.join("\\quad\n")
+    end
+
+    buffer.join("\n")
+  end
+
+  def tex_syntactic_properties(m)
+    buffer = ["\\textbf{Syntactic Properties:}\\\\"]
+    buffer << "\\begin{tabular}{ll}"
+    buffer << "Disjunctive Subset & Possible Regular Expression \\\\"
+    m.all_disjunctive_subsets.each do |ds|
+      re = m.to_dfa(ds).to_re
+      buffer << set(ds) + " & " + r2tex(re) + "\\\\"
+    end
+    buffer << "\\end{tabular}"
+
+    buffer.join("\n")
+  end
+
+
+  def tex_properties(m)
+    buffer = ['\begin{tabular}{llcll}']
+    buffer << '\multicolumn{2}{l}{\textbf{Properties of the Monoid:}} &'
+    buffer << ' & \multicolumn{2}{l}{\textbf{Special Elements:}} \\\\'
+    buffer << "Generator: & #{set(m.generating_subset)} & \\quad &" +
+      "Idempotents: & #{list(m.idempotents)} \\\\"
+
+    buffer << "Group: & #{m.group?} & \\quad &"
+    if m.zero_element
+      buffer[-1] += " Zero Element: & #{m.zero_element} \\\\"
+    else
+      buffer[-1] += " Left-Zeros: & #{list(m.left_zeros)} \\\\"
+    end
+
+    buffer << "Commutative: & #{m.commutative?} & \\quad &"
+    if m.zero_element
+      buffer[-1] += " & \\\\"
+    else
+      buffer[-1] += " Rigth-Zeros: & #{list(m.right_zeros)} \\\\"
+    end
+
+    buffer << "Idempotent: & #{m.idempotent?} & \\quad & & \\\\"
+    buffer << "Syntactic: & #{m.syntactic?} & \\quad &" +
+      "\\multicolumn{2}{l}{\\textbf{Green Relations:}} \\\\"
+    buffer << "Aperiodic: & #{m.aperiodic?} & \\quad &" +
+      " L-Classes: & #{list(m.l_classes.map { |x| set(x) })} \\\\"
+    buffer << "L-trivial: & #{m.l_trivial?} & \\quad &" +
+      " R-Classes: & #{list(m.r_classes.map { |x| set(x) })} \\\\"
+    buffer << "R-trivial: & #{m.r_trivial?} & \\quad &" +
+      " H-Classes: & #{list(m.h_classes.map { |x| set(x) })} \\\\"
+    buffer << "D-trivial: & #{m.d_trivial?} & \\quad &" +
+      " D-Classes: & #{list(m.d_classes.map { |x| set(x) })} \\\\"
+    buffer << "Zero Element: & #{!m.zero_element.nil?} & \\quad & & \\\\"
+    buffer << '\end{tabular}'
+
+    buffer.join("\n")
+  end
+
+  def tex_xy_node(n)
+    if n.first == 'edge'
+      return "" if n[1] == 'preinit'
+
+      num_points = n[3].to_i
+      lable_pos = n[2*num_points + 5,2].join(',')
+      label = n[2*num_points + 4].gsub("\"",'')
+
+      return ";(#{lable_pos})*[r]\\txt{#{label}}\n"
+    else
+      id = n[1]
+      xypos = n[2,2].join(',')
+      return  "(#{xypos})*{}=\"#{id}\"\n" if n[1] == 'preinit'
+
+      label = n[6]
+      type = n[8] == 'circle' ? '' : '='
+
+      return ";(#{xypos})*+=[o]++[F#{type}]{#{label}}=\"#{id}\"\n"
+    end
+  end
+
+  def tex_xy_edge(e)
+    from, to = e[1,2]
+    num_points = e[3].to_i
+    points = points_to_str(e[4,2*num_points])
+
+    "\\ar @`{#{points}} \"#{from}\";\"#{to}\""
+  end
+
+  def points_to_str(a)
+    "(" + a.enum_slice(2).to_a.map { |x| x.join(',') }.join('),(') + ")"
+  end
+end