activefacts 0.8.16 → 0.8.18

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

@@ -28,7 +28,7 @@ module ActiveFacts
               :context_note_kind => @context_kind,
               :discussion => @discussion
             )
-          context_note.concept = target
+          context_note.relevant_concept = target
           if @agreed_date || @agreed_agents
             agreement = constellation.Agreement(context_note)
             agreement.date = @agreed_date if @agreed_date
@@ -74,6 +74,7 @@ module ActiveFacts
             clauses_list.each do |clause| 
               fact_type = clause.match_existing_fact_type @context
               raise "Unrecognised fact type #{clause.inspect} in #{self.class}" unless fact_type
+              raise "Negated fact type #{clause.inspect} in #{self.class} is not yet supported" if clause.certainty == false
             end
           end
 
@@ -82,22 +83,22 @@ module ActiveFacts
           loose_binding
 
           # Ok, we have bound all players by subscript/role_name, by adjectives, and by loose binding,
-          # and matched all the fact types that matter. Now assemble a join (with all join steps) for
-          # each join list, and build an array of the variables that are involved in the join steps.
-          @variables_by_list =
+          # and matched all the fact types that matter. Now assemble a query (with all steps) for
+          # each query list, and build an array of the bindings that are involved in the steps.
+          @bindings_by_list =
             @clauses_lists.map do |clauses_list|
-              all_variables_in_clauses(clauses_list)
+              all_bindings_in_clauses(clauses_list)
             end
 
-          warn_ignored_joins
+          warn_ignored_queries
         end
 
-        def warn_ignored_joins
-          # Warn about ignored joins
+        def warn_ignored_queries
+          # Warn about ignored queries
           @clauses_lists.each do |clauses_list|
-            fact_types = clauses_list.map{|join| join.var_refs[0].role_ref.role.fact_type}.uniq
+            fact_types = clauses_list.map{|clauses| (rr = clauses.refs[0].role_ref) && rr.role.fact_type}.compact.uniq
             if fact_types.size > 1
-              puts "------->>>> Join ignored in #{self.class}: #{fact_types.map{|ft| ft.preferred_reading.expand}*' and '}"
+              raise "------->>>> join ignored in #{self.class}: #{fact_types.map{|ft| ft.preferred_reading.expand}*' and '}"
             end
           end
         end
@@ -107,28 +108,28 @@ module ActiveFacts
           debug :binding, "Loose binding on #{self.class.name}" do
             @clauses_lists.each do |clauses_list|
               clauses_list.each do |clause|
-                clause.var_refs.each_with_index do |var_ref, i|
-                  next if var_ref.variable.refs.size > 1
+                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 #{var_ref.inspect} as needing loose binding because it has no residual_adjectives"
+#                    debug :binding, "Discounting #{ref.inspect} as needing loose binding because it has no residual_adjectives"
 #                    next
 #                  end
