cauldron 0.1.3 → 0.1.5

data/lib/theory/ActionImplementation.rb

@@ -1,17 +0,0 @@
-class ActionImplementation < TheoryAction
-  
-  attr_reader :target_id
-  
-  def initialize(statement,target_id,theory_component_id=nil)
-    super(statement,target_id,theory_component_id)
-  end
-  
-  def copy
-    return ActionImplementation.new(@action.copy,@target_id.copy,@theory_component_id)
-  end
-  
-  def write(tab=0)
-    return ("  "*tab)+"runtime_method.add_statement_at(#{@action.write},#{@target_id.write})"
-  end    
-  
-end

data/lib/theory/TheoryAction.rb

@@ -1,100 +0,0 @@
-# The theory action represents the what theory inserts into the 
-# main runtime method.
-#
-class TheoryAction
-  include TheoryComponent
-  
-  attr_reader :target_id, :action
-  # 
-  # @param  action          A statement to insert into the main runtime method.
-  #                         e.g. action.write => "return var8"
-  # @param  target_id       The id of the nested statement or method to add the generated statement to.
-  # 
-  def initialize(action,target_id,theory_component_id=nil)
-    raise StandardError.new('Expecting theory statement but was '+action.class.to_s) unless action.kind_of?(TheoryStatement)
-    @action = action
-    @target_id = target_id
-    @theory_component_id = theory_component_id unless theory_component_id.nil?    
-    generate_theory_component_id
-  end
-   
-  # Provide a general description of the action, explaining the statement
-  # it will add to the runtime method and where.  This is pseudo code
-  # and shouldn't be interpretted at runtime.  Use "write" for runtime
-  # actions.
-  #
-  # @param  tab     
-  #    
-  def describe(tab=0)
-    # TODO  That is nicer way to do tabs - I should make the other methods consistent with it
-    return ("  "*tab)+"<runtime_method>.add_statement_at(#{@action.describe},#{@target_id.describe})"
-  end
-  
-  def write(tab=0)
-    return ('  '*tab)+"<runtime_method>.add_statement_at(#{@action.write},#{@target_id.write})"
-  end
-  
-  # Returns all the theory vairables in this theory action 
-  #
-  def theory_variables
-    return @action.select_all {|x| x.kind_of?(TheoryVariable)}
-  end
-  
-  # Returns a action implementation with the theory variable declarations replaced with
-  # the values in the mapping hash. 
-  # 
-  def map_to(mapping)
-
-    # Duplicate the current statement before it is rewritten
-    rewritten_statement = @action.copy
-    target_id = @target_id.copy
-    
-    # Find all containers of VariableDeclarations that declare a TheoryVariable
-    containers = [rewritten_statement,target_id].select_all {|x| x.respond_to?(:has?)}
-    theory_variable_containers = containers.select {|x| x.has? {|y| y.kind_of?(TheoryVariable)}}
-    
-    # Do any of the containers contain each other?
-    # => TODO Need to prevent this
-    all_theory_variables = Set.new
-    theory_variable_containers.each do |x|
-      results = x.select_all([]) {|y| y.kind_of?(TheoryVariable)}
-      all_theory_variables += results
-    end
-    
-    map = {}
-    all_theory_variables.each do |x|
-      next if mapping[x.theory_variable_id].nil?
-      map[x] = mapping[x.theory_variable_id]  
-    end
-        
-    rewritten_statement.replace_variables_alt!(map) 
-    target_id.replace_variables_alt!(map)
-    
-    return ActionImplementation.new(rewritten_statement,target_id,@theory_component_id)
-    
-  end  
-  
-  def copy
-    return TheoryAction.new(@action.copy,@target_id,@theory_component_id)
-  end
-  
-  def statements_with_variable(variable_id)
-    
-    # Duplicate the current statement before it is rewritten
-    rewritten_statement = @action.copy
-    target_id = @target_id.copy
-    
-    # Find all containers of VariableDeclarations that declare a TheoryVariable
-    containers = [rewritten_statement,target_id].select_all {|x| x.respond_to?(:has?)}
-    theory_variable_containers = containers.select {|x| x.has? {|y| y.kind_of?(TheoryVariable)}}
-    
-    results = theory_variable_containers.select do |x|
-      reg = eval '/var'+variable_id.to_s+'/'
-      x.write.match(reg)
-    end
-    return results
-    
-  end
-  
-  
-end

data/lib/theory/TheoryChainValidator.rb

