activefacts 0.8.8 → 0.8.9

data/examples/CQL/Orienteering.cql

@@ -54,7 +54,7 @@ Event Control has at most one Point Value;
 
 Event Scoring Method is where
 	Scoring Method is used for Course of Event,
-	Course of Event uses at most one Scoring Method;
+	Course of Event uses one Scoring Method;
 
 Map is identified by its ID;
 Club (as Owner) owns Map,
@@ -87,7 +87,7 @@ Series has one Series Name (as Name),
 
 Entry is identified by its ID where
 	Person entered Course of Event,
-	Person entered Event in at most one Course;
+	Person entered Event in one Course;
 Entry received at most one Score;
 Entry finished in at most one finish-Placing;
 

data/examples/CQL/OrienteeringER.cql

@@ -21,8 +21,8 @@ Series Name is written as String;
  * Entity Types
  */
 Club is where
-	Code is of the club called at most one Club Name,
-	the club called Club Name has at most one Code;
+	Code is of the club called one Club Name,
+	the club called Club Name has one Code;
 
 Map is where
 	map-Name having Accessibility belongs to Club;
@@ -35,7 +35,7 @@ Event is where
 	event-ID is Series Event called Event Name run by Club using Map on Date at Location;
 
 Event Control is where
-	Event includes Control which is worth at most one Point Value;
+	Event includes Control which is worth one Point Value;
 
 Event Course is where
 	Course is available at Event,
@@ -46,13 +46,13 @@ Event Course is where
  */
 each Club occurs at least one time in
 	event ID is Series Event called Event Name run by Club using Map on Date at Location;
-each Event Name occurs at most one time in
+each Event Name occurs one time in
 	event ID is Series Event called Event Name run by Club using Map on Date at Location;
 each Event occurs at least one time in
 	Event includes Control which is worth Point Value;
 each ID occurs one time in
 	event ID is Series Event called Event Name run by Club using Map on Date at Location;
-each Name occurs at most one time in
+each Name occurs one time in
 	map Name having Accessibility belongs to Club;
-each Series Event occurs at most one time in
+each Series Event occurs one time in
 	event ID is Series Event called Event Name run by Club using Map on Date at Location;

data/examples/CQL/SchoolActivities.cql

@@ -22,7 +22,7 @@ Student is enrolled in one School;
 
 Student Participation is where
 	Student represents School in Activity,
-	Student participates in Activity which is sanctioned by at most one School;
+	Student participates in Activity which is sanctioned by one School;
 
 /*
  * Constraints:

data/examples/CQL/ServiceDirector.cql

@@ -193,7 +193,7 @@ Service is identified by Vendor and Service Type where
 	Service is of one Service Type;
 
 Data Store File Host System is where
-	Data Store has at most one File Host System;
+	Data Store has one File Host System;
 Data Store File Host System has one Internal-Credential;
 
 Data Store Service is where
@@ -235,8 +235,8 @@ Switch is on private Network
 	if and only if
 	Data Store has Legacy Switch;
 Client has default Data Store
-	only if Data Store belongs to Client;
-Data Store has Tcp Proxy Network
+	only if Client uses Data Store;
+Tcp Proxy Network is in Data Store
 	only if Network is ip_single;
 Network uses Domain Name
 	only if Network is ip_single;

data/examples/CQL/Supervision.cql

@@ -29,9 +29,10 @@ CEO runs Company,
  * Constraints:
  */
 either Employee reports to Manager(1) or Employee is a Manager(2) that is a CEO that runs Company but not both;
-CEO runs Company
+Employee is a Manager that is a CEO that runs Company
 	if and only if
-	CEO is a kind of Manager that works for Company;
+	Employee works for Company;
+
 // This constraint cannot be expressed in NORMA until it adds explicit join paths:
 Employee(1) reports to Manager that is a kind of Employee(2) that works for Company
 	if and only if

data/examples/CQL/Tests.Test5.Load.cql

@@ -20,7 +20,7 @@ Event Date is identified by ymd where
 Party is identified by its Id [independent];
 
 Party Moniker is where
-	Party is called at most one Party Name;
+	Party is called one Party Name;
 Party Moniker has one Accuracy;
 
 Person is a kind of Party;