-                  # This var_ref didn't match any other var_ref. Have a scout around for a suitable partner
-                  candidates = @context.variables.
-                    select do |key, variable|
-                      variable.player == var_ref.variable.player and
-                        variable != var_ref.variable and
-                        variable.role_name == var_ref.variable.role_name and  # Both will be nil if they match
-                        # REVISIT: Don't bind to a variable with a role occurrence in the same clause
-                        !variable.refs.detect{|vr|
+                  # This ref didn't match any other ref. Have a scout around for a suitable partner
+                  candidates = @context.bindings.
+                    select do |key, binding|
+                      binding.player == ref.binding.player and
+                        binding != ref.binding and
+                        binding.role_name == ref.binding.role_name and  # Both will be nil if they match
+                        # REVISIT: Don't bind to a binding with a role occurrence in the same clause
+                        !binding.refs.detect{|vr|
                           x = vr.clause == clause
-                          # puts "Discounting variable #{variable.inspect} as a match for #{var_ref.inspect} because it's already bound to a player in #{var_ref.clause.inspect}" if x
+                          # puts "Discounting binding #{binding.inspect} as a match for #{ref.inspect} because it's already bound to a player in #{ref.clause.inspect}" if x
                           x
                         }
                     end.map{|k,b| b}
                   next if candidates.size != 1  # Fail
-                  debug :binding, "Loose binding #{var_ref.inspect} to #{candidates[0].inspect}"
-                  var_ref.rebind_to(@context, candidates[0].refs[0])
+                  debug :binding, "Loose binding #{ref.inspect} to #{candidates[0].inspect}"
+                  ref.rebind_to(@context, candidates[0].refs[0])
                 end
               end
             end
@@ -138,28 +139,28 @@ 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
-            @roles.each do |var_ref|
-              if var_ref.variable.refs.size < @clauses_lists.size+1
-                debug :binding, "Insufficient bindings for #{var_ref.inspect} (#{var_ref.variable.refs.size}, expected #{@clauses_lists.size+1}), attempting loose binding" 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
                   @clauses_lists.each do |clauses_list|
                     candidates = []
                     next if clauses_list.
                       detect do |clause|
                         debug :binding, "Checking #{clause.inspect}"
-                        clause.var_refs.
+                        clause.refs.
                           detect do |vr|
-                            already_bound = vr.variable == var_ref.variable
-                            if !already_bound && vr.player == var_ref.player
+                            already_bound = vr.binding == ref.binding
+                            if !already_bound && vr.player == ref.player
                               candidates << vr
                             end
                             already_bound
                           end
                       end
-                    debug :binding, "Attempting loose binding for #{var_ref.inspect} in #{clauses_list.inspect}, from the following candidates: #{candidates.inspect}"
+                    debug :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 #{var_ref.inspect}"
-                      candidates[0].rebind_to(@context, var_ref)
+                      debug :binding, "Rebinding #{candidates[0].inspect} to #{ref.inspect}"
+                      candidates[0].rebind_to(@context, ref)
                     end
                   end
                 end
@@ -168,10 +169,10 @@ module ActiveFacts
           end
         end
 
-        def common_variables
-          @common_variables ||= @variables_by_list[1..-1].inject(@variables_by_list[0]) { |r, b| r & b }
-          raise "#{self.class} must cover some of the same roles, see #{@variables_by_list.inspect}" unless @common_variables.size > 0
-          @common_variables
+        def common_bindings
+          @common_bindings ||= @bindings_by_list[1..-1].inject(@bindings_by_list[0]) { |r, b| r & b }
+          raise "#{self.class} must cover some of the same roles, see #{@bindings_by_list.inspect}" unless @common_bindings.size > 0
+          @common_bindings
         end
 
         def to_s
@@ -180,33 +181,33 @@ module ActiveFacts
       end
 
       class PresenceConstraint < Constraint
-        def initialize context_note, enforcement, clauses_lists, var_refs, quantifier
+        def initialize context_note, enforcement, clauses_lists, refs, quantifier
           super context_note, enforcement, clauses_lists
-          @var_refs = var_refs || []
+          @refs = refs || []
           @quantifier = quantifier
         end
 
         def compile
           @clauses = @clauses_lists.map do |clauses_list|
-            raise "REVISIT: Join presence constraints not supported yet" if clauses_list.size > 1 or
-              clauses_list.detect{|clause| clause.var_refs.detect{|vr| vr.nested_clauses } }
+            raise "REVISIT: join presence constraints not supported yet" if clauses_list.size > 1 or
+              clauses_list.detect{|clause| clause.refs.detect{|vr| vr.nested_clauses } }
             clauses_list[0]
           end
 
-          bind_clauses @var_refs
+          bind_clauses @refs
 
-          if @var_refs.size > 0
+          if @refs.size > 0
             bind_constrained_roles
           else
-            cb = common_variables
+            cb = common_bindings
             raise "Either/or must have only one duplicated role, not #{cb.inspect}" unless cb.size == 1
-            @var_refs = cb[0].refs.reverse # REVISIT: Should have order these by clause, not like this
+            @refs = cb[0].refs.reverse # REVISIT: Should have order these by clause, not like this
           end
 
           role_sequence = @constellation.RoleSequence(:new)
-          @var_refs.each do |var_ref|
-            raise "The constrained role #{var_ref.inspect} was not found in the invoked fact types" if var_ref.variable.refs.size == 1
-            (var_ref.variable.refs-[var_ref]).each do |ref|
+          @refs.each do |ref|
+            raise "The constrained role #{ref.inspect} was not found in the invoked fact types" if ref.binding.refs.size == 1
+            (ref.binding.refs-[ref]).each do |ref|
               role = (ref.role_ref && ref.role_ref.role) || ref.role
               raise "FactType role not found for #{ref.inspect}" unless role
               @constellation.RoleRef(role_sequence, role_sequence.all_role_ref.size, :role => role)
@@ -225,6 +226,7 @@ module ActiveFacts
               :is_mandatory => @quantifier.min && @quantifier.min > 0
             )
           @enforcement.compile(@constellation, @constraint) if @enforcement
