activefacts 1.0.2 → 1.1.0

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

@@ -105,13 +105,13 @@ module ActiveFacts
 
         def loose_bind_wherever_possible
           # Apply loose binding over applicable roles:
-          debug :binding, "Loose binding on #{self.class.name}" do
+          trace :binding, "Loose binding on #{self.class.name}" do
             @clauses_lists.each do |clauses_list|
               clauses_list.each do |clause|
                 clause.refs.each_with_index do |ref, i|
                   next if ref.binding.refs.size > 1
 #                  if clause.side_effects && !clause.side_effects.role_side_effects[i].residual_adjectives
-#                    debug :binding, "Discounting #{ref.inspect} as needing loose binding because it has no residual_adjectives"
+#                    trace :binding, "Discounting #{ref.inspect} as needing loose binding because it has no residual_adjectives"
 #                    next
 #                  end
                   # This ref didn't match any other ref. Have a scout around for a suitable partner
@@ -128,7 +128,7 @@ module ActiveFacts
                         }
                     end.map{|k,b| b}
                   next if candidates.size != 1  # Fail
-                  debug :binding, "Loose binding #{ref.inspect} to #{candidates[0].inspect}"
+                  trace :binding, "Loose binding #{ref.inspect} to #{candidates[0].inspect}"
                   ref.rebind_to(@context, candidates[0].refs[0])
                 end
               end
@@ -138,15 +138,15 @@ module ActiveFacts
 
         def loose_bind
           # Apply loose binding over applicable @roles:
-          debug :binding, "Check for loose bindings on #{@roles.size} roles in #{self.class.name}" do
+          trace :binding, "Check for loose bindings on #{@roles.size} roles in #{self.class.name}" do
             @roles.each do |ref|
               if ref.binding.refs.size < @clauses_lists.size+1
-                debug :binding, "Insufficient bindings for #{ref.inspect} (#{ref.binding.refs.size}, expected #{@clauses_lists.size+1}), attempting loose binding" do
+                trace :binding, "Insufficient bindings for #{ref.inspect} (#{ref.binding.refs.size}, expected #{@clauses_lists.size+1}), attempting loose binding" do
                   @clauses_lists.each do |clauses_list|
                     candidates = []
                     next if clauses_list.
                       detect do |clause|
-                        debug :binding, "Checking #{clause.inspect}"
+                        trace :binding, "Checking #{clause.inspect}"
                         clause.refs.
                           detect do |vr|
                             already_bound = vr.binding == ref.binding
@@ -156,10 +156,10 @@ module ActiveFacts
                             already_bound
                           end
                       end
-                    debug :binding, "Attempting loose binding for #{ref.inspect} in #{clauses_list.inspect}, from the following candidates: #{candidates.inspect}"
+                    trace :binding, "Attempting loose binding for #{ref.inspect} in #{clauses_list.inspect}, from the following candidates: #{candidates.inspect}"
 
                     if candidates.size == 1
-                      debug :binding, "Rebinding #{candidates[0].inspect} to #{ref.inspect}"
+                      trace :binding, "Rebinding #{candidates[0].inspect} to #{ref.inspect}"
                       candidates[0].rebind_to(@context, ref)
                     end
                   end
@@ -226,7 +226,7 @@ module ActiveFacts
               :is_mandatory => @quantifier.min && @quantifier.min > 0
             )
           @enforcement.compile(@constellation, @constraint) if @enforcement
-	  debug :constraint, "Made new PC GUID=#{@constraint.concept.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{role_sequence.describe}"
+	  trace :constraint, "Made new PC GUID=#{@constraint.concept.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{role_sequence.describe}"
           super
         end
 
@@ -244,7 +244,7 @@ module ActiveFacts
                   clause.refs.select{ |vr| vr.player == ref.player }
                 end.flatten
               if candidates.size == 1
-                debug :binding, "Rebinding #{ref.inspect} to #{candidates[0].inspect} in presence constraint"
+                trace :binding, "Rebinding #{ref.inspect} to #{candidates[0].inspect} in presence constraint"
                 ref.rebind_to(@context, candidates[0])
               end
             end