data/examples/CQL/WaiterTips.cql

@@ -19,7 +19,7 @@ Meal is identified by its Id;
 Waiter is identified by its Nr;
 
 WaiterTip is where
-	Waiter for serving Meal reported a tip of at most one Amount;
+	Waiter for serving Meal reported a tip of one Amount;
 
 Service is where
 	Waiter served Meal;

data/lib/activefacts/cql/FactTypes.treetop

@@ -49,6 +49,18 @@ module ActiveFacts
         }
       end
 
+      rule fact_clauses
+        fact_clause
+          ftail:( (',' / and ) s fact_clause s )*
+	{
+	  def ast
+            readings = fact_clause.ast
+            ftail.elements.each{|e| readings += e.fact_clause.ast }
+	    readings
+	  end
+	}
+      end
+
       rule returning_clause
         returning return (',' return)*
       end
@@ -212,10 +224,10 @@ module ActiveFacts
       end
 
       rule objectification_join
-        '(' s where s fact_clause s ')' s
+        '(' s where s facts:fact_clauses s ')' s
 	{
 	  def ast
-	    fact_clause.ast
+	    facts.ast
 	  end
 	}
       end

data/lib/activefacts/cql/compiler/constraint.rb

@@ -286,47 +286,76 @@ module ActiveFacts
         end
 
         def build_join_steps reading, constrained_rs, objectification_node = nil
-          role_sequence = nil
-          role_refs = []
+          join_roles = []
+          incidental_roles = []
           debug :join, "Creating join Role Sequence for #{reading.inspect} with #{reading.role_refs.size} role refs" do
+            objectification_step = nil
             reading.role_refs.each do |role_ref|
               # These role_refs are the Compiler::RoleRefs. These have associated Metamodel::RoleRefs,
-              # but we need new RoleRefs to attach to the join (and save any residual_adjectives)
+              # but we need to create JoinRoles for those roles.  # REVISIT: JoinRoles may need to save residual_adjectives
               binding = role_ref.binding
               role = role_ref.role || role_ref.role_ref.role
+              join_role = nil
 
               if (reading.fact_type.entity_type)
-                # This reading is of an objectified fact type. The second role ref is to a phantom role.
-                # We don't need join steps for roles that have only one role_ref (this one) in their binding
+                # This reading is of an objectified fact type.
+                # We need a join step from this role to the phantom role, but not
+                # for a role that has only one role_ref (this one) in their binding.
+                # Create the JoinNode and JoinRole in any case though.
                 refs_count = binding.refs.size
                 objectification_ref_count = 0
-                role_ref.objectification_join.each{|r| objectification_ref_count += r.role_refs.select{|rr| rr.binding.refs.size > 1}.size} if role_ref.objectification_join
+                if role_ref.objectification_join
+                  role_ref.objectification_join.each do |r|
+                    objectification_ref_count += r.role_refs.select{|rr| rr.binding.refs.size > 1}.size
+                  end
+                end
                 refs_count += objectification_ref_count
-                debug :join, "#{refs_count > 1 ? 'Creating' : 'Skipping'} Role Ref #{role_ref.inspect} (counts #{refs_count}/#{objectification_ref_count}) and objectification Join Step for #{role_ref.inspect}" do
-
-                  if (refs_count > 1)
-                    role_sequence ||= @constellation.RoleSequence(:new)
-                    role_refs <<
-                      @constellation.RoleRef(role_sequence, role_sequence.all_role_ref.size, :role => role, :join_node => binding.join_node)
-                    unless objectification_node
-                      # We need to create a JoinNode for this object, even though it has no RoleRefs
-                      # REVISIT: Or just complain and make the user show the objectification explicitly. Except that doesn't work, see Warehouse...
-                      raise "Can't join over fact type '#{reading.fact_type.default_reading}' because it's not objectified" unless reading.fact_type.entity_type
-                      join = binding.join_node.join
-                      debug :join, "Creating join node #{join.all_join_node.size} for #{reading.fact_type.entity_type.name} in objectification"
-                      objectification_node = @constellation.JoinNode(join, join.all_join_node.size, :concept => reading.fact_type.entity_type)
+
+                debug :join, "Creating Join Node #{role_ref.inspect} (counts #{refs_count}/#{objectification_ref_count}) and objectification Join Step for #{role_ref.inspect}" do
+
+                  raise "Internal error: Trying to add role of #{role.concept.name} to join node for #{binding.join_node.concept.name}" unless binding.join_node.concept == role.concept
+                  join_role = @constellation.JoinRole(binding.join_node, role)
+
+                  if (refs_count <= 1)   # Our work here is done if there are no other refs
+                    if objectification_step
+                      join_role.join_step = objectification_step
+                    else
+                      incidental_roles << join_role
                     end