+	  debug :constraint, "Made new PC GUID=#{@constraint.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{role_sequence.describe}"
           super
         end
 
@@ -234,23 +236,23 @@ module ActiveFacts
         end
 
         def bind_constrained_roles
-          @var_refs.each do |var_ref|
-            if var_ref.variable.refs.size == 1
+          @refs.each do |ref|
+            if ref.binding.refs.size == 1
               # Apply loose binding over the constrained roles
               candidates =
                 @clauses.map do |clause|
-                  clause.var_refs.select{ |vr| vr.player == var_ref.player }
+                  clause.refs.select{ |vr| vr.player == ref.player }
                 end.flatten
               if candidates.size == 1
-                debug :binding, "Rebinding #{var_ref.inspect} to #{candidates[0].inspect} in presence constraint"
-                var_ref.rebind_to(@context, candidates[0])
+                debug :binding, "Rebinding #{ref.inspect} to #{candidates[0].inspect} in presence constraint"
+                ref.rebind_to(@context, candidates[0])
               end
             end
           end
         end
 
         def to_s
-          "#{super} #{@quantifier.min}-#{@quantifier.max} over (#{@var_refs.map{|vr| vr.inspect}*', '})"
+          "#{super} #{@quantifier.min}-#{@quantifier.max} over (#{@refs.map{|vr| vr.inspect}*', '})"
         end
       end
 
@@ -259,53 +261,56 @@ module ActiveFacts
           super context_note, enforcement, clauses_lists
         end
 
-        def warn_ignored_joins
+        def warn_ignored_queries
           # No warnings needed here any more
         end
 
-        def role_sequences_for_common_variables ignore_trailing_joins = false
+        def role_sequences_for_common_bindings ignore_trailing_steps = false
           @clauses_lists.
-              zip(@variables_by_list).
-              map do |clauses_list, variables|
-            # Does this clauses_list involve a join?
+              zip(@bindings_by_list).
+              map do |clauses_list, bindings|
+            # Does this clauses_list involve a query?
             if clauses_list.size > 1 or
-              clauses_list.detect{|clause| clause.var_refs.detect{|var_ref| var_ref.nested_clauses } }
-
-              debug :join, "Building join for #{clauses_list.inspect}" do
-                debug :join, "Constrained variables are #{@common_variables.inspect}"
-                # Every Variable in these clauses becomes a Join Node,
-                # and every clause becomes a JoinStep (and a RoleSequence).
-                # The returned RoleSequences contains the RoleRefs for the common_variables.
-
-                # Create a join with a join node for every variable and all join steps:
-                join = build_join_nodes(clauses_list)
-                roles_by_variable = build_all_join_steps(clauses_list)
-                join.validate
+              clauses_list.detect do |clause|
+		clause.refs.detect{|ref| ref.nested_clauses } or
+		clause.includes_literals
+	      end
+
+              debug :query, "Building query for #{clauses_list.inspect}" do
+                debug :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.
+
+                # Create a query with a variable for every binding and all steps:
+                query = build_variables(clauses_list)
+                roles_by_binding = build_all_steps(clauses_list)
+                query.validate
 
                 # Create the projected RoleSequence for the constraint:
                 role_sequence = @constellation.RoleSequence(:new)