@@ -276,8 +276,8 @@ module ActiveFacts
 		clause.includes_literals
 	      end
 
-              debug :query, "Building query for #{clauses_list.inspect}" do
-                debug :query, "Constrained bindings are #{@common_bindings.inspect}"
+              trace :query, "Building query for #{clauses_list.inspect}" do
+                trace :query, "Constrained bindings are #{@common_bindings.inspect}"
                 # Every Binding in these clauses becomes a Variable,
                 # and every clause becomes a Step (and a RoleSequence).
                 # The returned RoleSequences contains the RoleRefs for the common_bindings.
@@ -301,7 +301,7 @@ module ActiveFacts
               role_sequence = @constellation.RoleSequence(:new)
               query_bindings = bindings-@common_bindings
               unless query_bindings.empty? or ignore_trailing_steps && query_bindings.size <= 1
-                debug :constraint, "REVISIT: #{self.class}: Ignoring query from #{@common_bindings.inspect} to #{query_bindings.inspect} in #{clauses_list.inspect}"
+                trace :constraint, "REVISIT: #{self.class}: Ignoring query from #{@common_bindings.inspect} to #{query_bindings.inspect} in #{clauses_list.inspect}"
               end
               @common_bindings.each do |binding|
                 roles = clauses_list.
@@ -483,7 +483,7 @@ module ActiveFacts
               :ring_type => ring_type
             )
 
-          debug :constraint, "Added #{@constraint.verbalise}"
+          trace :constraint, "Added #{@constraint.verbalise}"
           super
         end
 

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

@@ -122,7 +122,7 @@ module ActiveFacts
           if (pc)
             pc.is_preferred_identifier = true
             pc.name = "#{@entity_type.name}PK" unless pc.name
-            debug "Existing PC #{pc.verbalise} is now PK for #{@entity_type.name}"
+            trace "Existing PC #{pc.verbalise} is now PK for #{@entity_type.name}"
           else
             # Add a unique constraint over all identifying roles
             pc = @constellation.PresenceConstraint(
@@ -135,7 +135,7 @@ module ActiveFacts
                 #:is_mandatory => true,
                 #:min_frequency => 1,
               )
-	    debug :constraint, "Made new preferred PC GUID=#{pc.concept.guid} min=nil max=1 over #{role_sequence.describe}"
+	    trace :constraint, "Made new preferred PC GUID=#{pc.concept.guid} min=nil max=1 over #{role_sequence.describe}"
           end
         end
 
@@ -183,7 +183,7 @@ module ActiveFacts
 
           operation = any_matched ? 'Objectifying' : 'Creating'
           player_names = clauses[0].refs.map{|vr| vr.key.compact*'-'}
-          debug :matching, "#{operation} fact type for #{clauses.size} clauses over (#{player_names*', '})" do
+          trace :matching, "#{operation} fact type for #{clauses.size} clauses over (#{player_names*', '})" do
             if any_matched  # There's an existing fact type we must be objectifying
               fact_type = objectify_existing_fact_type(existing_clauses[0].fact_type)
             end
@@ -220,7 +220,7 @@ module ActiveFacts
               :is_preferred_identifier => false,  # We only get here when there is a reference mode on the entity type
               :max_frequency => 1
             )
-	    debug :constraint, "Made new objectification PC GUID=#{pc.concept.guid} min=nil max=1 over #{fact_type.preferred_reading.role_sequence.describe}"
+	    trace :constraint, "Made new objectification PC GUID=#{pc.concept.guid} min=nil max=1 over #{fact_type.preferred_reading.role_sequence.describe}"
           end
 
           @fact_type = @entity_type.fact_type = fact_type
@@ -229,7 +229,7 @@ module ActiveFacts
         end
 
         def add_supertype(supertype_name, not_identifying)
-          debug :supertype, "Adding #{not_identifying ? '' : 'identifying '}supertype #{supertype_name} to #{@entity_type.name}" do
+          trace :supertype, "Adding #{not_identifying ? '' : 'identifying '}supertype #{supertype_name} to #{@entity_type.name}" do
             supertype = @vocabulary.valid_entity_type_name(supertype_name) ||
 	      @constellation.EntityType(@vocabulary, supertype_name, :concept => :new) # Should always already exist
 