-                    @constellation.RoleRef(role_sequence, 1, :role => role.implicit_fact_type.all_role.single, :join_node => objectification_node)
-                    js = @constellation.JoinStep(objectification_node, binding.join_node, :fact_type => role.implicit_fact_type)
-                    debug :join, "New Join Step #{js.describe}"
-                    role_sequence = nil # Make a new role sequence for the next role, if any
+                    next
+                  end
+
+                  join_roles << join_role
+                  unless objectification_node
+                    # This is an implicit objectification, just the FT reading, not ET(where ...reading...)
+                    # We need to create a JoinNode for this object, even though it has no RoleRefs
+                    join = binding.join_node.join
+                    debug :join, "Creating JN#{join.all_join_node.size} for #{reading.fact_type.entity_type.name} in objectification"
+                    objectification_node = @constellation.JoinNode(join, join.all_join_node.size, :concept => reading.fact_type.entity_type)
                   end
+                  raise "Internal error: Trying to add role of #{role.implicit_fact_type.all_role.single.concept.name} to join node for #{objectification_node.concept.name}" unless objectification_node.concept == role.implicit_fact_type.all_role.single.concept
+
+                  irole = role.implicit_fact_type.all_role.single
+                  raise "Internal error: Trying to add role of #{irole.concept.name} to join node for #{objectification_node.concept.name}" unless objectification_node.concept == irole.concept
+                  objectification_role = @constellation.JoinRole(objectification_node, role.implicit_fact_type.all_role.single)
+                  objectification_step = @constellation.JoinStep(objectification_role, join_role, :fact_type => role.implicit_fact_type)
+                  debug :join, "New #{objectification_step.describe}"
+                  debug :join, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{objectification_step.describe}" if incidental_roles.size > 0
+                  incidental_roles.each { |jr| jr.join_step = objectification_step }
+                  incidental_roles = []
+                  join_roles = []
                 end
               else
                 debug :join, "Creating Role Ref for #{role_ref.inspect}" do
-                  role_sequence ||= @constellation.RoleSequence(:new)
-                  role_refs <<
-                    @constellation.RoleRef(role_sequence, role_sequence.all_role_ref.size, :role => role, :join_node => binding.join_node)
+                    # REVISIT: If there's an implicit subtyping join here, create it; then always raise the error here.
+                    # I don't want to do this for now because the verbaliser will always verbalise all join steps.
+                  if binding.join_node.concept != role.concept and
+                    0 == (binding.join_node.concept.supertypes_transitive & role.concept.supertypes_transitive).size
+                    raise "Internal error: Trying to add role of #{role.concept.name} to join node for #{binding.join_node.concept.name} in '#{reading.fact_type.default_reading}'"
+                  end
+                  raise "Internal error: Trying to add role of #{role.concept.name} to join node for #{binding.join_node.concept.name}" unless binding.join_node.concept == role.concept
+                  join_role = @constellation.JoinRole(binding.join_node, role)
+                  join_roles << join_role
                 end
               end
 
@@ -343,21 +372,25 @@ module ActiveFacts
               end
               if (@common_bindings.include?(binding))
                 debug :join, "#{binding.inspect} is a constrained binding, add the Role Ref for #{role.concept.name}"
-                @constellation.RoleRef(constrained_rs, constrained_rs.all_role_ref.size, :role => role, :join_node => binding.join_node)
+                raise "Internal error: Trying to add role of #{role.concept.name} to join node for #{binding.join_node.concept.name}" unless binding.join_node.concept == role.concept
+                @constellation.RoleRef(constrained_rs, constrained_rs.all_role_ref.size, :role => role, :join_role => join_role)
               end
             end
           end
 
