adsl 0.0.2

data/lib/spass/bin.rb

@@ -0,0 +1,164 @@
+require 'tempfile'
+require 'parser/adsl_parser.tab'
+require 'spass/spass_ds_extensions'
+require 'spass/util'
+require 'colorize'
+require 'util/util'
+require 'util/csv_hash_formatter'
+
+module Spass
+  module Bin
+    include Spass::Util
+
+    def output(term_msg, csv)
+      if @verification_output == :terminal
+        if term_msg
+          print term_msg
+          STDOUT.flush
+        end
+      elsif @verification_output == :csv
+        @csv_output << csv if csv
+      else
+        raise "Unknown verification output #{@verification_output}"
+      end
+    end
+
+    def filter_by_name(elems, names)
+      return elems if names.nil?
+      filtered = elems.select{ |elem| names.map{ |name| elem.name.include? name}.include? true }
+    end
+
+    def verify(input, options={})
+      parser = ADSL::ADSLParser.new
+      ds_spec = parser.parse input
+
+      stop_on_incorrect = options[:halt_on_error]
+      check_satisfiability = options[:check_satisfiability]
+      timeout = options[:timeout]
+      actions = filter_by_name ds_spec.actions, options[:actions]
+      invariants = filter_by_name ds_spec.invariants, options[:invariants]
+
+      @csv_output = ::Util::CSVHashFormatter.new
+
+      @verification_output = options[:csv_output] ? :csv : :terminal
+      do_stats = @verification_output == :csv
+
+      if check_satisfiability
+        begin
+          output "Checking for satisfiability...", nil
+          
+          translation = nil
+          translation_time = Time.time_execution do
+            translation = ds_spec.translate_action nil
+          end
+
+          result, stats = exec_spass translation, timeout, true
+          if do_stats
+            stats[:translation_time] = translation_time
+            stats[:action] = '<unsatisfiability>'
+            stats[:result] = result.to_s
+          end
+
+          if result == :correct
+            output "\rSatisfiability check #{ 'failed!'.red }", stats
+            return
+          elsif result == :inconclusive
+            output "\rSatisfiability check #{ 'unconclusive'.yellow }        ", stats
+          else
+            output "\rSatisfiability check #{ 'passed'.green }.         ", stats
+          end
+        ensure
+          output "\n", nil
+        end
+      end
+
+      actions.each do |action|
+        invariants.each do |invariant|
+          output "Verifying action '#{action.name}' with invariant '#{invariant.name}'...", nil
+          begin
+            translation = nil
+            translation_time = Time.time_execution do
+              translation = ds_spec.translate_action action.name, invariant
+            end
+            result, stats = exec_spass translation, timeout, true
+            if do_stats
+              stats[:translation_time] = translation_time
+              stats[:action] = action.name
+              stats[:invariant] = invariant.name
+              stats[:result] = result.to_s
+            end
+
+            case result
+            when :correct
+              output "\rAction '#{action.name}' with invariant '#{invariant.name}': #{ 'correct'.green }     ", stats
+            when :incorrect
+              output "\rAction '#{action.name}' with invariant '#{invariant.name}': #{ 'incorrect'.red }     ", stats
+              return if stop_on_incorrect
+            when :inconclusive
+              output "\rAction '#{action.name}' with invariant '#{invariant.name}': #{ 'inconclusive'.yellow } ", stats
+            else
+              raise "Unknown exec_spass result: #{result}"
+            end
+          rescue => e
+            # puts translation
+            raise e
+          ensure
+            output "\n", nil
+          end
+        end
+      end
+    ensure
+      puts @csv_output.to_s if @verification_output == :csv
+      @csv_output = nil
+    end
+
+    def exec_spass(spass_code, timeout=-1, include_stats = false)
+      tmp_file = Tempfile.new "spass_temp"
+      tmp_file.write spass_code
+      tmp_file.close
+      arg_combos = ["", "-Sorts=0"]
+      output = process_race(*arg_combos.map{ |a| "SPASS #{a} -TimeLimit=#{timeout} #{tmp_file.path}" })
+      result = /^SPASS beiseite: (.+)\.$/.match(output)[1]
+
+      stats = include_stats ? pack_stats(spass_code, output) : nil
+      verdict = nil
+
+      case result
+      when 'Proof found'
+        verdict = :correct
+      when 'Completion found'
+        verdict = :incorrect
+      else
+        verdict = :inconclusive
+      end
+      return stats.nil? ? verdict : [verdict, stats]
+    ensure
+      tmp_file.delete unless tmp_file.nil?
+    end
+
+    def pack_stats(spass_code, spass_output)
+      spass_output = spass_output.split("\n").last(10).join("\n")
+      stats = {}
+      stats[:translation_time] = nil # should be set externally
+
+      identifiers = /predicates\s*\[([^\]]*)\]/.match(spass_code)[1].scan(/\w+/)
+      stats[:spass_predicate_count] = identifiers.length
+
+      formulae = spass_code.scan(/formula\s*\([^\.]+\)\./)
+      stats[:spass_formula_count] = formulae.length
+      stats[:average_formula_length] = formulae.inject(0){ |total, formula| total += formula.length} / formulae.length
+
+      times = spass_output.scan(/(\d):(\d\d):(\d\d)\.(\d\d)/)
+      raise if times.length != 6
+      times = times.map{ |time| time[3].to_i*10 + time[2].to_i*1000 + time[1].to_i*60*1000 + time[0].to_i*60*60*1000 }
+      stats[:spass_preparation_time] = times[1..2].sum 
+      stats[:spass_proof_lookup_time] = times[3..5].sum
+
+      stats[:proof_clause_count] = /^SPASS derived (\d+) clauses.*$/.match(spass_output)[1].to_i
+      
+      stats[:memory] = /^\s*SPASS allocated (\d+) KBytes.*$/.match(spass_output)[1].to_i
+
+      stats
+    end
+  end
+end