@@ -275,7 +275,7 @@ module ActiveFacts
             pc1.min_frequency = 1
             pc1.max_frequency = 1
             pc1.is_preferred_identifier = false
-	    debug :constraint, "Made new subtype PC GUID=#{pc1.concept.guid} min=1 max=1 over #{p1rs.describe}"
+	    trace :constraint, "Made new subtype PC GUID=#{pc1.concept.guid} min=1 max=1 over #{p1rs.describe}"
 
             p2rs = @constellation.RoleSequence(:new)
             constellation.RoleRef(p2rs, 0).role = super_role
@@ -287,15 +287,15 @@ module ActiveFacts
             pc2.max_frequency = 1
             # The supertype role often identifies the subtype:
             pc2.is_preferred_identifier = inheritance_fact.provides_identification
-	    debug :supertype, "identification of #{@entity_type.name} via supertype #{supertype.name} was #{inheritance_fact.provides_identification ? '' : 'not '}added"
-	    debug :constraint, "Made new supertype PC GUID=#{pc2.concept.guid} min=1 max=1 over #{p2rs.describe}"
+	    trace :supertype, "identification of #{@entity_type.name} via supertype #{supertype.name} was #{inheritance_fact.provides_identification ? '' : 'not '}added"
+	    trace :constraint, "Made new supertype PC GUID=#{pc2.concept.guid} min=1 max=1 over #{p2rs.describe}"
           end
         end
 
         def make_entity_type_refmode_valuetypes(name, mode, parameters)
           vt_name = "#{name}#{mode}"
           vt = nil
-          debug :entity, "Preparing value type #{vt_name} for reference mode" do
+          trace :entity, "Preparing value type #{vt_name} for reference mode" do
             # Find an existing ValueType called 'vt_name' or 'name vtname'
 	    # or find/create the supertype '#{mode}' and the subtype
             unless vt = @vocabulary.valid_object_type_name(vt_name) or
@@ -309,7 +309,7 @@ module ActiveFacts
                 vt.scale = scale if scale
               end
             else
-              debug :entity, "Value type #{vt_name} already exists"
+              trace :entity, "Value type #{vt_name} already exists"
             end
           end
 
@@ -363,9 +363,9 @@ module ActiveFacts
           end
           if rs01.all_reading.empty?
             @constellation.Reading(fact_type, fact_type.all_reading.size, :role_sequence => rs01, :text => "{0} has {1}", :is_negative => false)
-            debug :mode, "Creating new forward reading '#{entity_role.object_type.name} has #{identifying_type.name}'"
+            trace :mode, "Creating new forward reading '#{entity_role.object_type.name} has #{identifying_type.name}'"
           else
-            debug :mode, "Using existing forward reading"
+            trace :mode, "Using existing forward reading"
           end
 
           # Make a reverse reading if none exists
@@ -377,20 +377,20 @@ module ActiveFacts
           end
           if rs10.all_reading.empty?
             @constellation.Reading(fact_type, fact_type.all_reading.size, :role_sequence => rs10, :text => "{0} is of {1}", :is_negative => false)
-            debug :mode, "Creating new reverse reading '#{identifying_type.name} is of #{entity_role.object_type.name}'"
+            trace :mode, "Creating new reverse reading '#{identifying_type.name} is of #{entity_role.object_type.name}'"
           else
-            debug :mode, "Using existing reverse reading"
+            trace :mode, "Using existing reverse reading"
           end
 
           # Entity must have one identifying instance. Find or create the role sequence, then create a PC if necessary
           rs0 = entity_role.all_role_ref.select{|rr| rr.role_sequence.all_role_ref.size == 1}[0]
           if rs0
             rs0 = rs0.role_sequence
-            debug :mode, "Using existing EntityType role sequence"
+            trace :mode, "Using existing EntityType role sequence"
           else
             rs0 = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs0, 0, :role => entity_role)