@@ -1,103 +0,0 @@
-# Instances of this class receive a chain of order theories and proceed
-# to apply each of them and confirm their expected output.  The valid chain
-# can then be used to generate an appropriate runtime method.
-#
-class TheoryChainValidator
-  
-  # TODO  Is 'potential_values' used?
-  # Returns the first runtime method that could be created with the implemented chains
-  # supplied.  This actually generates the runtime method to check the links of the chain
-  # are accurate - unlike the complete? check in chain instances.
-  #
-  def build(runtime_method,test_cases,theory_implementation_chains,potential_values=[])
-      validated_chains = []
-      theory_implementation_chains.each do |chain|
-        validate_next_chain_link(validated_chains,chain,runtime_method.copy,test_cases.copy,0)
-      end  
-      raise StandardError.new('Failed to generate a valid runtime method') if validated_chains.length == 0
-      
-      # Select the first chain and return the runtime method it generates
-      results =  build_method_from_chain(validated_chains.first,runtime_method.copy,test_cases.copy)
-      return results
-      
-  end 
-  
-  # Validates that the next link in the chain is consistent with the 
-  # theories expected result.  If it is then the next link is checked
-  # and so on.  if all the links are consistent then the chain is add
-  # to the validated chain array.
-  # 
-  def validate_next_chain_link(validated_chains,chain,runtime_method,test_cases,position)
-    
-    # Check that current link in the chain meets in dependencies 
-    # if its dependents are met it isn't suppose to work
-    unless chain[position].meets_dependencies?(runtime_method.copy,test_cases.copy)
-      return nil
-    end
-    
-    # Add the theories action to the chains runtime method and realise the runtime method
-    # TODO  This creates a new runtime method each time (so ignores what the previous theory did - BAD)
-    result = runtime_method.copy
-    unless chain[position].action.nil? 
-      begin
-        result = add_statement_to_method(test_cases,runtime_method.copy,chain[position].action)
-      rescue SyntaxError => e
-        StandardLogger.instance.warn e
-        return nil
-      rescue TypeError => e
-        StandardLogger.instance.warn e
-        return nil
-      end
-      
-    end
-    
-    # Now check that the runtime method with the theories action also responds
-    # as the theory said it would in the result.
-    if chain[position].results.all? {|x| x.validates?(result,test_cases)}
-      
-      # Has the chain been completed?
-      if (position+1) == chain.length
-        validated_chains << chain 
-        return
-      else
-        # Continue along the chain
-        validate_next_chain_link(validated_chains,chain,result,test_cases,(position+1))
-      end
-    else
-      # Theory was wrong
-      # chain[position].results.each do |x|
-        # unless x.validates?(result,test_cases)
-          # StandardLogger.instance.info('The following result failed to be met')
-          # StandardLogger.instance.info(x.write)
-        # end
-      # end
-      return nil
-    end    
-    
-  end
-  
-  # Builds the method using the chain without checking that the depenedents
-  # and results are accurate. 
-  #
-  def build_method_from_chain(chain,runtime_method,test_cases)
-    runtime_method = runtime_method.copy
-    chain.each do |link|
-      next if link.action.nil?
-      runtime_method = add_statement_to_method(test_cases,runtime_method,link.action)
-    end
-    return runtime_method
-  end
-  
-  def add_statement_to_method(test_cases,runtime_method,action)
-    evaluation_code = ''
-    # TODO  I don't think this line below is needed
-    evaluation_code += "test_cases = #{test_cases.write}"+"\n"
-    evaluation_code += "last_runtime_method = runtime_method.copy"+"\n"
-    evaluation_code += action.write+"\n"
-    evaluation_code += 'return runtime_method'+"\n"
-    eval evaluation_code    
-  rescue NoMethodError => e
-    return nil
-  end  
-  
-end

data/lib/theory/TheoryComponent.rb