-          if role_sequence
+          if join_roles.size > 0
+            end_node = join_roles[-1].join_node
             if !reading.fact_type.entity_type and role = reading.fact_type.all_role.single
-              # REVISIT: It might prove to be evil to use the same JoinNode twice for the same JoinStep here... but I don't have a real 
-              role_refs <<
-                @constellation.RoleRef(role_sequence, role_sequence.all_role_ref.size, :role => role.implicit_fact_type.all_role.single, :join_node => role_sequence.all_role_ref.single.join_node)
+              # Don't give the ImplicitBoolean a join_node. We can live without one, for now.
+              # The Join Step will have a duplicate node, and the fact type will tell us what's happening
+              join_roles << join_roles[0]
             end
             # We aren't talking about objectification here, so there must be exactly two roles.
-            raise "REVISIT: Internal error constructing join for #{reading.inspect}" if role_sequence.all_role_ref.size != 2 && role_refs.size == 2
-            js = @constellation.JoinStep(role_refs[0].join_node, role_refs[1].join_node, :fact_type => reading.fact_type)
+            raise "REVISIT: Internal error constructing join for #{reading.inspect}" if join_roles.size != 2
+            js = @constellation.JoinStep(join_roles[0], join_roles[1], :fact_type => reading.fact_type)
             debug :join, "New Join Step #{js.describe}"
+            debug :join, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{js.describe}" if incidental_roles.size > 0
+            incidental_roles.each { |jr| jr.join_step = js }
           end
         end
 
@@ -378,15 +411,15 @@ module ActiveFacts
                 # Create a join with a join node for every binding:
                 join = build_join_nodes(readings_list)
 
-                join.role_sequence = @constellation.RoleSequence(:new)
+                role_sequence = @constellation.RoleSequence(:new)
                 debug :join, "Building join steps" do
                   readings_list.each do |reading|
-                    build_join_steps(reading, join.role_sequence)
+                    build_join_steps(reading, role_sequence)
                   end
                 end
                 join.validate
 
-                join.role_sequence
+                role_sequence
               end
             else
               # There's no join in this readings_list, just create a role_sequence

data/lib/activefacts/cql/compiler/fact.rb

@@ -15,12 +15,12 @@ module ActiveFacts
           @readings.each{ |reading| reading.identify_players_with_role_name(@context) }
           @readings.each{ |reading| reading.identify_other_players(@context) }
           @readings.each{ |reading| reading.bind_roles @context }
+          @readings.each{ |reading| reading.match_existing_fact_type @context }
 
           # Figure out the simple existential facts and find fact types:
-          @bound_instances = {}  # Instances indexed by binding
-          @bound_fact_types = []
           @bound_facts = []
-          @unbound_readings = @readings.
+          @ojr_by_role_ref = {}
+          @unbound_readings = all_readings.
             map do |reading|
               bind_literal_or_fact_type reading
             end.
@@ -43,90 +43,149 @@ module ActiveFacts
 
           # Any clause that has one binding and no other word is
           # either a value instance or a simply-identified entity.
-          reading.role_refs.map do |role_ref|
-            next role_ref unless l = role_ref.literal
+          reading.role_refs.each do |role_ref|
+            next unless l = role_ref.literal    # No literal
+            next if role_ref.binding.instance   # Already bound
             player = role_ref.binding.player
             # raise "A literal may not be an objectification" if role_ref.role_ref.objectification_join
             # raise "Not processing facts involving objectification joins yet" if role_ref.role_ref
             debug :instance, "Making #{player.class.basename} #{player.name} using #{l.inspect}" do
-              @bound_instances[role_ref.binding] =
-                instance_identified_by_literal player, l
+              role_ref.binding.instance = instance_identified_by_literal(player, l)
             end
             role_ref
           end
 
-          if reading.phrases.size == 1 && (role_ref = reading.phrases[0]).is_a?(Compiler::RoleRef)
-            # This is an existential fact (like "Name 'foo'", or "Company 'Microsoft'")
-            # @bound_instances[role_ref.binding]
-            nil # Nothing to see here, move along
+          if reading.phrases.size == 1 and (role_ref = reading.phrases[0]).is_a?(Compiler::RoleRef)
+            if role_ref.objectification_join
+              # Assign the objectified fact type as this reading's fact type?
+              reading.fact_type = role_ref.player.fact_type
+              reading
+            else
+              # This is an existential fact (like "Name 'foo'", or "Company 'Microsoft'")
+              nil # Nothing to see here, move along
+            end
           else