-            debug :mode, "Creating new EntityType role sequence"
+            trace :mode, "Creating new EntityType role sequence"
           end
           if (rs0.all_presence_constraint.size == 0)
             constraint = @constellation.PresenceConstraint(
@@ -403,22 +403,22 @@ module ActiveFacts
               :is_preferred_identifier => false,
               :is_mandatory => true
             )
-	    debug :constraint, "Made new refmode PC GUID=#{constraint.concept.guid} min=1 max=1 over #{rs0.describe}"
+	    trace :constraint, "Made new refmode PC GUID=#{constraint.concept.guid} min=1 max=1 over #{rs0.describe}"
           else
-            debug :mode, "Using existing EntityType PresenceConstraint"
+            trace :mode, "Using existing EntityType PresenceConstraint"
           end
 
           # Value Type must have a value type. Find or create the role sequence, then create a PC if necessary
-          debug :mode, "identifying_role has #{identifying_role.all_role_ref.size} attached sequences"
-          debug :mode, "identifying_role has #{identifying_role.all_role_ref.select{|rr| rr.role_sequence.all_role_ref.size == 1}.size} unary sequences"
+          trace :mode, "identifying_role has #{identifying_role.all_role_ref.size} attached sequences"
+          trace :mode, "identifying_role has #{identifying_role.all_role_ref.select{|rr| rr.role_sequence.all_role_ref.size == 1}.size} unary sequences"
           rs1 = identifying_role.all_role_ref.select{|rr| rr.role_sequence.all_role_ref.size == 1 ? rr.role_sequence : nil }.compact[0]
           if (!rs1)
             rs1 = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs1, 0, :role => identifying_role)
-            debug :mode, "Creating new ValueType role sequence"
+            trace :mode, "Creating new ValueType role sequence"
           else
             rs1 = rs1.role_sequence
-            debug :mode, "Using existing ValueType role sequence"
+            trace :mode, "Using existing ValueType role sequence"
           end
           if (rs1.all_presence_constraint.size == 0)
             constraint = @constellation.PresenceConstraint(
@@ -431,9 +431,9 @@ module ActiveFacts
               :is_preferred_identifier => true,
               :is_mandatory => false
             )
-	    debug :constraint, "Made new refmode ValueType PC GUID=#{constraint.concept.guid} min=0 max=1 over #{rs1.describe}"
+	    trace :constraint, "Made new refmode ValueType PC GUID=#{constraint.concept.guid} min=0 max=1 over #{rs1.describe}"
           else
-            debug :mode, "Marking existing ValueType PresenceConstraint as preferred"
+            trace :mode, "Marking existing ValueType PresenceConstraint as preferred"
             rs1.all_presence_constraint.single.is_preferred_identifier = true
           end
         end

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

@@ -53,7 +53,7 @@ module ActiveFacts
             player = ref.binding.player
             # raise "A literal may not be an objectification" if ref.role_ref.nested_clauses
             # raise "Not processing facts involving nested clauses yet" if ref.role_ref
-            debug :instance, "Making #{player.class.basename} #{player.name} using #{l.inspect}" do
+            trace :instance, "Making #{player.class.basename} #{player.name} using #{l.inspect}" do
               ref.binding.instance = instance_identified_by_literal(player, l)
             end
             ref
@@ -84,13 +84,15 @@ module ActiveFacts
           # Find the roles of this clause that do not yet have an instance
           bare_roles = clause.refs.
             select do |ref|
-              next false if ref.binding.instance
-              next false if ref.literal and
+	      if !ref.binding.instance and ref.literal
                 ref.binding.instance = instance_identified_by_literal(ref.binding.player, ref.literal)
+	      end
+
+              next false if ref.binding.instance
               true
             end
 
-          debug :instance, "Considering '#{clause.display}' with "+
+          trace :instance, "Considering '#{clause.display}' with "+
             (bare_roles.empty? ? "no bare roles" : "bare roles: #{bare_roles.map{|ref| ref.player.name}*", "}") do
 
             # If all the roles are in place, we can bind the rest of this clause:
@@ -107,7 +109,7 @@ module ActiveFacts
             end
 
             return true if progress
-            debug :instance, "Can't make progress on '#{clause.display}'"
+            trace :instance, "Can't make progress on '#{clause.display}'"
             nil
           end
         end