@@ -1,59 +0,0 @@
-module TheoryComponent
-  include ActsAsCode
-  
-  attr_reader :theory_component_id
-  
-  # TODO  Complete hack for issue where component ids aren't unique - using marshal load
-  @@theory_component_id = 0
-  
-  def generate_theory_component_id
-    if @theory_component_id.nil?
-      @theory_component_id = @@theory_component_id
-      @@theory_component_id += 1
-    end
-  end
-  
-  # Returns all the theory vairables in this theory
-  # dependent. 
-  #
-  def theory_variables
-    return @statement.select_all {|x| x.kind_of?(TheoryVariable)}
-  end    
-  
-  def tokens
-    return @statement.tokens
-  end
-  
-  def statements_with_variable(variable_id)
-    
-    # Duplicate the current statement before it is rewritten
-    rewritten_statement = @statement.copy
-    
-    # Find all containers of VariableDeclarations that declare a TheoryVariable
-    containers = [rewritten_statement].select_all {|x| x.respond_to?(:has?)}
-    theory_variable_containers = containers.select {|x| x.has? {|y| y.kind_of?(TheoryVariable)}}
-    
-    results = theory_variable_containers.select do |x|
-      reg = eval '/var'+variable_id.to_s+'/'
-      x.write.match(reg)
-    end
-    return results
-    
-  end  
-  
-  # Returns an array of any of the accessors in the statement.  An accessor
-  # is the chain to access a property e.g. in the following statement =>
-  #
-  # var1[:params][var3].something(var6)
-  #
-  # it would return ["var1[:params][var3]","var6"]
-  #
-  # The needed when trying to determine intrinsic values.  So in this case 
-  # var1 couln't be a runtime_method instance becuase it doesn't use 
-  # the has key
-  #
-  def accessors
-    
-  end
-  
-end

data/lib/theory/TheoryConnector.rb