-                @common_variables.each do |variable|
-                  role, join_role = *roles_by_variable[variable]
-                  @constellation.RoleRef(role_sequence, role_sequence.all_role_ref.size, :role => role, :join_role => join_role)
+                @common_bindings.each do |binding|
+                  role, play = *roles_by_binding[binding]
+                  @constellation.RoleRef(role_sequence, role_sequence.all_role_ref.size, :role => role, :play => play)
                 end
 
                 role_sequence
               end
             else
-              # There's no join in this clauses_list, just create a role_sequence
+              # There's no query in this clauses_list, just create a role_sequence
               role_sequence = @constellation.RoleSequence(:new)
-              join_variables = variables-@common_variables
-              unless join_variables.empty? or ignore_trailing_joins && join_variables.size <= 1
-                debug :constraint, "REVISIT: #{self.class}: Ignoring join from #{@common_variables.inspect} to #{join_variables.inspect} in #{clauses_list.inspect}"
+              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}"
               end
-              @common_variables.each do |variable|
+              @common_bindings.each do |binding|
                 roles = clauses_list.
                   map do |clause|
-                    clause.var_refs.detect{|vr| vr.variable == variable }
+                    clause.refs.detect{|vr| vr.binding == binding }
                   end.
-                  compact.  # A join clause will probably not have the common variable
-                  map do |var_ref|
-                    var_ref.role_ref && var_ref.role_ref.role or var_ref.role
+                  compact.  # A query clause will probably not have the common binding
+                  map do |ref|
+                    ref.role_ref && ref.role_ref.role or ref.role
                   end.
                   compact
                 # REVISIT: Should use clause side effects to preserve residual adjectives here.
@@ -326,10 +331,10 @@ module ActiveFacts
 
         def compile
           bind_clauses
-          common_variables
+          common_bindings
 
           role_sequences =