@@ -118,14 +120,14 @@ module ActiveFacts
           @pass += 1
 
           progress = false
-          debug :instance, "Pass #{@pass} with #{@unbound_clauses.size} clauses to consider" do
+          trace :instance, "Pass #{@pass} with #{@unbound_clauses.size} clauses to consider" do
             @unbound_clauses =
               @unbound_clauses.select do |clause|
                 action = bind_clause(clause)
                 progress = true if action
                 !action
               end
-            debug :instance, "end of pass, unbound clauses are #{@unbound_clauses.map(&:display)*', '}"
+            trace :instance, "end of pass, unbound clauses are #{@unbound_clauses.map(&:display)*', '}"
           end # debug
           progress
         end
@@ -139,35 +141,39 @@ module ActiveFacts
 
         def bind_complete_fact clause
           return true unless clause.fact_type  # An bare objectification
-          debug :instance, "All bindings in '#{clause.display}' contain instances; create the fact type"
-          instances = clause.refs.map{|vr| vr.binding.instance}
-          debug :instance, "Instances are #{instances.map{|i| "#{i.object_type.name} #{i.value.inspect}"}*", "}"
+          trace :instance, "All bindings in '#{clause.display}' contain instances; assert the fact type"
+          instances = clause.refs.map{|vr| vr.binding.instance }
+          trace :instance, "Instances are #{instances.map{|i| "#{i.verbalise}"}*", "}"
 
           if e = clause.fact_type.entity_type and
             clause.refs[0].binding.instance.object_type == e
             fact = clause.refs[0].binding.instance.fact
           else
             # Check that this fact doesn't already exist
+	    trace :instance, "Searching for existing fact instance"
+
             fact = clause.fact_type.all_fact.detect do |f|
+
               # Get the role values of this fact in the order of the clause we just bound
               role_values_in_clause_order = f.all_role_value.sort_by do |rv|
                 clause.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_clause_order.zip(instances).detect{|rv, i| rv.instance != i }
             end
           end
           if fact
             clause.fact = fact
-            debug :instance, "Found existing fact type instance"
+            trace :instance, "Found existing fact"
           else
+            trace :instance, "Creating new fact of type #{clause.fact_type.default_reading}"
             fact =
               clause.fact =
               @constellation.Fact(:new, :fact_type => clause.fact_type, :population => @population)
             @bound_facts << fact
-
             clause.reading.role_sequence.all_role_ref_in_order.zip(instances).each do |rr, instance|
-              debug :instance, "New fact has #{instance.object_type.name} role #{instance.value.inspect}"
+              trace :instance, "Assigning fact role #{instance.object_type.name} to #{instance.value ? instance.value.inspect : instance.verbalise}"
               # REVISIT: Any residual adjectives after the fact type matching are lost here.
               @constellation.RoleValue(:fact => fact, :instance => instance, :role => rr.role, :population => @population)
             end
@@ -176,7 +182,7 @@ module ActiveFacts
           if !fact.instance && clause.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 #{clause.fact_type.entity_type.name}"
+            trace :instance, "Objectifying fact as #{clause.fact_type.entity_type.name}"
             instance =
               @constellation.Instance(:new, :object_type => clause.fact_type.entity_type, :fact => fact, :population => @population)
             @bound_facts << instance
@@ -202,14 +208,14 @@ module ActiveFacts
           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" : ""}"
+          trace :instance, "This clause associates a new #{binding.player.name} with a #{identifying_binding.player.name}#{identifying_instance ? " which exists" : ""}"
 
           identifying_role_ref = preferred_identifier.role_sequence.all_role_ref.detect { |rr|
               rr.role.fact_type == clause.fact_type && rr.role.object_type == identifying_binding.player
             }
           unless identifying_role_ref
             # This shold never happen; we already bound all refs
-            debug :instance, "Failed to find a #{identifying_instance.object_type.name}"
+            trace :instance, "Failed to find a #{identifying_instance.object_type.name}"
             return false # We can't do this yet
           end
           role_value = identifying_instance.all_role_value.detect do |rv|