-            @bound_fact_types << reading.match_existing_fact_type(@context)
+            raise "Fact Type not found: '#{reading.display}'" unless reading.fact_type
+            # This instance will be associated with its binding by our caller
             reading
           end
         end
 
+        #
+        # Try to bind this reading, and return true if it can be completed
+        #
+        def bind_reading reading
+          return true if reading.fact
+
+          # Find the roles of this reading that do not yet have an instance
+          bare_roles = reading.role_refs.
+            select do |role_ref|
+              next false if role_ref.binding.instance
+              next false if role_ref.literal and
+                role_ref.binding.instance = instance_identified_by_literal(role_ref.binding.player, role_ref.literal)
+              true
+            end
+
+          debug :instance, "Considering '#{reading.display}' with "+
+            (bare_roles.empty? ? "no bare roles" : "bare roles: #{bare_roles.map{|role_ref| role_ref.player.name}*", "}") do
+
+            # If all the roles are in place, we can bind the rest of this reading:
+            return true if bare_roles.size == 0 && bind_complete_fact(reading)
+
+            progress = false
+            if bare_roles.size == 1 &&
+                (binding = bare_roles[0].binding) &&
+                (et = binding.player).is_a?(ActiveFacts::Metamodel::EntityType)
+              if et.preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type == reading.fact_type} &&
+                bind_entity_if_identifier_ready(reading, et, binding)
+                progress = true
+              end
+            end
+
+            return true if progress
+            debug :instance, "Can't make progress on '#{reading.display}'"
+            nil
+          end
+        end
+
         # Take one pass through the @unbound_readings, processing (and removing) any that have all pre-requisites
         def bind_more_facts
+          return false unless @unbound_readings.size > 0
           @pass += 1
 
           progress = false
           debug :instance, "Pass #{@pass} with #{@unbound_readings.size} readings to consider" do
-            @unbound_readings.map! do |reading|
-              # See if we can create the fact instance for this reading yet
-
-              # Find the roles of this reading that do not yet have an entry in @bound_instances:
-              bare_roles = reading.role_refs.
-                select do |role_ref|
-                  !role_ref.literal && !@bound_instances[role_ref.binding]
-                end
-
-              debug :instance, "Considering '#{reading.fact_type.preferred_reading.expand}' with bare roles: #{bare_roles.map{|role_ref| role_ref.player.name}*", "} "
-
-              if bare_roles.size == 0
-                reading = nil if bind_complete_fact reading
-              elsif bare_roles.size == 1 &&
-                  (binding = bare_roles[0].binding) &&
-                  (et = binding.player).is_a?(ActiveFacts::Metamodel::EntityType) &&
-                  et.preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type == reading.fact_type}
-
-                reading = nil if bind_entity_if_identifier_ready reading, et, binding
+            @unbound_readings =
+              @unbound_readings.select do |reading|
+                action = bind_reading(reading)
+                progress = true if action
+                !action
               end
-              progress = true unless reading
-              reading
-            end
-            @unbound_readings.compact!
+            debug :instance, "end of pass, unbound readings are #{@unbound_readings.map(&:display)*', '}"
           end # debug
           progress
         end
 
+        # Occasionally we need to search through all the readings:
+        def all_readings
+          @readings.map do |reading|
+            [reading] + reading.role_refs.map{|rr| rr.objectification_join}
+          end.flatten.compact
+        end
+
         def bind_complete_fact reading
-          debug :instance, "All bindings in '#{reading.fact_type.preferred_reading.expand}' contain instances; create the fact type"
-          instances = reading.role_refs.map{|rr| @bound_instances[rr.binding]}
+          return true unless reading.fact_type  # An bare objectification
+          debug :instance, "All bindings in '#{reading.display}' contain instances; create the fact type"
+          instances = reading.role_refs.map{|rr| rr.binding.instance}
           debug :instance, "Instances are #{instances.map{|i| "#{i.concept.name} #{i.value.inspect}"}*", "}"
 