data/lib/spass/ruby_extensions.rb

@@ -0,0 +1,25 @@
+class Symbol
+  def to_spass_string
+    to_s
+  end
+end
+
+class String
+  def to_spass_string
+    self
+  end
+
+  def resolve_params(*args)
+    args = args.flatten
+    max_arg_index = self.scan(/\$\{(\d+)\}/).map{ |a| a.first.to_i }.max || 0
+    if args.length < max_arg_index
+      raise ArgumentError, "Invalid argument number: #{args.length} instead of #{max_arg_index}"
+    end
+    result = self
+    args.length.times do |i|
+      result = result.gsub "${#{i + 1}}", args[i].to_s
+    end
+    result
+  end
+end
+

data/lib/spass/spass_ds_extensions.rb

@@ -0,0 +1,870 @@
+require 'fol/first_order_logic'
+require 'spass/spass_translator'
+
+module DS
+  class DSNode
+    def replace_var(from, to); end
+  end
+  
+  class DSSpec < DSNode
+    def translate_action(action_name, *listed_invariants)
+      translation = SpassTranslator::Translation.new
+
+      if action_name
+        action = @actions.select{ |a| a.name == action_name }
+        raise ArgumentError, "Action '#{action_name}' not found" if action.empty?
+        action = action.first
+      end
+
+      translation.classes.concat @classes
+      @classes.each do |klass|
+        klass.translate(translation)
+      end
+
+      relations = @classes.map{ |c| c.relations }.flatten
+      relations.select{ |r| r.inverse_of.nil? }.each do |relation|
+        relation.translate(translation)
+      end
+      relations.select{ |r| r.inverse_of }.each do |relation|
+        relation.translate(translation)
+      end
+
+      action.prepare(translation) if action_name
+
+      translation.create_formula FOL::ForAll.new(:o, FOL::Equiv.new(
+        translation.is_object[:o],
+        FOL::Or.new(@classes.map{ |c| c[:o] })
+      ))
+      @classes.group_by{ |klass| klass.parent }.each do |common_parent, children|
+        unless common_parent.nil?
+          translation.create_formula FOL::ForAll.new(:o, FOL::Implies.new(
+            FOL::Or.new(children.map{ |c| c[:o] }),
+            common_parent[:o]
+          ))
+        end
+        if children.length > 1
+          children.each do |child|
+            translation.create_formula FOL::ForAll.new(:o, FOL::Implies.new(
+              child[:o],
+              FOL::Not.new(children.select{ |c| c != child}.map{ |c| c[:o] })
+            ))
+          end
+        end
+      end
+
+      relations = @classes.map{ |c| c.relations }.flatten.map{ |rel| rel.type_pred }.uniq
+      translation.create_formula FOL::ForAll.new(:o, FOL::Equiv.new(
+        translation.is_tuple[:o],
+        FOL::Or.new(relations.map{ |r| r[:o] })
+      ))
+      if relations.length > 1
+        relations.each do |relation|
+          translation.create_formula FOL::ForAll.new(:o, FOL::Implies.new(
+            relation[:o],
+            FOL::Not.new(relations.select{ |c| c != relation}.map{ |c| c[:o] })
+          ))
+        end
+      end
+
+      translation.create_formula FOL::ForAll.new(:o, FOL::OneOf.new(
+        translation.is_object[:o],
+        translation.is_tuple[:o],
+        translation.is_either_resolution[:o]
+      ))
+      translation.create_formula FOL::ForAll.new(:o, FOL::Implies.new(
+        translation.existed_initially[:o],
+        FOL::Or.new(translation.is_object[:o], translation.is_tuple[:o])
+      ))
+      translation.create_formula FOL::ForAll.new(:o, FOL::Equiv.new(
+        translation.existed_initially[:o], 
+        translation.prev_state[:o]
+      ))
+
+      action.translate(translation) if action_name
+
+      if action_name
+        translation.invariant_state = translation.existed_initially
+        pre_invariants = @invariants.map{ |invariant| invariant.formula.resolve_invariant_formula(translation) }
+      
+        listed_invariants = @invariants if listed_invariants.empty?
+        translation.invariant_state = translation.exists_finally
+        post_invariants = listed_invariants.map{ |invariant| invariant.formula.resolve_invariant_formula(translation) }
+        
+        translation.create_conjecture FOL::Implies.new(
+          FOL::And.new(pre_invariants),
+          FOL::And.new(post_invariants)
+        ).resolve_spass
+      else
+        # used to check for contradictions in the model
+        invariants_formulae = invariants.map do |invariant|
+          formula = invariant.formula
+          dummy_state = translation.create_predicate 'always_true', 1
+          translation.create_formula FOL::ForAll.new(:o, dummy_state[:o])
+          translation.invariant_state = dummy_state
+          formula.resolve_invariant_formula(translation)
+        end
+        translation.create_conjecture FOL::Not.new(FOL::And.new(invariants_formulae))
+      end
+
+      return translation.to_spass_string
+    end
+  end
+
+  class DSAction < DSNode
+    include FOL
+
+    def prepare(translation)
+      @args.each do |arg|
+        arg.define_predicate translation
+      end
+      @block.prepare translation
+    end
+
+    def translate(translation)
+      translation.context = translation.root_context
+      
+      @args.length.times do |i|
+        cardinality = @cardinalities[i]
+        arg = @args[i]
+
+        translation.create_formula _for_all(:o, _implies(
+          arg[:o],
+          _and(translation.existed_initially[:o], arg.type[:o])
+        ))
+
+        translation.create_formula _exists(:o, arg[:o]) if cardinality[0] > 0
+        if cardinality[1] == 1
+          translation.create_formula _for_all(:o1, :o2, _implies(
+            _and(arg[:o1], arg[:o2]),
+            _equal(:o1, :o2)
+          ))
+        end
+      end
+
+      @block.migrate_state_spass translation
+      
+      translation.create_formula _for_all(:o, _equiv(
+        translation.exists_finally[:o],
+        translation.prev_state[:o]
+      ))
+    end
+  end
+
+  class DSClass < DSNode
+    def [](variable)
+      @type_pred[variable]
+    end
+
+    def translate(translation)
+      @type_pred = translation.create_predicate "of_#{@name}_type", 1
+    end
+  end
+
+  class DSRelation < DSNode
+    include FOL
+    attr_reader :type_pred, :left_link, :right_link
+
+    def [](variable)
+      @type_pred[variable]
+    end
+
+    def translate(translation)
+      if @inverse_of
+        @type_pred = @inverse_of.type_pred
+        @left_link = @inverse_of.right_link
+        @right_link = @inverse_of.left_link
+      else
+        @type_pred = translation.create_predicate "of_#{@from_class.name}_#{@name}_type", 1
+        @left_link = translation.create_predicate "left_link_#{@from_class.name}_#{@name}", 2
+        @right_link = translation.create_predicate "right_link_#{@from_class.name}_#{@name}", 2
+        translation.create_formula _for_all(:t, :o, _implies(@left_link[:t, :o], _and(@from_class[:o], @type_pred[:t])))
+        translation.create_formula _for_all(:t, :o, _implies(@right_link[:t, :o], _and(@to_class[:o], @type_pred[:t])))
+        translation.create_formula _for_all(:t, :o1, :o2, _and(
+          _implies(_and(@left_link[:t, :o1], @left_link[:t, :o2]), _equal(:o1, :o2)),
+          _implies(_and(@right_link[:t, :o1], @right_link[:t, :o2]), _equal(:o1, :o2))
+        ))
+        translation.create_formula _for_all(:t, _implies(
+          @type_pred[:t],
+          _exists(:o1, :o2, _and(@left_link[:t, :o1], @right_link[:t, :o2]))
+        ))
+      end
+
+      if @cardinality[0] > 0
+        translation.create_formula _for_all(:o, _implies(@from_class[:o], _exists(:t, @left_link[:t, :o])))
+      end
+      if @cardinality[1] == 1
+        translation.create_formula _for_all(:o, :t1, :t2, _implies(
+          _and(@left_link[:t1, :o], @left_link[:t2, :o]),
+          _equal(:t1, :t2)
+        ))  
+      end
+    end
+  end
+
+  class DSCreateObj < DSNode
+    include FOL
+    attr_reader :context_creation_link, :context
+
+    def prepare(translation)
+      @context = translation.context
+      translation.create_obj_stmts[@klass] << self
+      @context_creation_link = translation.create_predicate "created_#{@klass.name}_in_context", context.level + 1
+    end
+
+    def migrate_state_spass(translation)
+      state = translation.create_state "post_create_#{@klass.name}"
+      prev_state = translation.prev_state
+      translation.gen_formula_for_unique_arg(@context_creation_link, (0..@context.level-1), @context.level)
+      translation.reserve_names @context.p_names, :o do |ps, o|
+        created_by_other_create_stmts = translation.create_obj_stmts[@klass].select{|s| s != self}.map do |stmt|
+          formula = nil
+          translation.reserve_names stmt.context.p_names do |other_ps|
+            formula = _exists(other_ps, stmt.context_creation_link[other_ps, o])
+          end
+          formula
+        end
+        created_by_other_create_stmts << translation.existed_initially[o]
+        child_classes = translation.classes.select{ |c| c.parent == @klass }
+        not_of_child_types = child_classes.empty? ? true : _and(child_classes.map{ |c| _not(c[o]) })
+        translation.create_formula _for_all(ps, o, _implies(
+          @context_creation_link[ps, o], _and(
+            context.type_pred(ps),
+            _not(created_by_other_create_stmts),
+            @klass[o],
+            not_of_child_types
+          )
+        ))
+        translation.create_formula _for_all(ps, _implies(@context.type_pred(ps), _exists(o,
+          @context_creation_link[ps, o]
+        )))
+        translation.create_formula _for_all(ps, o,
+          _if_then_else_eq(
+            @context_creation_link[ps, o],
+            _and(_not(prev_state[ps, o]), state[ps, o]),
+            _equiv(prev_state[ps, o], state[ps, o])
+          )
+        )
+
+        relevant_from_relations = translation.classes.map{ |c| c.relations }.flatten.select{ |r| r.from_class == @klass }
+        relevant_to_relations = translation.classes.map{ |c| c.relations }.flatten.select{ |r| r.to_class == @klass }
+        translation.reserve_names :r do |r|
+          translation.create_formula _for_all(ps, o, _implies(
+            @context_creation_link[ps, o],
+            _for_all(r, _not(_and(
+              state[ps, r],
+              _or(
+                relevant_from_relations.map{ |rel| rel.left_link[r, o] },
+                relevant_to_relations.map{ |rel| rel.right_link[r, o] }
+              )
+            )))
+          ))
+        end
+      end
+
+      translation.prev_state = state
+    end
+  end
+
+  class DSCreateObjset < DSNode
+    include FOL
+    
+    def prepare_action(translation); end
+
+    def resolve_action_objset(translation, ps, var)
+      return @createobj.context_creation_link[ps, var]
+    end
+  end
+
+  class DSDeleteObj < DSNode
+    include FOL
+    attr_accessor :context_deletion_link
+
+    def prepare(translation)
+      @objset.prepare_action translation
+    end
+
+    def migrate_state_spass(translation)
+      state = translation.create_state "post_delete_#{@objset.type.name}"
+      prev_state = translation.prev_state
+      context = translation.context
+      
+      translation.reserve_names context.p_names, :o do |ps, o|
+        translation.create_formula _for_all(ps, o,
+          _if_then_else_eq(_and(@objset.resolve_action_objset(translation, ps, o), prev_state[ps, o]),
+            _and(prev_state[ps, o], _not(state[ps, o])),
+            _equiv(prev_state[ps, o], state[ps, o])
+          )
+        )
+      end
+
+      translation.prev_state = state
+    end
+  end
+
+  class DSCreateTup < DSNode
+    include FOL
+   
+    def prepare(translation)
+      @objset1.prepare_action translation
+      @objset2.prepare_action translation
+    end
+
+    def migrate_state_spass(translation)
+      state = translation.create_state "post_create_#{@relation.from_class.name}_#{@relation.name}"
+      prev_state = translation.prev_state
+      context = translation.context
+
+      translation.reserve_names context.p_names, :r, :o1, :o2 do |ps, r, o1, o2|
+        objset1 = @objset1.resolve_action_objset(translation, ps, o1)
+        objset2 = @objset2.resolve_action_objset(translation, ps, o2)
+        translation.create_formula FOL::ForAll.new(ps, r, FOL::Implies.new(
+          context.type_pred(ps),
+          FOL::Equiv.new(
+            state[ps, r],
+            FOL::Or.new(
+              prev_state[ps, r],
+              FOL::Exists.new(o1, o2, FOL::And.new(
+                prev_state[ps, o1], prev_state[ps, o2],
+                @relation.left_link[r, o1], @relation.right_link[r, o2],
+                objset1, objset2
+              ))
+            )
+          )
+        ))
+        translation.create_formula FOL::ForAll.new(ps, o1, o2, FOL::Implies.new(
+          FOL::And.new(prev_state[ps, o1], prev_state[ps, o2], objset1, objset2),
+          FOL::Exists.new(r, FOL::And.new(state[ps, r], @relation.left_link[r, o1], @relation.right_link[r, o2]))
+        ))
+      end
+      translation.prev_state = state
+    end
+  end
+
+  class DSDeleteTup < DSNode
+    include FOL
+
+    def prepare(translation)
+      @objset1.prepare_action translation
+      @objset2.prepare_action translation
+    end
+
+    def migrate_state_spass(translation)
+      state = translation.create_state "post_deleteref_#{@relation.from_class.name}_#{@relation.name}"
+      prev_state = translation.prev_state
+      context = translation.context
+
+      translation.reserve_names context.p_names, :r, :o1, :o2 do |ps, r, o1, o2|
+        objset1 = @objset1.resolve_action_objset(translation, ps, o1)
+        objset2 = @objset2.resolve_action_objset(translation, ps, o2)
+        translation.create_formula FOL::ForAll.new(ps, r, FOL::Equiv.new(
+          state[ps, r],
+          FOL::And.new(
+            prev_state[ps, r],
+            FOL::ForAll.new(o1, o2, FOL::Not.new(FOL::And.new(
+              objset1, objset2,
+              prev_state[ps, o1], prev_state[ps, o2],
+              @relation.left_link[r, o1], @relation.right_link[r, o2]
+            )))
+          )
+        ))
+      end
+
+      translation.prev_state = state
+    end
+  end
+
+  class DSEither < DSNode
+    include FOL
+    attr_reader :resolution_link, :is_trues
+    
+    def prepare(translation)
+      context = translation.context
+      @resolution_link = translation.create_predicate :resolution_link, context.level+1
+      translation.reserve_names context.p_names, :r do |ps, r|
+        translation.gen_formula_for_unique_arg(@resolution_link, (0..ps.length-1), ps.length)
+        translation.create_formula _for_all(ps, r, _implies(@resolution_link[ps, r], _and(
+          translation.context.type_pred(ps),
+          translation.is_either_resolution[r]
+        )))
+      end
+      @is_trues = []
+      @blocks.length.times do |i|
+        is_trues << translation.create_predicate("either_resolution_#{i}_is_true", 1)
+      end
+      @blocks.each do |block|
+        block.prepare(translation)
+      end
+    end
+
+    def migrate_state_spass(translation)
+      post_state = translation.create_state :post_either
+      prev_state = translation.prev_state
+      context = translation.context
+
+      pre_states = []
+      post_states = []
+      @blocks.length.times do |i|
+        pre_states << translation.create_state(:pre_of_either)
+      end
+      translation.create_formula FOL::ForAll.new(:r, FOL::Implies.new(
+        translation.is_either_resolution[:r],
+        FOL::OneOf.new(is_trues.map{ |pred| pred[:r] })
+      ))
+
+      translation.reserve_names context.p_names, :resolution, :o do |ps, resolution, o|
+        translation.create_formula FOL::ForAll.new(ps, FOL::Implies.new(
+          translation.context.type_pred(ps),
+          FOL::Exists.new(resolution, FOL::And.new(
+            @resolution_link[ps, resolution],
+            FOL::And.new((0..@blocks.length-1).map { |i|
+              FOL::Equiv.new(is_trues[i][resolution], FOL::ForAll.new(o, FOL::Equiv.new(prev_state[ps, o], pre_states[i][ps, o])))
+            })
+          ))
+        ))
+      end
+
+      @blocks.length.times do |i|
+        translation.prev_state = pre_states[i]
+        @blocks[i].migrate_state_spass translation
+        post_states << translation.prev_state
+      end
+        
+      translation.reserve_names context.p_names, :resolution, :o do |ps, resolution, o|
+        translation.create_formula FOL::ForAll.new(ps, FOL::Implies.new(
+          translation.context.type_pred(ps),
+          FOL::Exists.new(resolution, FOL::And.new(
+            @resolution_link[ps, resolution],
+            FOL::And.new((0..@blocks.length-1).map { |i|
+              FOL::Equiv.new(is_trues[i][resolution], FOL::ForAll.new(o, FOL::Equiv.new(post_state[ps, o], post_states[i][ps, o])))
+            })
+          ))
+        ))
+      end
+      
+      translation.prev_state = post_state
+    end
+  end
+
+  class DSEitherLambdaObjset < DSNode
+    def prepare_action(translation); end
+
+    def resolve_action_objset(translation, ps, o)
+      translation.reserve_names :r do |r|
+        implications = []
+        @either.blocks.length.times do |i|
+          implications << FOL::Implies.new(@either.is_trues[i][r], @vars[i].resolve_action_objset(translation, ps, o))
+        end
+        
+        return FOL::ForAll.new(:r, FOL::Implies.new(
+          @either.resolution_link[ps, r],
+          FOL::And.new(implications)
+        ))
+      end
+    end
+  end
+
+  class DSForEachCommon < DSNode
+    include FOL
+
+    attr_reader :context, :pre_iteration_state, :post_iteration_state, :pre_state, :post_state
+
+    def prepare_with_context(translation, flat_context)
+      @context = translation.create_context "for_each_context", flat_context, translation.context
+      @objset.prepare_action translation
+      translation.context = @context
+      @block.prepare translation
+      translation.context = @context.parent
+    end
+
+    def migrate_state_spass(translation)
+      @pre_state = translation.prev_state
+      @post_state = translation.create_state :post_for_each
+      
+      translation.reserve_names @context.parent.p_names, :o do |ps, o|
+        translation.create_formula _for_all(ps, o, _equiv(
+          _and(@objset.resolve_action_objset(translation, ps, o), @pre_state[ps, o]),
+          @context.type_pred(ps, o)
+        ))
+      end
+
+      translation.context = @context
+      
+      @pre_iteration_state = translation.create_state :pre_iteration
+      @post_iteration_state = translation.create_state :post_iteration
+      
+      translation.prev_state = @pre_iteration_state
+      @block.migrate_state_spass translation
+      
+      translation.reserve_names @context.p_names, :o do |ps, o|
+        translation.create_formula _for_all(ps, o, _equiv(
+          translation.prev_state[ps, o],
+          @post_iteration_state[ps, o]
+        ))
+      end
+
+      create_iteration_formulae translation
+      translation.context = @context.parent
+      translation.prev_state = post_state
+    end
+  end
+
+  class DSForEach < DSForEachCommon
+    def prepare(translation)
+      prepare_with_context(translation, false)
+    end
+
+    def create_iteration_formulae(translation)
+      raise "Not implemented for flexible arities"
+      translation.create_formula _if_then_else_eq(
+        _exists(:c, :o, _and(old_state[:c, :o], @objset.resolve_action_objset(translation, :c, :o))),
+        _for_all(:parent, :c, :o, _implies(@context.parent_of_link[:parent, :c], _and(
+          _if_then_else(
+            @context.first[:parent, :c],
+            _equiv(old_state[:parent, :o], @pre_iteration_state[:c, :o]),
+            _for_all(:prev, _implies(
+              @context.just_before[:prev, :c],
+              _equiv(@post_iteration_state[:prev, :o], @pre_iteration_state[:c, :o])
+            ))
+          ),
+          _implies(
+            @context.last[:parent, :c],
+            _equiv(@post_state[:parent, :o], @post_iteration_state[:c, :o])
+          )
+        ))),
+        _for_all(:c, :o, _equiv(@pre_state[:c, :o], @post_state[:c, :o]))
+      )
+    end
+  end
+
+  class DSForEachIteratorObjset < DSNode
+    def prepare_action(translation); end
+
+    def resolve_action_objset(translation, ps, o)
+      return FOL::Equal.new(o, ps[@for_each.context.level-1])
+    end
+  end
+
+  class DSForEachPreLambdaObjset < DSNode
+    def prepare_action(translation); end
+
+    def resolve_action_objset(translation, ps, o)
+      raise "Not implemented for flexible arities"
+      translation.reserve_names :parent, :prev_context do |parent, prev_context|
+        return FOL::ForAll.new(parent, FOL::Implies.new(@context.parent_of_pred[parent, :c],
+          FOL::IfThenElseEq.new(
+            @context.first[parent, c],
+            @before_var[c, o],
+            FOL::Exists.new( prev_context, FOL::And.new(
+              @context.just_before[prev_context, c],
+              @inside_var[prev_context, o]
+            ))
+          )
+        ))
+      end
+    end
+  end
+
+  class DSFlatForEach < DSForEachCommon
+    def prepare(translation)
+      prepare_with_context(translation, true)
+    end
+
+    def create_iteration_formulae(translation)
+      context = translation.context
+      translation.reserve_names context.p_names, :o, :c1, :c2 do |ps, o, c1, c2|
+        ps_without_last = ps.first(ps.length - 1)
+        translation.create_formula _for_all(ps, o, _implies(
+          @context.type_pred(ps),
+          _equiv(@pre_state[ps_without_last, o], @pre_iteration_state[ps, o])
+        ))
+        translation.create_formula _for_all(ps_without_last, o, _if_then_else(
+          _not(_exists(ps.last, @context.type_pred(ps))),
+          _equiv(@pre_state[ps_without_last, o], @post_state[ps_without_last, o]),
+          _implies(
+            @context.parent.type_pred(ps_without_last),
+            _equiv(
+              @post_state[ps_without_last, o],
+              _or(
+                _and(
+                  @pre_state[ps_without_last, o],
+                  _for_all(ps.last, _implies(
+                    @context.type_pred(ps),
+                    @post_iteration_state[ps, o]
+                  ))
+                ),
+                _and(
+                  _not(@pre_state[ps_without_last, o]),
+                  _exists(ps.last, @post_iteration_state[ps, o])
+                )
+              )
+            )
+          )
+        ))
+      end
+    end
+  end
+
+  class DSBlock < DSNode
+    def prepare(translation)
+      @statements.each do |stat|
+        stat.prepare translation
+      end
+    end
+
+    def migrate_state_spass(translation)
+      @statements.each do |stat|
+        stat.migrate_state_spass translation
+      end
+    end
+  end
+
+  class DSAssignment < DSNode
+    def prepare(translation)
+      @var.define_predicate translation
+      @objset.prepare_action translation
+    end
+
+    def migrate_state_spass(translation)
+      context = translation.context
+      translation.reserve_names context.p_names, :o do |ps, o|
+        translation.create_formula FOL::ForAll.new(ps, o, FOL::Equiv.new(
+          var.resolve_action_objset(translation, ps, o),
+          FOL::And.new(
+            translation.prev_state[ps, o],
+            objset.resolve_action_objset(translation, ps, o)
+          )
+        ))
+      end
+    end
+  end
+
+  class DSVariable < DSNode
+    attr_accessor :context, :pred
+
+    def action_name
+      "var_#{@name}"
+    end
+    
+    # The predicate is not defined in prepare_action
+    # as we want the predicate to be defined only when assigning to the variable
+    # not when using it
+    # a nil check does not work because it makes the translation non-reusable
+    def prepare_action(translation); end
+    def define_predicate(translation)
+      @context = translation.context
+      @pred = translation.create_predicate action_name, context.level + 1
+    end
+
+    def resolve_action_objset(translation, ps, var)
+      return @pred[ps.first(@context.level), var]
+    end
+
+    def invariant_name
+      "invariant_var_#{@name}"
+    end
+
+    def resolve_invariant_objset(translation, var)
+      FOL::Equal.new(invariant_name, var)
+    end
+
+    def [](*args)
+      @pred[args]
+    end
+  end
+
+  class DSAllOf < DSNode
+    def prepare_action(translation); end
+    
+    def resolve_action_objset(translation, ps, var)
+      return @klass[var]
+    end
+
+    def resolve_invariant_objset(translation, var)
+      return @klass[var]
+    end
+  end
+
+  class DSDereference < DSNode
+    def prepare_action(translation)
+      @objset.prepare_action translation
+    end
+
+    def resolve_action_objset(translation, ps, var)
+      translation.reserve_names :temp, :r do |temp, r|
+        return FOL::Exists.new(temp, r, FOL::And.new(
+          translation.prev_state[ps, r],
+          translation.prev_state[ps, temp],
+          @objset.resolve_action_objset(translation, ps, temp),
+          @relation.left_link[r, temp],
+          @relation.right_link[r, var]
+        ))
+      end
+    end
+
+    def resolve_invariant_objset(translation, var)
+      translation.reserve_names :temp, :r do |temp, r|
+        return FOL::Exists.new(temp, r, FOL::And.new(
+          translation.invariant_state[temp],
+          translation.invariant_state[r],
+          @objset.resolve_invariant_objset(translation, temp),
+          @relation.left_link[r, temp],
+          @relation.right_link[r, var]
+        ))
+      end
+    end
+  end
+
+  class DSSubset < DSNode
+    def prepare_action(translation)
+      @objset.prepare_action translation
+    end
+
+    def resolve_action_objset(translation, ps, var)
+      context = translation.context
+      pred = translation.create_predicate :subset, context.level + 1
+      translation.reserve_names context.p_names do |ps|
+        translation.create_formula FOL::ForAll.new(ps, :o,
+          FOL::Implies.new(pred[ps, :o], @objset.resolve_action_objset(translation, ps, :o))
+        )
+      end
+      return pred[ps, var]
+    end
+    
+    def resolve_invariant_objset(translation, var)
+      pred = translation.create_predicate :subset, 1
+      translation.create_formula FOL::ForAll.new(:o, 
+        FOL::Implies.new(pred[:o], @objset.resolve_invariant_objset(translation, :o))
+      )
+      return pred[var]
+    end
+  end
+
+  class DSOr < DSNode
+    def resolve_invariant_formula(translation)
+      FOL::Or.new(@subformulae.map{ |sub| sub.resolve_invariant_formula translation })
+    end
+  end
+  
+  class DSAnd < DSNode
+    def resolve_invariant_formula(translation)
+      FOL::And.new(@subformulae.map{ |sub| sub.resolve_invariant_formula translation })
+    end
+  end
+
+  class DSEquiv < DSNode
+    def resolve_invariant_formula(translation)
+      FOL::Equiv.new(@subformulae.map{ |sub| sub.resolve_invariant_formula translation })
+    end
+  end
+  
+  class DSImplies < DSNode
+    def resolve_invariant_formula(translation)
+      subformula1 = @subformula1.resolve_invariant_formula translation
+      subformula2 = @subformula2.resolve_invariant_formula translation
+      FOL::Implies.new(subformula1, subformula2)
+    end
+  end
+  
+  class DSOneOf < DSNode
+    def prepare_action(translation)
+      @objset.prepare_action translation
+    end
+
+    def resolve_action_objset(translation, ps, var)
+      context = translation.context
+      pred = translation.create_predicate :one_of, context.level + 1
+      translation.gen_formula_for_unique_arg(pred, context.level)
+      translation.reserve_names context.p_names, :o do |subps, o|
+        co_in_objset = @objset.resolve_action_objset(translation, subps, o)
+        translation.create_formula FOL::ForAll.new(subps, FOL::Equiv.new(
+          FOL::Exists.new(o, FOL::And.new(translation.prev_state[subps, o], pred[subps, o])),
+          FOL::Exists.new(o, FOL::And.new(translation.prev_state[subps, o], co_in_objset))
+        ))
+        translation.create_formula FOL::ForAll.new(subps, o,
+          FOL::Implies.new(pred[subps, o], FOL::And.new(translation.prev_state[subps, o], co_in_objset))
+        )
+      end
+      return pred[ps, var]
+    end
+  end
+
+  class DSNot < DSNode
+    def resolve_invariant_formula(translation)
+      subformula = @subformula.resolve_invariant_formula translation
+      return FOL::Not.new(subformula)
+    end
+  end
+  
+  class DSBoolean < DSNode
+    def resolve_invariant_formula(translation)
+      return @bool_value.resolve_spass
+    end
+  end
+
+  class DSForAll < DSNode
+    def resolve_invariant_formula(translation)
+      subformula = @subformula.resolve_invariant_formula translation
+      var_constraints = []
+      @vars.length.times do |index|
+        var_constraints << @objsets[index].resolve_invariant_objset(translation, @vars[index].invariant_name)
+      end
+      return FOL::ForAll.new(@vars.map{ |v| v.invariant_name }, FOL::Implies.new(
+        FOL::And.new(
+          @vars.map{ |v| translation.invariant_state[v.invariant_name] },
+          var_constraints
+        ),
+        subformula
+      )).resolve_spass
+    end
+  end
+
+  class DSExists < DSNode
+    def resolve_invariant_formula(translation)
+      subformula = @subformula.nil? ? true : @subformula.resolve_invariant_formula(translation)
+      subformula ||= true
+      return FOL::Exists.new(@vars.map{ |v| v.invariant_name }, FOL::And.new(
+        @vars.map{ |v| translation.invariant_state[v.invariant_name] },
+        @vars.map{ |v| v.type[v.invariant_name] },
+        @vars.map{ |v| v.resolve_invariant_objset(translation, v.invariant_name) },
+        subformula
+      )).resolve_spass
+    end
+  end
+
+  class DSEqual < DSNode
+    def resolve_invariant_formula(translation)
+      translation.reserve_names :temp do |temp|
+        objsets = @objsets.map{ |o| o.resolve_invariant_objset translation, temp }
+        return FOL::ForAll.new(temp, FOL::Implies.new(
+          translation.invariant_state[temp],
+          FOL::Equiv.new(objsets)
+        )).resolve_spass
+      end
+    end
+  end
+
+  class DSIn < DSNode
+    def resolve_invariant_formula(translation)
+      translation.reserve_names :temp do |temp|
+        return FOL::ForAll.new(temp, FOL::Implies.new(
+          translation.invariant_state[temp],
+          FOL::Implies.new(
+            @objset1.resolve_invariant_objset(translation, temp),
+            @objset2.resolve_invariant_objset(translation, temp)
+          )
+        ))
+      end
+    end
+  end
+  
+  class DSEmpty < DSNode
+    def resolve_invariant_formula(translation)
+      translation.reserve_names :temp do |temp|
+        return FOL::ForAll.new(temp, FOL::Implies.new(
+          translation.invariant_state[temp],
+          FOL::Not.new(@objset.resolve_invariant_objset(translation, temp))
+        ))
+      end
+    end
+  end
+end