-            role_sequences_for_common_variables
+            role_sequences_for_common_bindings
 
           @constraint =
             @constellation.SubsetConstraint(
@@ -362,10 +367,10 @@ module ActiveFacts
 
         def compile
           bind_clauses @roles
-          common_variables
+          common_bindings
 
           role_sequences =
-            role_sequences_for_common_variables
+            role_sequences_for_common_bindings
 
           @constraint = @constellation.SetExclusionConstraint(
             :new,
@@ -397,10 +402,10 @@ module ActiveFacts
 
         def compile
           bind_clauses
-          common_variables
+          common_bindings
 
           role_sequences =
-            role_sequences_for_common_variables
+            role_sequences_for_common_bindings
 
           @constraint = @constellation.SetEqualityConstraint(
             :new,
@@ -419,8 +424,9 @@ module ActiveFacts
       end
 
       class RingConstraint < Constraint
-        Types = %w{acyclic intransitive symmetric asymmetric transitive antisymmetric irreflexive reflexive}
+        Types = %w{acyclic intransitive stronglyintransitive symmetric asymmetric transitive antisymmetric irreflexive reflexive}
         Pairs = {
+          :stronglyintransitive => [:acyclic, :asymmetric, :symmetric],
           :intransitive => [:acyclic, :asymmetric, :symmetric],
           :transitive => [:acyclic],
           :acyclic => [:transitive],
@@ -487,28 +493,42 @@ module ActiveFacts
       end
 
       class ValueConstraint < Constraint
-        def initialize value_ranges, units, enforcement
+        def initialize ast, enforcement
           super nil, enforcement
-          @value_ranges = value_ranges
-          @units = units
+          @value_ranges = ast[:ranges]
+          @units = ast[:units]
+          @regular_expression = ast[:regular_expression]
         end
 
+	def assert_value(val)
+	  if val.is_a?(String)
+	    @constellation.Value(eval(val), true, nil)
+	  elsif val
+	    @constellation.Value(val.to_s, false , nil)
+	  else
+	    nil
+	  end
+	end
+
         def compile
           @constraint = @constellation.ValueConstraint(:new)
           raise "Units on value constraints are not yet processed (at line #{'REVISIT'})" if @units
               # @string.line_of(node.interval.first)
 
-          @value_ranges.each do |range|
-            min, max = Array === range ? range : [range, range]
-            v_range = @constellation.ValueRange(
-              min ? [[String === min ? eval(min) : min.to_s, String === min, nil], true] : nil,
-              max ? [[String === max ? eval(max) : max.to_s, String === max, nil], true] : nil
-            )
-            ar = @constellation.AllowedRange(@constraint, v_range)
-          end
-          @enforcement.compile(@constellation, @constraint) if @enforcement
-          super
-        end
+	  if @value_ranges
+	    @value_ranges.each do |range|
+	      min, max = Array === range ? range : [range, range]
+	      v_range = @constellation.ValueRange(
+		min && @constellation.Bound(:value => assert_value(min), :is_inclusive => true),
+		max && @constellation.Bound(:value => assert_value(max), :is_inclusive => true))
+	      ar = @constellation.AllowedRange(@constraint, v_range)
+	    end
+	  else
+	    @constraint.regular_expression = @regular_expression
+	  end
+	  @enforcement.compile(@constellation, @constraint) if @enforcement
+	  super
+	end
 
         def vrto_s vr
           if Array === vr
@@ -529,7 +549,11 @@ module ActiveFacts
         end
 
         def to_s
-          "#{super} to (#{@value_ranges.map{|vr| vrto_s(vr) }.inspect })#{ @units ? " in #{@units.inspect}" : ''}"
+          "#{super} to " +
+	  (@value_ranges ?
+	    "(#{@value_ranges.map{|vr| vrto_s(vr) }.inspect })#{ @units ? " in #{@units.inspect}" : ''}" :
+	    @regular_expression
+	  )
         end
       end
 

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

@@ -19,16 +19,18 @@ module ActiveFacts
       end
 
       class EntityType < ObjectType
-        def initialize name, supertypes, identification, pragmas, clauses
+        def initialize name, supertypes, identification, pragmas, clauses, context_note
           super name
           @supertypes = supertypes
           @identification = identification
           @pragmas = pragmas
           @clauses = clauses || []
+	  @context_note = context_note
         end
 
         def compile
-          @entity_type = @constellation.EntityType(@vocabulary, @name, :guid => :new)
+          @entity_type = @vocabulary.valid_entity_type_name(@name) ||
+	    @constellation.EntityType(@vocabulary, @name, :guid => :new)
           @entity_type.is_independent = true if (@pragmas.include? 'independent')
 
           # REVISIT: CQL needs a way to indicate whether subtype migration can occur.
@@ -47,7 +49,7 @@ module ActiveFacts
           # Create the fact types that define the identifying roles:
           fact_types = create_identifying_fact_types context
 
-          # At this point, @identification is an array of VarRefs and/or Clauses (for unary fact types)
+          # At this point, @identification is an array of References and/or Clauses (for unary fact types)
           # Have to do this after creating the necessary fact types
           complete_reference_mode_fact_type fact_types
 
@@ -56,6 +58,10 @@ module ActiveFacts
 
           make_preferred_identifier_over_roles identifying_roles
 
+	  if @context_note
+	    @context_note.compile(@constellation, @entity_type)
+	  end
+
           @clauses.each do |clause|
             next unless clause.context_note
             clause.context_note.compile(@constellation, @entity_type)
@@ -70,7 +76,7 @@ module ActiveFacts
             if @identification.is_a? ReferenceMode
               make_entity_type_refmode_valuetypes(name, @identification.name, @identification.parameters)
               vt_name = @reference_mode_value_type.name
-              @identification = [Compiler::VarRef.new(vt_name, nil, nil, nil, nil, nil, @identification.value_constraint, nil)]
+              @identification = [Compiler::Reference.new(vt_name, nil, nil, nil, nil, nil, @identification.value_constraint, nil)]
             else
               context.allowed_forward_terms = legal_forward_references(@identification)
             end
@@ -80,16 +86,16 @@ module ActiveFacts
         # Names used in the identifying roles list may be forward referenced:
         def legal_forward_references(identification_phrases)
           identification_phrases.map do |phrase|
-            phrase.is_a?(VarRef) ? phrase.term : nil
+            phrase.is_a?(Reference) ? phrase.term : nil
           end.compact.uniq
         end
 
         def bind_identifying_roles context
           return unless @identification
           @identification.map do |id|
-            if id.is_a?(VarRef)
-              variable = id.variable
-              roles = variable.refs.map{|r| r.role}.compact.uniq
+            if id.is_a?(Reference)
+              binding = id.binding
+              roles = binding.refs.map{|r|r.role || (rr=r.role_ref and rr.role)}.compact.uniq
               raise "Looking for an occurrence of identifying role #{id.inspect}, but found #{roles.size == 0 ? "none" : roles.size}" if roles.size != 1
               roles[0]
             else
@@ -129,6 +135,7 @@ module ActiveFacts
                 #:is_mandatory => true,
                 #:min_frequency => 1,
               )
+	    debug :constraint, "Made new preferred PC GUID=#{pc.guid} min=nil max=1 over #{role_sequence.describe}"
           end
         end
 
@@ -147,7 +154,7 @@ module ActiveFacts
           fact_types = []
           # Categorise the clauses into fact types according to the roles they play.
           @clauses.inject({}) do |hash, clause|
-            players_key = clause.var_refs.map{|vr| vr.key.compact}.sort
+            players_key = clause.refs.map{|vr| vr.key.compact}.sort
             (hash[players_key] ||= []) << clause
             hash
           end.each do |players_key, clauses|
@@ -155,7 +162,9 @@ module ActiveFacts
 
             fact_type = create_identifying_fact_type(context, clauses)
             fact_types << fact_type if fact_type
-            objectify_existing_fact_type(fact_type) unless fact_type.all_role.detect{|r| r.object_type == @entity_type}
+	    unless fact_type.all_role.detect{|r| r.object_type == @entity_type}
+	      objectify_existing_fact_type(fact_type)
+	    end
           end
           fact_types
         end
@@ -167,10 +176,13 @@ module ActiveFacts
 
           # See if any fact type already exists (this ET cannot be a player, but might objectify it)
           existing_clauses = clauses.select{ |clause| clause.match_existing_fact_type context }
+	  if negation = existing_clauses.detect{|c| c.certainty == false }
+	    raise "#{@name} cannot be identified by negated fact type #{negation.inspect}"
+	  end
           any_matched = existing_clauses.size > 0
 
           operation = any_matched ? 'Objectifying' : 'Creating'
-          player_names = clauses[0].var_refs.map{|vr| vr.key.compact*'-'}
+          player_names = clauses[0].refs.map{|vr| vr.key.compact*'-'}
           debug :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)
@@ -194,10 +206,13 @@ module ActiveFacts
 
         def objectify_existing_fact_type fact_type
           raise "#{@name} cannot objectify fact type '#{fact_type.entity_type.name}' that's already objectified" if fact_type.entity_type
-          raise "#{@name} must only objectify one fact type" if @fact_type
+	  if @fact_type
+	    raise "#{@name} cannot objectify '#{fact_type.default_reading}', it already objectifies '#{@fact_type.default_reading}'"
+	  end
+
           if fact_type.internal_presence_constraints.select{|pc| pc.max_frequency == 1}.size == 0
             # If there's no existing uniqueness constraint over this fact type, make a spanning one.
-            @constellation.PresenceConstraint(
+            pc = @constellation.PresenceConstraint(
               :new,
               :vocabulary => @vocabulary,
               :name => @entity_type.name+"UQ",
@@ -205,18 +220,20 @@ 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.guid} min=nil max=1 over #{fact_type.preferred_reading.role_sequence.describe}"
           end
 
           @fact_type = @entity_type.fact_type = fact_type
-          @entity_type.create_implicit_fact_types
+          @entity_type.create_implicit_fact_types # REVISIT: Could there be readings for the implicit fact types here?
           @fact_type
         end
 
         def add_supertype(supertype_name, not_identifying)
-          debug :supertype, "Adding supertype #{supertype_name}" do
-            supertype = @constellation.EntityType(@vocabulary, supertype_name, :guid => :new)
+          debug :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, :guid => :new) # Should always already exist
 
-            # Did we already know about this supertype?
+            # Did we already know about this supertyping?
             return if @entity_type.all_type_inheritance_as_subtype.detect{|ti| ti.supertype == supertype}
 
             # By default, the first supertype identifies this entity type
@@ -235,14 +252,14 @@ module ActiveFacts
             rs = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs, 0, :role => sub_role)
             @constellation.RoleRef(rs, 1, :role => super_role)
-            @constellation.Reading(inheritance_fact, 0, :role_sequence => rs, :text => "{0} is a kind of {1}")
+            @constellation.Reading(inheritance_fact, 0, :role_sequence => rs, :text => "{0} is a kind of {1}", :is_negative => false)
 
             rs2 = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs2, 0, :role => super_role)
             @constellation.RoleRef(rs2, 1, :role => sub_role)
             # Decide in which order to include is a/is an. Provide both, but in order.
             n = 'aeiouh'.include?(sub_role.object_type.name.downcase[0]) ? 'n' : ''