-          # Check that this fact doesn't already exist
-          fact = reading.fact_type.all_fact.detect{|f|
-            # Get the role values of this fact in the order of the reading we just bound
-            role_values_in_reading_order = f.all_role_value.sort_by do |rv|
-              reading.reading.role_sequence.all_role_ref.detect{|rr| rr.role == rv.role}.ordinal
+          if e = reading.fact_type.entity_type and
+            reading.role_refs[0].binding.instance.concept == e
+            fact = reading.role_refs[0].binding.instance.fact
+          else
+            # Check that this fact doesn't already exist
+            fact = reading.fact_type.all_fact.detect do |f|
+              # Get the role values of this fact in the order of the reading we just bound
+              role_values_in_reading_order = f.all_role_value.sort_by do |rv|
+                debugger unless reading.reading
+                reading.reading.role_sequence.all_role_ref.detect{|rr| rr.role == rv.role}.ordinal
+              end
+              # If all this fact's role values are played by the bound instances, it's the same fact
+              !role_values_in_reading_order.zip(instances).detect{|rv, i| rv.instance != i }
             end
-            # If all this fact's role values are played by the bound instances, it's the same fact
-            !role_values_in_reading_order.zip(instances).detect{|rv, i| rv.instance != i }
-          }
-          unless fact
-            fact = @constellation.Fact(:new, :fact_type => reading.fact_type, :population => @population)
+          end
+          if fact
+            reading.fact = fact
+            debug :instance, "Found existing fact type instance"
+          else
+            fact =
+              reading.fact =
+              @constellation.Fact(:new, :fact_type => reading.fact_type, :population => @population)
             @bound_facts << fact
-            instance =
-              @constellation.Instance(:new, :concept => reading.fact_type.entity_type, :fact => fact, :population => @population)
-            @bound_facts << instance
-            reading.reading.role_sequence.all_role_ref.zip(instances).each do |rr, instance|
+
+            reading.reading.role_sequence.all_role_ref_in_order.zip(instances).each do |rr, instance|
               debug :instance, "New fact has #{instance.concept.name} role #{instance.value.inspect}"
               # REVISIT: Any residual adjectives after the fact type matching are lost here.
               @constellation.RoleValue(:fact => fact, :instance => instance, :role => rr.role, :population => @population)
             end
-          else
-            debug :instance, "Found existing fact type instance"
           end
+
+          if !fact.instance && reading.fact_type.entity_type
+            # Objectified fact type; create the instance
+            # Create the instance that objectifies this fact. We don't have the binding to assign it to though; that'll happen in our caller
+            debug :instance, "Objectifying fact as #{reading.fact_type.entity_type.name}"
+            instance =
+              @constellation.Instance(:new, :concept => reading.fact_type.entity_type, :fact => fact, :population => @population)
+            @bound_facts << instance
+          end
+
+          if reading.fact and
+            reading.objectified_as and
+            instance = reading.fact.instance and
+            instance.concept == reading.objectified_as.binding.player
+            reading.objectified_as.binding.instance = instance
+          end
+
           true
         end
 
@@ -136,7 +195,8 @@ module ActiveFacts
         def bind_entity_if_identifier_ready reading, entity_type, binding
           # Check this instance doesn't already exist already:
           identifying_binding = (reading.role_refs.map{|rr| rr.binding}-[binding])[0]
-          identifying_instance = @bound_instances[identifying_binding]
+          return false unless identifying_binding # This happens when we have a bare objectification
+          identifying_instance = identifying_binding.instance
           preferred_identifier = entity_type.preferred_identifier
 
           debug :instance, "This clause associates a new #{binding.player.name} with a #{identifying_binding.player.name}#{identifying_instance ? " which exists" : ""}"
@@ -155,7 +215,7 @@ module ActiveFacts
           if role_value
             instance = (role_value.fact.all_role_value.to_a-[role_value])[0].instance
             debug :instance, "Found an existing instance (of #{instance.concept.name}) from a previous definition"
-            @bound_instances[binding] = instance
+            binding.instance = instance
             return true  # Done with this reading
           end
 
@@ -164,29 +224,37 @@ module ActiveFacts
           # Then we have to create an instance of each fact
           identifiers =
             pi_role_refs.map do |rr|