@@ -217,7 +223,7 @@ module ActiveFacts
           end
           if role_value
             instance = (role_value.fact.all_role_value.to_a-[role_value])[0].instance
-            debug :instance, "Found an existing instance (of #{instance.object_type.name}) from a previous definition"
+            trace :instance, "Found an existing instance (of #{instance.object_type.name}) from a previous definition"
             binding.instance = instance
             return true  # Done with this clause
           end
@@ -240,16 +246,17 @@ module ActiveFacts
               [rr, identifying_clause, 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"
+            trace :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" do
+          trace :instance, "Creating Entity #{binding.player.name} using #{identifiers.size} roles" do
             instance = @constellation.Instance(:new, :object_type => entity_type, :population => @population)
             binding.instance = instance
             @bound_facts << instance
             identifiers.each do |rr, identifying_clause, identifying_binding, identifying_instance|
               # This clause provides the identifying literal for the entity_type
+	      trace :instance, "Creating existential fact #{rr.role.fact_type.default_reading} for value #{identifying_instance.value.inspect}"
               id_fact =
                 identifying_clause.fact =
                 @constellation.Fact(:new, :fact_type => rr.role.fact_type, :population => @population)
@@ -267,21 +274,25 @@ module ActiveFacts
           if object_type.is_a?(ActiveFacts::Metamodel::EntityType)
             entity_identified_by_literal object_type, literal
           else
-            debug :instance, "Making ValueType #{object_type.name} #{literal.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}" do
-
+            trace :instance, "Assert Value #{object_type.name} #{literal.inspect}" do
               is_literal_string = literal.literal.is_a?(String)
-              instance = @constellation.Instance.detect do |key, i|
+	      # REVISIT: Check for subtypes and supertypes also, and promote type if necessary
+	      instance = object_type.all_instance.detect do |i|
+              #instance = @constellation.Instance.detect do |key, i|
                   # REVISIT: And same unit
+		  trace :instance, "Comparing #{i.value.literal.inspect} to #{literal.literal.inspect}"
                   i.population == @population &&
                     i.value &&
-                    i.value.literal == literal &&
+                    i.value.literal.inspect == literal.literal.inspect &&
                     i.value.is_literal_string == is_literal_string
                 end
               #instance = object_type.all_instance.detect { |instance|
               #  instance.population == @population && instance.value == literal
               #}
-              debug :instance, "This #{object_type.name} value already exists" if instance
-              unless instance
+	      if instance
+		trace :instance, "This #{object_type.name} value already exists"
+              else
+		trace :instance, "Creating Value #{object_type.name} #{literal.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
                 instance = @constellation.Instance(:new)
                 instance.object_type = object_type
                 instance.population = @population
@@ -296,7 +307,7 @@ module ActiveFacts
         def entity_identified_by_literal object_type, literal
           # A literal that identifies an entity type means the entity type has only one identifying role
           # That role is played either by a value type, or by another similarly single-identified entity type
-          debug "Making EntityType #{object_type.name} identified by '#{literal}' #{@population.name.size>0 ? " in "+@population.name.inspect : ''}" do
+          trace :instance, "Assert Entity #{object_type.name} identified by '#{literal}'" do
             identifying_role_refs = object_type.preferred_identifier.role_sequence.all_role_ref
             raise "Single literal cannot satisfy multiple identifying roles for #{object_type.name}" if identifying_role_refs.size > 1
             role = identifying_role_refs.single.role
@@ -312,13 +323,15 @@ module ActiveFacts
             }
             if instance_rv
               instance = existing_instance
-              debug :instance, "This #{object_type.name} entity already exists"
+              trace :instance, "This #{object_type.name} entity already exists"
             else
               # This fact has no clause.
+	      trace :instance, "Creating implicit existential fact #{role.fact_type.default_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, :object_type => object_type, :population => @population)
+	      trace :instance, "Creating Entity #{object_type.name} identified by '#{literal}' #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
               @bound_facts << instance
               # The identifying fact type has two roles; create both role instances:
               @constellation.RoleValue(:instance => identifying_instance, :fact => fact, :population => @population, :role => role)