-            @constellation.Reading(inheritance_fact, 2, :role_sequence => rs2, :text => "{0} is a#{n} {1}")
+            @constellation.Reading(inheritance_fact, 2, :role_sequence => rs2, :text => "{0} is a#{n} {1}", :is_negative => false)
 
             if is_identifying_supertype
               inheritance_fact.provides_identification = true
@@ -258,6 +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.guid} min=1 max=1 over #{p1rs.describe}"
 
             p2rs = @constellation.RoleSequence(:new)
             constellation.RoleRef(p2rs, 0).role = super_role
@@ -269,6 +287,8 @@ 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.guid} min=1 max=1 over #{p2rs.describe}"
           end
         end
 
@@ -276,10 +296,12 @@ module ActiveFacts
           vt_name = "#{name}#{mode}"
           vt = nil
           debug :entity, "Preparing value type #{vt_name} for reference mode" do
-            # Find or Create an appropriate ValueType called '#{vt_name}', of the supertype '#{mode}'
-            unless vt = @constellation.ObjectType[[@vocabulary.identifying_role_values, vt_name]] or
-                   vt = @constellation.ObjectType[[@vocabulary.identifying_role_values, vt_name = "#{name} #{mode}"]]
-              base_vt = @constellation.ValueType(@vocabulary, mode, :guid => :new)
+            # 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
+		   vt = @vocabulary.valid_object_type_name(vt_name = "#{name} #{mode}")
+              base_vt = @vocabulary.valid_value_type_name(mode) ||
+		  @constellation.ValueType(@vocabulary, mode, :guid => :new)
               vt = @constellation.ValueType(@vocabulary, vt_name, :supertype => base_vt, :guid => :new)
               if parameters
                 length, scale = *parameters