@@ -1,756 +0,0 @@
-
-# Instances are expected to connect any number of theories so 
-# that the chain finishes with a particular outcome.  
-#
-# e.g.  '<runtime_method>.all_pass?(<test_cases>) = true'
-#
-class TheoryConnector
-  
-  def initialize(potential_values)
-    @potential_values = potential_values
-  end
-  
-  # Attempts to chain the theories togeather so that the final theory
-  # results in the specified "finish".
-  #
-  # @param  runtime_method    This is an instance of the core runtime method
-  #                           instance that is populated with any number of statements.
-  # @param  test_cases        An array of test cases that contain the values for 
-  #                           runtime method's paramters and the expected return value
-  #                           given those parameters.
-  # @param  finish            A description of the desired final outcome - this will
-  #                           probably be
-  #                           '<runtime_method>.all_pass?(<test_cases>) = true'
-  # @param  theories          A array of theories to be chained togeather to result 
-  #                           in the finish outcome.   
-  #
-  # TODO Last runtime method dependencies can't be shared down the the theory chain 
-  # 
-  def chain(runtime_method,test_cases,finish,theories)
-    
-    return create_possible_chains(runtime_method,test_cases,finish,theories)
-    
-  end
-
-  # NOTE: Will probably replace the create_possible_chains and chain call  
-  # Returns an array of complete chains that conclude with a valid 
-  # runtime method.
-  #
-  def generate_chains(runtime_method,test_cases,theories,exclude=[])
-    
-    theories = remove_irrelevant_theories(theories)
-
-    # Create the inital chain (with the head and tail)
-    intial_chain = Chain.new
-    
-    # Find a theory that can act as the head
-    possible_head_theories = theories.select {|x| x.dependents.length == 0}
-    
-    # Create the initial chains
-    possible_chains = []
-    possible_head_theories.each do |x|
-      possible_chains += intial_chain.copy.extension_permutaions(x)
-    end
-        
-    # Check the initial chains incase they're complete
-    complete_chains = []
-    if possible_chains.any? {|x| x.complete? }
-      complete_chains += possible_chains.select {|x| x.complete?}
-      possible_chains.delete_if {|x| x.complete?}
-    end       
-    complete_chains = complete_chains.delete_if do |x|
-      exclude.any? {|y| y == x.theories_sequence}
-    end
-    unless complete_chains.empty? 
-      return complete_chains 
-    end
-    possible_chains.each do |chain|
-        
-      # Remove the head theory to avoid it being re-used
-      head_free_theories = theories.copy
-      head_free_theories.delete_if {|theory| theory.theory_id == chain.first.theory_id}      
-      complete_chains += complete_chain(chain,head_free_theories)
-    end
-    return complete_chains
-    
-  end
-  
-  def complete_chain(chain,theories)
-    res = catch(:complete) do
-      converge_chain(chain,theories)
-      #raise StandardError.new('Failed to generate a chain')
-      return []
-    end
-    return [res] 
-    
-  end
-  
-  def remove_existing_theories(chain,theories)
-    theories.delete_if do |theory|
-      chain.theories_sequence.include?(theory.theory_id)
-    end    
-  end
-  
-  def converge_chain(chain,theories,step=0)
-    
-    theories = remove_existing_theories(chain.copy,theories.copy)
-    
-    extended_chains = add_to_chain(chain.copy,theories.copy,step)
-    
-    if extended_chains.any? {|x| x.complete? }
-      res2 = extended_chains.select {|x| x.complete?}
-      raise StandardError.new('More than one complete chain found') if res2.length > 1
-      throw :complete, res2.first.freeze      
-    end
-    closer = closer_chains(chain.copy,extended_chains)
-
-    complete_chains = []
-    unless closer.empty?
-      closer.each do |x|
-        complete_chains += converge_chain(x,theories,step+1)
-      end
-    else 
-      extended_chains.each do |x|
-        complete_chains += converge_chain(x,theories,(step+1))
-      end
-    end
-    
-    return complete_chains
-  end
-  
-  def closer_chains(chain,chains)
-    closer_chains = []
-    chains.each do |x|
-      if ((chain.unmet_dependents_ids-x.unmet_dependents_ids).length == chain.unmet_dependents_ids.length)
-        closer_chains << x
-      end    
-    end    
-    return closer_chains
-  end
-  
-  def add_to_chain(chain,theories,step)
-    extended_chains = []
-    theories.each do |theory|
-      last_position = 1
-      chains = chain.add_link_to(theory,last_position,[])
-      
-      #chains = chain.extension_permutaions(theory,[])
-      next if chains.empty?
-      extended_chains += chains
-    end
-    return extended_chains    
-  end
-  
-  def extend_chain(chain,theories)
-    
-    complete_chains = []
-    theories.each do |x|
-      extended_chains = chain.copy.extension_permutaions(x)
-      next if extended_chains.empty?
-      
-      # Don't allow the same theory to be added twice - for now
-      updated_theories = theories.copy
-      updated_theories.delete_if {|theory| theory.theory_id == x.theory_id}
-      
-      complete_chains += extended_chains.select {|y| y.complete?}
-      extended_chains.delete_if {|y| y.complete?}
-      extended_chains.each do |y|
-        complete_chains += extend_chain(y,updated_theories)
-      end
-    end
-    return complete_chains
-  end
-
-  def remove_irrelevant_theories(theories)
-    theories.delete_if {|theory| theory.irrelevant? }
-  end
-
-  def create_possible_chains(runtime_method,test_cases,finish,theories)
-    
-    # Generate the head theory - this is the starting point and doesn't have any dependents
-    accessors, mapping = TheoryGenerator.new.generate_accessors_and_mapping(test_cases,runtime_method,7,0)
-    
-    # * Generate all the possible results of this runtime method
-    theory_results = TheoryGenerator.new.get_theory_results(accessors)
-
-    # * Create the actual head theory
-    head_theory = Theory.new([],nil,theory_results,runtime_method.copy)
-    
-    # Create the initial chain that needs to be connected
-    intial_chain = Chain.new
-    intial_chain.form_chain(head_theory,finish,mapping)
-    
-    return create_possible_chain_extensions(runtime_method,test_cases,finish,theories,intial_chain)
-  end
-
-  # This method has been created so the initial chain can be passed in to start the method
-  # creation.  Generating the initial chain can take a couple of minutes.
-  #
-  def create_possible_chain_extensions(runtime_method,test_cases,finish,theories,intial_chain)
-    
-    # Save any of the complete chains
-    possible_chains = []
-    
-    # Search through the available theories and find one that results in the finish
-    potential_final_theories = theories.select {|x| x.has_result_structure?(finish)}
-    
-    # Attempt to add the potential link to the end of the chain
-    partial_chains = [] 
-    potential_final_theories.each do |theory|
-      potential_chain = intial_chain.copy
-      # TODO  Maybe should be call add_link_to_tail - then check if it completes
-      if(potential_chain.add_link(theory))
-        # A new link has been added - does this complete the chain (tail -> head)
-        res = potential_chain.complete?
-        #if potential_chain.complete?
-        if res
-          possible_chains << potential_chain 
-        else
-          partial_chains << potential_chain
-        end
-      end
-      
-    end
-    
-    
-    # If there are any partial chains try to extend them with additional theories
-    # - partial chains were connect to the finish but not the head.
-    partial_chains.each do |partial_chain|
-      
-      # Select from the chain the dependents that haven't be met.
-      
-      # TODO  This looks very messy - 
-
-      # Take the first dependent attempt to add a theory to resolve it
-      # - NOTE: This theory may resolve other of the dependents
-      #until partial_chain.unmet_dependents.empty?
-      limit = 1
-      until partial_chain.unmet_dependents.empty? or limit == 0
-        
-        # Select the firs of the unment dependents
-        dependent = partial_chain.unmet_dependents.first
-        
-        # Search through the available theories for ones that match the dependent structure
-        # TODO  This should be empty for "ruby test/unit/theory/tc_theory_connector.rb --name test_chain_with_2_theories"
-        potential_theories = theories.select {|x| x.has_result_structure?(dependent) }
-        if potential_theories.length > 10
-          raise StandardError.new("Have not tested for #{potential_theories.length.to_s} potential theories" )
-        end
-        
-        # Attempt to add the theory to the partial chain (prefers the theories that complete)
-        potential_theories.each do |t|
-          updated_chain = partial_chain.copy
-          # TODO  Should create a quick way to switch input on and off while the script is running
-          if(updated_chain.add_link(t))
-            partial_chain = updated_chain
-            if updated_chain.complete?
-              possible_chains << updated_chain
-              break
-            else
-            end
-          else
-          end
-        end        
-        
-        limit -= 1
-      end
-      
-    end
-
-    # Return the complete chains 
-    return possible_chains    
-    
-  end
-  
-  # Returns a new chain so that they all use consistent theory variables ids
-  #
-  def unify_chain(chain)
-
-    # TODO  Break up this method and write tests for the individual parts
-
-    # Find all the ways the theory and results can connected
-    # - the same_structure? approach is quite loose
-    arrangements = chain_arrangements(chain.copy.reverse)
-    
-    # For each theory in the chain give each each variable a unique id
-    starting_id = 1
-    uniq_chain = chain.inject([]) do |total,x|
-      r = x.uniq_theory_variables(starting_id)
-      starting_id = r.highest_theory_variable_id+1
-      total << r
-      total
-    end
-    
-    # Identify the matching variables
-    mappings = matching_variables(arrangements,uniq_chain)
-    # TODO Why are so many of these identical
-    mappings.uniq!
-    
-    # Identify opposed mapping (variables that don't match in the context of the theory aren't equal)
-    false_mappings = {}
-    uniq_chain.each do |x|
-      r = x.all_theory_variables.collect {|x| x.theory_variable_id}
-      r.each do |y|
-        false_mappings[y] = r.copy.delete_if {|z| z == y}
-      end
-    end
-    
-    final_mapping = []
-    #mappings = [mappings.last]
-    
-    count = 0
-    mappings.each do |m|
-      count += 1
-      # Create an array of all variables that are equalivalent
-      master = combine_matches(m.to_a)
-      
-      # Check that the equivalent variables don't occur in the same theory
-      # TODO  If this never occurs I need to re-think things
-      catch :bad_map do 
-        false_mappings.each do |key,value|
-          
-          master.each do |x|
-            if x.include?(key)
-              if (x | value).length != x.length+value.length
-                throw :bad_map
-              end
-            end
-          end
-        end
-      
-       final_mapping << master.collect {|x| x.uniq}
-      end
-    end
-    
-    # Generate new chains using the final mappings
-    return [] if final_mapping.empty?
-    
-    #m = final_mapping.last
-    new_chains = []
-    final_mapping.each do |x|
-      
-      # Get the id of all the theory variables
-      all_theory_variable_ids = uniq_chain.collect {|y| y.all_theory_variables.collect {|z| z.theory_variable_id} }.flatten
-      
-      # Unique theory variables
-      uniq_variables = all_theory_variable_ids-x.flatten
-      unique_count = (all_theory_variable_ids-x.flatten).length + x.length
-      
-      # Prepare the mapping to match each id to a new variable
-      # (at this stage each of the mappings should be unique)
-      map = Mapping.new
-      unique_count.times do |k|
-        unless uniq_variables.empty?
-          #map << {uniq_variables.shift=>TheoryVariable.new(k)}
-          map[uniq_variables.shift] = TheoryVariable.new(k)
-          next
-        end
-        #t = m.shift
-        var = TheoryVariable.new(k)
-        #map += x.shift.collect {|u| {u=>var} }
-        x.shift.each do |j|
-          map[j] = var
-        end
-      end
-      
-      # Copy the the chain and update the mapping
-      new_chains << Chain.new(uniq_chain.collect {|y| y.copy.map_to(map)})
-      
-    end
-    return new_chains
-    
-  end
-  
-  # Returns an array of arrays containing matching ids
-  #
-  # matches e.g.  [[5,10],[11,17],[12,18],[1,6],[7,12],[13,5]]
-  #
-  def combine_matches(matches)
-    
-    results = []
-    until matches.empty?
-      start = matches.shift
-      
-      catch :no_change do
-        loop do  
-          initial_length = start.length
-          #removed = temp2.delete_if {|x| (x | start).length != start.length+x.length }
-          
-          # TODO  A delete command to that returns what you were deleting would be nice
-          index = matches.index {|x| (x | start).length != start.length+x.length }
-          if index.nil?
-            results << start
-            throw :no_change
-          end
-          b = matches.slice!(index)
-          start += b
-          start.uniq!
-        end
-        
-      end
-    end    
-    return results
-  end    
-  
-  # Returns an array that matches one variable to another indicating that
-  # they should be considered equal.
-  #
-  def matching_variables(arrangements,uniq_chain)
-    mappings = []
-    arrangements.each do |arrangement|
-      map = {}
-      arrangement.each do |theory|
-        
-        dependents = uniq_chain.inject([]) {|total,x| total += x.dependents} 
-        results = uniq_chain.inject([]) {|total,x| total += x.results}
-        
-        theory.each do |dependent_id,result_id|
-          
-          # Find the dependent with the matching id
-          dependent = dependents.detect() {|x| x.theory_component_id == dependent_id}
-          result = results.detect() {|x| x.theory_component_id == result_id}
-          
-          # Temporary check that everything is tickety boo
-          if result.theory_variables.length != dependent.theory_variables.length
-            raise StandardError.new('They should always have the same number of theory variables')
-          end
-          
-          # Go through each of the variables and match up the values
-          result.theory_variables.zip(dependent.theory_variables) do |x,y|
-            
-            if map.has_key?(x.theory_variable_id)
-            end
-            map[y.theory_variable_id] = x.theory_variable_id
-          
-          end            
-          
-        end
-        
-      end
-      mappings << map
-    end
-    return mappings
-  end    
-  
-  # Returns an array of all the ways the theory chain can be arranged
-  # So dependent A -> result B 
-  #
-  # @param  chain       An array containing all the theories in order
-  # 
-  def chain_arrangements(chain)
-    arrangements = []
-    next_link_arrangement(arrangements,[],chain)
-    return arrangements
-  end
-  
-  def next_link_arrangement(arrangements,arrangement,chain)
-    # Take out link and find the results that match its dependents
-    link = chain.pop
-    
-    # Stop if the all the links in the chain have been met (the last one has nothing left to be dependent on)
-    if chain.empty?
-      arrangements << arrangement
-      return
-    end    
-    
-    # TODO  Down the line I should see if Cauldron can tidy this up
-    
-    # Saves what dependent connects to what result
-    # e.g. connection = {16=>[26, 28], 17=>[26, 28]}
-    connection = {}
-    link.dependents.each do |dependent|
-
-      # Get all the results from the rest of the chain
-      results = chain.inject([]) {|total,x| total + x.results }
-      
-      # Go through the rest of the chain and find the results with the same structure
-      connection[dependent.theory_component_id] = results.select do |x| 
-        x.same_structure?(dependent)
-      end.collect {|x| x.theory_component_id}
-   
-    end
-    
-    # TODO  I need to re-do allot of the connecton stuff - I was using theories with arround 650 dependents and
-    #       it was generating an insane size of arrangements.  I think it is plausable to handle that size a theory
-    #       but I should re-do this bit.  
-    #
-    #       I may need to reduce the theories to only include the dependent/result arrangements that change after
-    #       the action is added.  
-    
-    # Calculate the total number of arrangements
-    total_arrangements = connection.values.collect {|x| x.length}.inject(1) {|total,y| total *= y}
-    
-    # TODO  Need to include an escape here if there are too many total_arrangements
-    
-    # TODO  The theory_generator is generating too many results and dependents.
-    
-    # Find the various arrangements for the results
-    # e.g. [[26,26],[26,28],[28,26],..]
-    # NOTE I get a RangeError: too big to product     with larger theories
-    connection_arrangements = connection.values.first.product(*connection.values[1..connection.values.length])
-    
-#    Alternative 
-#    NOTE: I've rewritten this because the code above generates an error for larger theories
-#    new_connection_arrangements = []
-#    extend_arrangement(new_connection_arrangements,connection.values)
-    
-    # Jump back to the clearer dependent -> result arrangement
-    # e.g. [{16=>26, 17=>26}, {16=>26, 17=>28}, {16=>28, 17=>26}, {16=>28, 17=>28}]
-    nice_connection_arrangements = connection_arrangements.collect do |x|
-      a = []
-      connection.keys.zip(x) do |dependent_id,result_id|
-        a << dependent_id
-        a << result_id
-      end
-      Hash[*a]
-    end
-
-    # For each arrangement continue to the next link
-    nice_connection_arrangements.each do |x|
-      # TODO  Maybe use a hash with the theory id in instead
-      a = arrangement.copy + [x]
-      next_link_arrangement(arrangements,a,chain.copy)
-    end      
-    
-  end
-  
-  def extend_arrangement(total,groups,group=[])
-    if groups.empty?
-      total << group
-      return
-    end
-    groups.shift.each do |x|
-      extend_arrangement(total,groups.copy,group.copy.push(x))
-    end
-  end
-  
-  # Returns all the implementation permutations for the theory.
-  def implement_chain(chain,mapping=Mapping.new)
-    
-    
-    # Implement the theory in all the permutations
-    # NOTE: Need to get the mapping during the implementation
-    link = chain.shift
-    
-    # TODO  Rewriting permutations takes quite long, I think it could be greatly reduced by 
-    #       stricting the posibilities by reviewing the dependents.  For example: 
-    #
-    #         if(var6.kind_of?(Fixnum))
-    #           return true
-    #         end
-    #
-    # TODO  I shouldn't treat the realisable fixnum variables as fair game.  They should only
-    #       TestCaseIndexFixnum and only available to things of that type. 
-    #
-    link_permutations = link.rewrite_permutations(@potential_values,mapping)
-    implemented_chains = []
-    link_permutations.each do |x|
-      implement_next_link(implemented_chains,chain.copy,[link],[x])
-    end
-    
-    return implemented_chains
-    
-  end    
-  
-  def implement_next_link(implemented_chains,chain,previous_chain,partial_implemented_chain)
-    if chain.empty?
-      implemented_chains << partial_implemented_chain
-      return
-    end
-    next_link = chain.shift
-    
-    # Create an hash to show how the results-dependents are linked.
-    # TODO  Because I am loading the theories from Marshal dumps I need to make sure they all have unique ids
-    results_to_dependents = {}
-    
-    dependent_mapping = conversion_mapping(partial_implemented_chain,previous_chain,next_link)
-
-    #    # Now implement the next theory using the mapping dependency already established.
-    dependent_mapping.each do |mapping|
-      
-      # NOTE: The mapping is only restricted between the dependent and result connection
-      implemented_links = next_link.rewrite_permutations(@potential_values,mapping)
-      
-      implemented_links.each do |x|
-        extended_implemented_chain = partial_implemented_chain.copy << x
-        previous_chain = previous_chain.copy << next_link
-        implement_next_link(implemented_chains,chain,previous_chain,extended_implemented_chain)
-      end    
-    end
-    
-  end
-  
-  # Returns a mapping hash that will describe how to implement the next theory
-  # so that it is compatiable with current chain.   
-  #
-  def conversion_mapping(implemented_chain,current_chain,next_theory)
-    
-    # Find all the permutations of theory dependents meet by the current chain.
-    
-    # For each dependent find all the current implementations that meet it
-    # e.g. {16=>[26, 28, 12], 17=>[26, 28, 12]}
-    # TODO  Should only include the most recent chain if the result contains a 
-    #       last_runtime_method variable.
-    results = current_chain.inject([]) {|total,x| total + x.results }
-    arrangements = next_theory.dependents.inject({}) do |total,dependent|
-      total[dependent.theory_component_id] = results.select do |x| 
-        x.same_structure?(dependent)
-      end.collect {|x| x.theory_component_id}
-      total
-    end
-  
-#    # ------------- Development Code -------------
-#    arrangements.each do |key,value|
-#      value.each do |x|
-#      end
-#    end
-    
-    # Get the various permutations of the dependent to result
-    result_values = arrangements.values
-#     http://www.ruby-doc.org/core/classes/Array.html#M000287    
-#     TODO  Need to check when there is only one dependent    
-#    [1,2].product()            #=> [[1],[2]]
-#    [1,2].product([])          #=> []    
-    
-    variations = result_values.first.product(*result_values[1..result_values.length])
-    # e.g. [[26, 26], [26, 28], [26, 12], [28, 26], [28, 28], [28, 12], [12, 26], [12, 28], [12, 12]]
-    # TODO  Maybe an array with the dependent id in would be more useful
-    #       e.g. [[16=>26,17=>26],[16=>26,17=>28],...
-    
-    # Need to find all the mappings that will still be consistent
-    potential_mappings = []
-    variations.each do |x|
-      
-      # Go through each dependent to result pair
-      catch :incompatiable do 
-        index = 0
-        mapping = Mapping.new
-
-        arrangements.each_key do |dependent_id|
-          
-          # ----------- Development ----------------
-          
-          # Find the implementation with this result
-          theory_result = results.detect {|y| y.theory_component_id == x[index]}
-          
-          # Find the dependent that will be mapped
-          theory_dependent = next_theory.dependents.detect {|y| y.theory_component_id == dependent_id}
-          
-          # Find the implementation that contains the selected result
-          # TODO  This approach implies that the same theory can be used twice in the chain.
-          # TODO  I could probably avoid allot of this by having implementation ids and including the 
-          #       mapping with the implementation's results
-          theory_implementation = implemented_chain.detect do |y| 
-            y.results.any? {|z| z.theory_component_id == x[index]}
-          end
-          
-          # Map the id of dependent to the real value used by the result
-          theory_result.theory_variables.zip(theory_dependent.theory_variables) do |z,y|
-            
-            if mapping.has_key?(y.theory_variable_id)
-              throw :incompatiable if mapping[y.theory_variable_id] != theory_implementation.mapping[z.theory_variable_id] 
-            end
-          
-            mapping[y.theory_variable_id] = theory_implementation.mapping[z.theory_variable_id]
-          end        
-          index += 1
-        end
-        potential_mappings << mapping
-      end        
-    end
-    
-    return potential_mappings
-    
-  end
-  
-  def find_theories_with_these_results(theories,results)
-     return theories.select do |theory|
-       results.all? {|x| theory.has_result_structure?(x)}
-     end
-  end
- 
-  # Find the theories that match any of the results. 
-  #
-  def find_the_theories_with_these_results(theories,results)
-  end
-  
-  # 
-  def add_link(complete_chains,chain,theories)
-    
-    last_theory = chain.last
-    
-    
-    # Find the theories that can meet last theories dependency
-    # TODO  Should this be looking for just one theory?  If more than one theory is
-    #       added they might not be compatible.
-    results = find_theories_with_these_results(theories,last_theory.dependents)
-    if results.empty?
-      complete_chains << chain
-      return
-    end
-
-    # Try to find any additional links to the new chain
-    results.each do |x|
-      extended_chain = chain.copy.push(x)
-      add_link(complete_chains,extended_chain,theories)
-    end
-    
-  end
-  
-  # Returns a number of updated mappings based on what if possible
-  # for the first theory and the current mapping for the end.
-  #  
-  def refine_initial_mapping(theory,mapping,runtime_method,test_cases)
-
-    # TEMP
-    # 1.  What theory variables don't have real values?
-    # 2.  What real values are available?
-    # 3.  For each real variable identify the theory variables it could be.
-    # 4.  Given the possibilities work out the permutations
-    
-    # Find the theory variable ids that don't have real values
-    var_ids = theory.dependents.inject([]){|total,x| total << x.theory_variables.collect {|z| z.theory_variable_id}}.flatten.uniq
-    unasigned_var_ids = var_ids-mapping.keys
-    
-    # Development
-    
-    # Find the available real values
-    available_real_values = @potential_values-mapping.values
-    
-    # Determine the mermutations of unassigned var ids to available real values.
-    # NOTE: I'm sure how efficient it is working out every permutation especially
-    #       when a dependent link "varA.kind_of?(Fixnum)" could narrow the 
-    #       combinations considerably.
-    value_permutations = available_real_values.permutation(unasigned_var_ids.length).to_a
-    var_value_permutations = value_permutations.inject([]) do |total,x|
-      r = []
-      x.zip(unasigned_var_ids) do |y,z|
-        r << z
-        r << y 
-      end
-      total << Mapping.new(Hash[*r])
-    end
-    
-    # = Remove any mapping permutaions that don't work =
-    passible_mappings = []
-    var_value_permutations.each_with_index do |possible_mapping,i|
-    
-      # Combine the possible mapping with current actual mapping
-      m = mapping.merge(possible_mapping)
-      
-      # Using this mapping go through each dependent and check it works
-      # (if it doesn't work then it's a none starter)      
-      # TODO  I don't really need to implement the full theory - just the dependents
-      implementation = theory.map_to(m)
-      
-      # Use each implementation and find the ones that work
-      next unless implementation.meets_dependencies?(runtime_method,test_cases)
-      passible_mappings << m
-      
-      
-    end
-    return passible_mappings
-      
-  end    
-  
-end