-              fact_a = @readings.detect{|reading| rr.role.fact_type == reading.fact_type}
-              identifying_role_ref = fact_a.role_refs.select{|role_ref| role_ref.binding != binding}[0]
+              # Find a reading that provides the identifying_role_ref for this player:
+              identifying_reading = all_readings.detect do |reading|
+                rr.role.fact_type == reading.fact_type &&
+                  reading.role_refs.detect{|r1| r1.binding == binding}
+              end
+              return false unless identifying_reading
+              identifying_role_ref = identifying_reading.role_refs.select{|role_ref| role_ref.binding != binding}[0]
               identifying_binding = identifying_role_ref ? identifying_role_ref.binding : nil
-              identifying_instance = @bound_instances[identifying_binding]
+              identifying_instance = identifying_binding.instance
 
-              [rr, fact_a, identifying_binding, identifying_instance]
+              [rr, identifying_reading, identifying_binding, identifying_instance]
             end
           if identifiers.detect{ |i| !i[3] }  # Not all required facts are bound yet
             debug :instance, "Can't go through with creating #{binding.player.name}; not all the identifying facts are in"
             return false
           end
 
-          debug :instance, "Going ahead with creating #{binding.player.name} using #{identifiers.size} roles"
-          instance = @constellation.Instance(:new, :concept => entity_type, :population => @population)
-          @bound_instances[binding] = instance
-          @bound_facts << instance
-          identifiers.each do |rr, fact_a, identifying_binding, identifying_instance|
-            # This reading provides the identifying literal for the entity_type
-            id_fact = @constellation.Fact(:new, :fact_type => rr.role.fact_type, :population => @population)
-            @bound_facts << id_fact
-            role = (rr.role.fact_type.all_role.to_a-[rr.role])[0]
-            @constellation.RoleValue(:instance => instance, :fact => id_fact, :population => @population, :role => role)
-            @constellation.RoleValue(:instance => identifying_instance, :fact => id_fact, :role => rr.role, :population => @population)
+          debug :instance, "Going ahead with creating #{binding.player.name} using #{identifiers.size} roles" do
+            instance = @constellation.Instance(:new, :concept => entity_type, :population => @population)
+            binding.instance = instance
+            @bound_facts << instance
+            identifiers.each do |rr, identifying_reading, identifying_binding, identifying_instance|
+              # This reading provides the identifying literal for the entity_type
+              id_fact =
+                identifying_reading.fact =
+                @constellation.Fact(:new, :fact_type => rr.role.fact_type, :population => @population)
+              @bound_facts << id_fact
+              role = (rr.role.fact_type.all_role.to_a-[rr.role])[0]
+              @constellation.RoleValue(:instance => instance, :fact => id_fact, :population => @population, :role => role)
+              @constellation.RoleValue(:instance => identifying_instance, :fact => id_fact, :role => rr.role, :population => @population)
+            end
           end
 
           true  # Done with this reading
@@ -231,6 +299,7 @@ module ActiveFacts
             identifying_role_refs = concept.preferred_identifier.role_sequence.all_role_ref
             raise "Single literal cannot satisfy multiple identifying roles for #{concept.name}" if identifying_role_refs.size > 1
             role = identifying_role_refs.single.role
+            # This instance has no binding; the binding is of the entity type not the identifying value type
             identifying_instance = instance_identified_by_literal role.concept, literal
             existing_instance = nil
             instance_rv = identifying_instance.all_role_value.detect { |rv|
@@ -244,8 +313,10 @@ module ActiveFacts
               instance = existing_instance
               debug :instance, "This #{concept.name} entity already exists"
             else
+              # This fact has no reading.
               fact = @constellation.Fact(:new, :fact_type => role.fact_type, :population => @population)
               @bound_facts << fact
+              # This instance will be associated with its binding by our caller
               instance = @constellation.Instance(:new, :concept => concept, :population => @population)
               @bound_facts << instance
               # The identifying fact type has two roles; create both role instances:
@@ -263,7 +334,7 @@ module ActiveFacts
               map do |reading|
                 reading.role_refs.
                   select do |rr|
-                    !@bound_instances[rr.binding]
+                    !rr.binding.instance
                   end.
                   map do |role_ref|
                     role_ref.binding