@@ -340,7 +362,7 @@ module ActiveFacts
             @constellation.RoleRef(rs01, 1, :role => identifying_role)
           end
           if rs01.all_reading.empty?
-            @constellation.Reading(fact_type, fact_type.all_reading.size, :role_sequence => rs01, :text => "{0} has {1}")
+            @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}'"
           else
             debug :mode, "Using existing forward reading"
@@ -354,7 +376,7 @@ module ActiveFacts
             @constellation.RoleRef(rs10, 1, :role => entity_role)
           end
           if rs10.all_reading.empty?
-            @constellation.Reading(fact_type, fact_type.all_reading.size, :role_sequence => rs10, :text => "{0} is of {1}")
+            @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}'"
           else
             debug :mode, "Using existing reverse reading"
@@ -381,7 +403,7 @@ module ActiveFacts
               :is_preferred_identifier => false,
               :is_mandatory => true
             )
-            debug :mode, "Creating new EntityType PresenceConstraint"
+	    debug :constraint, "Made new refmode PC GUID=#{constraint.guid} min=1 max=1 over #{rs0.describe}"
           else
             debug :mode, "Using existing EntityType PresenceConstraint"
           end
@@ -409,7 +431,7 @@ module ActiveFacts
               :is_preferred_identifier => true,
               :is_mandatory => false
             )
-            debug :mode, "Creating new ValueType PresenceConstraint"
+	    debug :constraint, "Made new refmode ValueType PC GUID=#{constraint.guid} min=0 max=1 over #{rs1.describe}"
           else
             debug :mode, "Marking existing ValueType PresenceConstraint as preferred"
             rs1.all_presence_constraint.single.is_preferred_identifier = true