activefacts 0.8.16 → 0.8.18

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

@@ -5,21 +5,23 @@ module ActiveFacts
       class Clause
         attr_reader :phrases
         attr_accessor :qualifiers, :context_note
+        attr_accessor :certainty        # nil, true, false -> maybe, definitely, not
         attr_accessor :conjunction      # one of {nil, 'and', ',', 'or', 'where'}
         attr_accessor :fact_type
         attr_reader :reading, :role_sequence    # These are the Metamodel objects
         attr_reader :side_effects       # How to adjust the phrases if this fact_type match is accepted
         attr_accessor :fact             # When binding fact instances the fact goes here
-        attr_accessor :objectified_as   # The VarRef which objectified this fact type
+        attr_accessor :objectified_as   # The Reference which objectified this fact type
 
         def initialize phrases, qualifiers = [], context_note = nil
           @phrases = phrases
-          var_refs.each { |var_ref| var_ref.clause = self }
+          refs.each { |ref| ref.clause = self }
+          @certainty = true
           @qualifiers = qualifiers
           @context_note = context_note
         end
 
-        def var_refs
+        def refs
           @phrases.select{|r| r.respond_to?(:player)}
         end
 
@@ -27,7 +29,7 @@ module ActiveFacts
         # refers only to the existence of that ObjectType (as opposed to an instance of the object_type).
         def is_existential_type
           @phrases.size == 1 and
-            @phrases[0].is_a?(VarRef) and
+            @phrases[0].is_a?(Reference) and
             !@phrases[0].literal
         end
 
@@ -35,22 +37,29 @@ module ActiveFacts
           to_s
         end
 
-        def inspect
-          to_s
+        def inspect phrases = nil
+          to_s(phrases||@phrases)
         end
 
-        def to_s
+        def to_s phrases = nil
+          phrases ||= @phrases
           "#{
             @qualifiers && @qualifiers.size > 0 ? @qualifiers.sort.inspect+' ' : nil
+          }#{
+            case @certainty
+            when nil; 'maybe '
+            when false; 'negated '
+            # else 'definitely '
+            end
           }#{
             quotes = false
-            @phrases.inject(""){|s, p|
+            phrases.inject(""){|s, p|
               if String === p
                 s + (quotes ? '' : (quotes = true; '"')) + p.to_s + ' '
 #              REVISIT: Add something here when I re-add functions
 #              elsif FunctionCallChain === p
 #                s[0..-2] + (quotes ? (quotes = false; '" ') : '') + p.to_s
-              else # if VarRef === p
+              else # if Reference === p
                 s[0..-2] + (quotes ? (quotes = false; '" ') : '') + p.to_s +
                   ((oj = p.nested_clauses) ?  ' ('+ oj.map{|c| ((j=c.conjunction) ? j+' ' : '') + c.to_s}*' ' + ')' : '') +
                 ' '
@@ -64,21 +73,21 @@ module ActiveFacts
         end
 
         def identify_players_with_role_name context
-          var_refs.each do |var_ref|
-            var_ref.identify_players_with_role_name(context)
+          refs.each do |ref|
+            ref.identify_players_with_role_name(context)
           end
         end
 
         def identify_other_players context
-          var_refs.each do |var_ref|
-            var_ref.identify_other_players(context)
+          refs.each do |ref|
+            ref.identify_other_players(context)
             # Include players in nested clauses, if any
-            var_ref.nested_clauses.each{|clause| clause.identify_other_players(context)} if var_ref.nested_clauses
+            ref.nested_clauses.each{|clause| clause.identify_other_players(context)} if ref.nested_clauses
           end
         end
 
         def includes_literals
-          var_refs.detect{|var_ref| var_ref.literal || (ja = var_ref.nested_clauses and ja.detect{|jr| jr.includes_literals })}
+          refs.detect{|ref| ref.literal || (ja = ref.nested_clauses and ja.detect{|jr| jr.includes_literals })}
         end
 
         def is_equality_comparison
@@ -86,7 +95,7 @@ module ActiveFacts
         end
 
         def bind context
-          role_names = var_refs.map{ |var_ref| var_ref.role_name }.compact
+          role_names = refs.map{ |ref| ref.role_name }.compact
 
           # Check uniqueness of role names and subscripts within this clause:
           role_names.each do |rn|
@@ -94,15 +103,15 @@ module ActiveFacts
             raise "Duplicate role #{rn.is_a?(Integer) ? "subscript" : "name"} '#{rn}' in clause"
           end
 
-          var_refs.each do |var_ref|
-            var_ref.bind context
+          refs.each do |ref|
+            ref.bind context
           end
         end
 
         def phrases_match(phrases)
           @phrases.zip(phrases).each do |mine, theirs|
-            return false if mine.is_a?(VarRef) != theirs.is_a?(VarRef)
-            if mine.is_a?(VarRef)
+            return false if mine.is_a?(Reference) != theirs.is_a?(Reference)
+            if mine.is_a?(Reference)
               return false unless mine.key == theirs.key
             else
               return false unless mine == theirs
@@ -118,8 +127,9 @@ module ActiveFacts
         # no change is made to this Clause object - those will be done later.
         #
         def match_existing_fact_type context, options = {}
+          raise "Cannot match a clause that contains no object types" if refs.size == 0
           raise "Internal error, clause already matched, should not match again" if @fact_type
-          # If we fail to match, try to a left contraction (or save this for a subsequent left contraction):
+          # If we fail to match, try a left contraction (or save this for a subsequent left contraction):
           left_contract_this_onto = context.left_contractable_clause
           new_conjunction = (conjunction == nil || conjunction == ',')
           changed_conjunction = (lcc = context.left_contraction_conjunction) && lcc != conjunction
@@ -131,55 +141,100 @@ module ActiveFacts
           end
           context.left_contraction_conjunction = new_conjunction ? nil : @conjunction
 
-          contracted_role = nil
+          phrases = @phrases
+          vrs = []+refs
+
+          # A left contraction is where the first player in the previous clause continues as first player of this clause
+          contracted_left = false
+          can_contract_right = false
+          left_insertion = nil
+          right_insertion = nil
+          supposed_roles = []   # Arrange to unbind incorrect references supposed due to contraction
+          contract_left = proc do
+            contracted_from = left_contract_this_onto.refs[0]
+            contraction_player = contracted_from.player
+            contracted_role = Reference.new(contraction_player.name)
+            supposed_roles << contracted_role
+            left_insertion = contracted_role.inspect+' '
+            contracted_role.player = contracted_from.player
+            contracted_role.role_name = contracted_from.role_name
+            contracted_role.bind(context)
+            vrs.unshift contracted_role
+            contracted_left = true
+            phrases = [contracted_role]+phrases
+            debug :matching, "Failed to match #{inspect}. Trying again using left contraction onto #{contraction_player.name}"
+          end
+
+          contract_right = proc do
+            contracted_from = left_contract_this_onto.refs[-1]
+            contraction_player = contracted_from.player
+            contracted_role = Reference.new(contraction_player.name)
+            supposed_roles << contracted_role
+            right_insertion = ' '+contracted_role.inspect
+            contracted_role.player = contracted_from.player
+            contracted_role.role_name = contracted_from.role_name
+            contracted_role.bind(context)
+            vrs.push contracted_role
+            phrases = phrases+[contracted_role]
+            debug :matching, "Failed to match #{inspect}. Trying again using right contraction onto #{contraction_player.name}"
+          end
 
-          vrs = []+var_refs
           begin
             players = vrs.map{|vr| vr.player}
+
+            if players.size == 0
+              can_contract_right = left_contract_this_onto.refs.size == 2
+              contract_left.call
+              redo
+            end
+
             raise "Must identify players before matching fact types" if players.include? nil
             raise "A fact type must involve at least one object type, but there are none in '#{inspect}'" if players.size == 0 && !left_contract_this_onto
 
             player_names = players.map{|p| p.name}
 
-            debug :matching, "Looking for existing #{players.size}-ary fact types matching '#{contracted_role && contracted_role.inspect+' '}#{inspect}'" do
+            debug :matching, "Looking for existing #{players.size}-ary fact types matching '#{inspect(phrases)}'" do
               debug :matching, "Players are '#{player_names.inspect}'"
 
-              # Match existing fact types in nested clauses first (not for contractions):
-              if !contracted_role
-                vrs.each do |var_ref|
-                  next if var_ref.is_a?(Operation)
-                  next unless joins = var_ref.nested_clauses and !joins.empty?
-                  var_ref.nested_clauses.each do |oj|
+              # Match existing fact types in nested clauses first:
+              # (not for contractions) REVISIT: Why not?
+              if !contracted_left
+                vrs.each do |ref|
+                  next if ref.is_a?(Operation)
+                  next unless steps = ref.nested_clauses and !steps.empty?
+                  ref.nested_clauses.each do |oj|
                     ft = oj.match_existing_fact_type(context)
                     raise "Unrecognised fact type #{oj.display}" unless ft
-                    if (ft && ft.entity_type == var_ref.player)
-                      var_ref.objectification_of = ft
-                      oj.objectified_as = var_ref
+                    if (ft && ft.entity_type == ref.player)
+                      ref.objectification_of = ft
+                      oj.objectified_as = ref
                     end
                   end
-                  raise "#{var_ref.inspect} contains objectification joins that do not objectify it" unless var_ref.objectification_of
+                  raise "#{ref.inspect} contains objectification steps that do not objectify it" unless ref.objectification_of
                 end
               end
 
               # For each role player, find the compatible types (the set of all subtypes and supertypes).
-              # For a player that's an objectification, we don't allow implicit supertype joins
+              # For a player that's an objectification, we don't allow implicit supertype steps
               player_related_types =
-                vrs.zip(players).map do |var_ref, player|
-                  disallow_subtyping = var_ref && var_ref.objectification_of || options[:exact_type]
+                vrs.zip(players).map do |ref, player|
+                  disallow_subtyping = ref && ref.objectification_of || options[:exact_type]
                   ((disallow_subtyping ? [] : player.supertypes_transitive) +
                     player.subtypes_transitive).uniq
                 end
 
               debug :matching, "Players must match '#{player_related_types.map{|pa| pa.map{|p|p.name}}.inspect}'"
 
+              start_obj = player_related_types[0] || [left_contract_this_onto.refs[-1].player]
               # The candidate fact types have the right number of role players of related types.
-              # If any role is played by a supertype or subtype of the required type, there's an implicit subtyping join
+              # If any role is played by a supertype or subtype of the required type, there's an implicit subtyping steps
+              # REVISIT: A double contraction results in player_related_types being empty here
               candidate_fact_types =
-                player_related_types[0].map do |related_type|
+                start_obj.map do |related_type|
                   related_type.all_role.select do |role|
                     all_roles = role.fact_type.all_role
                     next if all_roles.size != players.size      # Wrong number of players
-                    next if role.fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType)
+                    next if role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
 
                     all_players = all_roles.map{|r| r.object_type}  # All the players of this candidate fact type
 
@@ -202,13 +257,13 @@ module ActiveFacts
                     map{ |role| role.fact_type}
                 end.flatten.uniq
 
-              # If there is more than one possible exact match (same adjectives) with different subyping, the implicit join is ambiguous and is not allowed
+              # If there is more than one possible exact match (same adjectives) with different subyping, the implicit query is ambiguous and is not allowed
 
-              debug :matching, "Looking amongst #{candidate_fact_types.size} existing fact types for one matching '#{contracted_role && contracted_role.inspect+' '}#{inspect}'" do
+              debug :matching, "Looking amongst #{candidate_fact_types.size} existing fact types for one matching #{left_insertion}'#{inspect}'#{right_insertion}" do
                 matches = {}
                 candidate_fact_types.map do |fact_type|
                   fact_type.all_reading.map do |reading|
-                    next unless side_effects = clause_matches(fact_type, reading, contracted_role)
+                    next unless side_effects = clause_matches(fact_type, reading, phrases)
                     matches[reading] = side_effects if side_effects
                   end
                 end
@@ -221,7 +276,7 @@ module ActiveFacts
                 # the whole declaration has been processed and the extra adjectives can be matched.
 
                 best_matches = matches.keys.sort_by{|match|
-                  # Between equivalents, prefer the one without a join on the first role
+                  # Between equivalents, prefer the one without steps on the first role
                   (m = matches[match]).cost*2 + ((!(e = m.role_side_effects[0]) || e.cost) == 0 ? 0 : 1)
                 }
                 debug :matching_fails, "Found #{matches.size} valid matches#{matches.size > 0 ? ', best is '+best_matches[0].expand : ''}"
@@ -243,7 +298,7 @@ module ActiveFacts
                   @side_effects = matches[@reading]
                   @fact_type = @side_effects.fact_type
                   debug :matching, "Matched '#{@fact_type.default_reading}'"
-                  @phrases.unshift(contracted_role) if contracted_role
+                  @phrases = phrases
                   apply_side_effects(context, @side_effects)
                   return @fact_type
                 end
@@ -251,21 +306,19 @@ module ActiveFacts
               end
               debug :matching, "No fact type matched, candidates were '#{candidate_fact_types.map{|ft| ft.default_reading}*"', '"}'"
             end
-            if left_contract_this_onto && !contracted_role
-              contracted_from = left_contract_this_onto.var_refs[0]
-              contraction_player = contracted_from.player
-              contracted_role = VarRef.new(contraction_player.name)
-              contracted_role.player = contracted_from.player
-              contracted_role.role_name = contracted_from.role_name
-              contracted_role.bind(context)
-              vrs.unshift contracted_role
-
-              debug :matching, "Failed to match #{inspect}. Trying again using left contraction onto #{contraction_player.name}"
-              redo
+            if left_contract_this_onto
+              if !contracted_left
+                contract_left.call
+                redo
+              elsif can_contract_right
+                contract_right.call
+                can_contract_right = false
+                redo
+              end
             end
           end until true  # Once through, unless we hit a redo
-          if contracted_role
-            contracted_role.unbind context
+          supposed_roles.each do |role|
+            role.unbind context
           end
           @fact_type = nil
         end
@@ -275,7 +328,7 @@ module ActiveFacts
         # Find whether the phrases of this clause match the fact type reading,
         # which may require absorbing unmarked adjectives.
         #
-        # If it does match, make the required changes and set @var_ref to the matching role ref.
+        # If it does match, make the required changes and set @ref to the matching role ref.
         # Adjectives that were used to match are removed (and leaving any additional adjectives intact).
         #
         # Approach:
@@ -288,18 +341,33 @@ module ActiveFacts
         #       trailing adjectives, both marked and unmarked, are absorbed too.
         #     a word that matches the reading's
         #
-        def clause_matches(fact_type, reading, contracted_role = nil)
+        def clause_matches(fact_type, reading, phrases = @phrases)
+          implicitly_negated = false
           side_effects = []    # An array of items for each role, describing any side-effects of the match.
           intervening_words = nil
           residual_adjectives = false
-          phrases = [contracted_role].compact+@phrases
+
+          # The following form of negation is, e.g., where "Person was invited to no Party",
+          # as opposed to where "Person was not invited to that Party". Quite different meaning,
+          # because a free Party variable is required, but the join step is still disallowed.
+          # REVISIT: I'll create the free variable when I implement some/that binding
+          # REVISIT: the verbaliser will need to know about a negated step to a free variable
+          implicitly_negated = true if refs.detect{|ref| q = ref.quantifier and q.is_zero }
+
           debug :matching_fails, "Does '#{phrases.inspect}' match '#{reading.expand}'" do
             phrase_num = 0
             reading_parts = reading.text.split(/\s+/)
             reading_parts.each do |element|
+              phrase = phrases[phrase_num]
+              if phrase == 'not'
+                raise "Stop playing games with your double negatives: #{phrases.inspect}" if implicitly_negated
+                debug :matching, "Negation detected"
+                implicitly_negated = true
+                phrase = phrases[phrase_num += 1]
+              end
               if element !~ /\{(\d+)\}/
                 # Just a word; it must match
-                unless phrases[phrase_num] == element
+                unless phrase == element
                   debug :matching_fails, "Mismatched ordinary word #{phrases[phrase_num].inspect} (wanted #{element})"
                   return nil
                 end
@@ -337,7 +405,7 @@ module ActiveFacts
                   return nil
                 end
 
-                debug :matching_fails, "Subtype join is required between #{player.name} and #{next_player_phrase.player.name} via common supertype #{common_supertype.name}"
+                debug :matching_fails, "Subtype step is required between #{player.name} and #{next_player_phrase.player.name} via common supertype #{common_supertype.name}"
               else
                 if !next_player_phrase
                   next    # Contraction succeeded so far
@@ -406,7 +474,7 @@ module ActiveFacts
 =end
 
               residual_adjectives ||= role_has_residual_adjectives
-              if residual_adjectives && next_player_phrase.variable.refs.size == 1
+              if residual_adjectives && next_player_phrase.binding.refs.size == 1
                 # This makes matching order-dependent, because there may be no "other purpose"
                 # until another reading has been matched and the roles rebound.
                 debug :matching_fails, "Residual adjectives have no other purpose, so this match fails"
@@ -423,20 +491,20 @@ module ActiveFacts
             end
 
             if fact_type.is_a?(Metamodel::TypeInheritance)
-              # There may be only one subtyping join on a TypeInheritance fact type.
-              ti_joins = side_effects.select{|side_effect| side_effect.common_supertype}
-              if ti_joins.size > 1   # Not allowed
-                debug :matching_fails, "Can't have more than one subtyping join on a TypeInheritance fact type"
+              # There may be only one subtyping step on a TypeInheritance fact type.
+              ti_steps = side_effects.select{|side_effect| side_effect.common_supertype}
+              if ti_steps.size > 1   # Not allowed
+                debug :matching_fails, "Can't have more than one subtyping step on a TypeInheritance fact type"
                 return nil
               end
 
-              if ti = ti_joins[0]
-                # The Type Inheritance join must continue in the same direction as this reading.
+              if ti = ti_steps[0]
+                # The Type Inheritance step must continue in the same direction as this reading.
                 allowed = fact_type.supertype == ti.role_ref.role.object_type ?
                     fact_type.subtype.supertypes_transitive :
                     fact_type.supertype.subtypes_transitive
                 if !allowed.include?(ti.common_supertype)
-                  debug :matching_fails, "Implicit subtyping join extends in the wrong direction"
+                  debug :matching_fails, "Implicit subtyping step extends in the wrong direction"
                   return nil
                 end
               end
@@ -449,7 +517,9 @@ module ActiveFacts
                 } side effects)#{residual_adjectives ? ' and residual adjectives' : ''}"
           end
           # There will be one side_effects for each role player
-          ClauseMatchSideEffects.new(fact_type, self, residual_adjectives, side_effects)
+          @certainty = !@certainty if implicitly_negated
+          @certainty = !@certainty if reading.is_negative
+          ClauseMatchSideEffects.new(fact_type, self, residual_adjectives, side_effects, implicitly_negated)
         end
 
         def apply_side_effects(context, side_effects)
@@ -460,8 +530,8 @@ module ActiveFacts
             side_effects.apply_all do |side_effect|
               phrase = side_effect.phrase
 
-              # We re-use the role_ref if possible (no extra adjectives were used, no rolename or join, etc).
-              debug :matching, "side-effect means variable #{phrase.inspect} matches role ref #{side_effect.role_ref.role.object_type.name}"
+              # We re-use the role_ref if possible (no extra adjectives were used, no rolename or step, etc).
+              debug :matching, "side-effect means binding #{phrase.inspect} matches role ref #{side_effect.role_ref.role.object_type.name}"
               phrase.role_ref = side_effect.role_ref
 
               changed = false
@@ -482,7 +552,7 @@ module ActiveFacts
                   end
                 elsif side_effect.absorbed_followers > 0
                   # The following statement is incorrect. The absorbed adjective is what caused the match.
-                  # This phrase is absorbing non-hyphenated adjective(s), which changes its variable
+                  # This phrase is absorbing non-hyphenated adjective(s), which changes its binding
                   # phrase.trailing_adjective =
                   @phrases.slice!(side_effect.num+1, side_effect.absorbed_followers)*' '
                   changed = true
@@ -502,7 +572,7 @@ module ActiveFacts
                   end
                 elsif side_effect.absorbed_precursors > 0
                   # The following statement is incorrect. The absorbed adjective is what caused the match.
-                  # This phrase is absorbing non-hyphenated adjective(s), which changes its variable
+                  # This phrase is absorbing non-hyphenated adjective(s), which changes its binding
                   #phrase.leading_adjective =
                   @phrases.slice!(side_effect.num-side_effect.absorbed_precursors, side_effect.absorbed_precursors)*' '
                   changed = true
@@ -540,10 +610,10 @@ module ActiveFacts
             reading_words.map! do |phrase|
               if phrase.respond_to?(:player)
                 # phrase.role will be set if this reading was used to make_fact_type.
-                # Otherwise we have to find the existing role via the Variable. This is pretty ugly.
+                # Otherwise we have to find the existing role via the Binding. This is pretty ugly.
                 unless phrase.role
-                  # Find another variable for this phrase which already has a role_ref to the same fact type:
-                  ref = phrase.variable.refs.detect{|ref| ref.role_ref && ref.role_ref.role.fact_type == fact_type}
+                  # Find another binding for this phrase which already has a role_ref to the same fact type:
+                  ref = phrase.binding.refs.detect{|ref| ref.role_ref && ref.role_ref.role.fact_type == fact_type}
                   role_ref = ref.role_ref
                   phrase.role = role_ref.role
                 end
@@ -578,7 +648,8 @@ module ActiveFacts
               existing
               #raise "Reading '#{existing.expand}' already exists, so why are we creating a duplicate?"
             end
-            constellation.Reading(@fact_type, @fact_type.all_reading.size, :role_sequence => @role_sequence, :text => reading_words*" ")
+            r = constellation.Reading(@fact_type, @fact_type.all_reading.size, :role_sequence => @role_sequence, :text => reading_words*" ", :is_negative => (certainty == false))
+            r
           end
         end
 
@@ -649,16 +720,16 @@ module ActiveFacts
             end
             # raise "Reading '#{@reading.expand}' already exists, so why are we creating a duplicate (with #{extra_adjectives.inspect})?"
           else
-            constellation.Reading(@fact_type, @fact_type.all_reading.size, :role_sequence => @role_sequence, :text => reading_text)
+            constellation.Reading(@fact_type, @fact_type.all_reading.size, :role_sequence => @role_sequence, :text => reading_text, :is_negative => (certainty == false))
           end
           @role_sequence
         end
 
         def make_embedded_constraints vocabulary
-          var_refs.each do |var_ref|
-            next unless var_ref.quantifier
-            # puts "Quantifier #{var_ref.inspect} not implemented as a presence constraint"
-            var_ref.make_embedded_presence_constraint vocabulary
+          refs.each do |ref|
+            next unless ref.quantifier
+            # puts "Quantifier #{ref.inspect} not implemented as a presence constraint"
+            ref.make_embedded_presence_constraint vocabulary
           end
 
           if @qualifiers && @qualifiers.size > 0
@@ -675,12 +746,12 @@ module ActiveFacts
             end
 
             # REVISIT: Check maybe and other qualifiers:
-            debug :constraint, "Need to make constraints for #{@qualifiers*', '}" if @qualifiers.size > 0
+            debug :constraint, "Need to make constraints for #{@qualifiers.inspect}" if @qualifiers.size > 0 or @certainty != true
           end
         end
 
         def is_naked_object_type
-          @phrases.size == 1 && var_refs.size == 1
+          @phrases.size == 1 && refs.size == 1
         end
 
       end
@@ -699,7 +770,7 @@ module ActiveFacts
           @common_supertype = common_supertype
           @residual_adjectives = residual_adjectives
           @cancelled_cost = 0
-          debug :matching_fails, "Saving side effects for #{@phrase.term}, absorbs #{@absorbed_precursors}/#{@absorbed_followers}#{@common_supertype ? ', join over supertype '+ @common_supertype.name : ''}" if @absorbed_precursors+@absorbed_followers+(@common_supertype ? 1 : 0) > 0
+          debug :matching_fails, "Saving side effects for #{@phrase.term}, absorbs #{@absorbed_precursors}/#{@absorbed_followers}#{@common_supertype ? ', step over supertype '+ @common_supertype.name : ''}" if @absorbed_precursors+@absorbed_followers+(@common_supertype ? 1 : 0) > 0
         end
 
         def cost
@@ -718,19 +789,23 @@ module ActiveFacts
       class ClauseMatchSideEffects
         attr_reader :residual_adjectives
         attr_reader :fact_type
-        attr_reader :role_side_effects    # One array of values per VarRef matched, in order
+        attr_reader :role_side_effects    # One array of values per Reference matched, in order
+        attr_reader :negated
+        attr_reader :optional
 
-        def initialize fact_type, clause, residual_adjectives, role_side_effects
+        def initialize fact_type, clause, residual_adjectives, role_side_effects, negated = false
           @fact_type = fact_type
           @clause = clause
           @residual_adjectives = residual_adjectives
           @role_side_effects = role_side_effects
+          @negated = negated
         end
 
         def to_s
           'side-effects are [' +
             @role_side_effects.map{|r| r.to_s}*', ' +
             ']' +
+            "#{@negated ? ' negated' : ''}" +
             "#{@residual_adjectives ? ' with residual adjectives' : ''}"
         end
 
@@ -743,29 +818,32 @@ module ActiveFacts
           @role_side_effects.each do |side_effect|
             c += side_effect.cost
           end
-          c + (@residual_adjectives ? 1 : 0)
+          c += 1 if @residual_adjectives
+          c += 2 if @negated
+          c
         end
 
         def describe
           actual_effects =
             @role_side_effects.map do |side_effect|
-              ( [side_effect.common_supertype ? "supertype join over #{side_effect.common_supertype.name}" : nil] +
+              ( [side_effect.common_supertype ? "supertype step over #{side_effect.common_supertype.name}" : nil] +
                 [side_effect.absorbed_precursors > 0 ? "absorbs #{side_effect.absorbed_precursors} preceding words" : nil] +
-                [side_effect.absorbed_followers > 0 ? "absorbs #{side_effect.absorbed_followers} following words" : nil]
+                [side_effect.absorbed_followers > 0 ? "absorbs #{side_effect.absorbed_followers} following words" : nil] +
+                [@negated ? 'implicitly negated' : nil]
               )
             end.flatten.compact*','
           actual_effects.empty? ? "no side effects" : actual_effects
         end
       end
 
-      class VarRef
+      class Reference
         attr_reader :term, :quantifier, :function_call, :value_constraint, :literal, :nested_clauses
         attr_accessor :leading_adjective, :trailing_adjective, :role_name
-        attr_accessor :player     # What ObjectType does the Variable denote
-        attr_accessor :variable   # What Variable for that ObjectType
+        attr_accessor :player     # What ObjectType does the Binding denote
+        attr_accessor :binding    # What Binding for that ObjectType
         attr_accessor :role       # Which Role of this ObjectType
         attr_accessor :role_ref   # Which RoleRef to that Role
-        attr_accessor :clause     # The clause that this VarRef is part of
+        attr_accessor :clause     # The clause that this Reference is part of
         attr_accessor :objectification_of # If nested_clauses is set, this is the fact type it objectifies
         attr_reader :embedded_presence_constraint   # This refers to the ActiveFacts::Metamodel::PresenceConstraint
 
@@ -870,19 +948,19 @@ module ActiveFacts
               role_name = @term
             end
           end
-          @variable = (context.variables[key] ||= Variable.new(@player, role_name))
-          @variable.refs << self
-          @variable
+          @binding = (context.bindings[key] ||= Binding.new(@player, role_name))
+          @binding.refs << self
+          @binding
         end
 
         def unbind context
           # The key has changed.
-          @variable.refs.delete(self)
-          if @variable.refs.empty?
-            # Remove the variable from the context if this was the last reference
-            context.variables.delete_if {|k,v| v == @variable }
+          @binding.refs.delete(self)
+          if @binding.refs.empty?
+            # Remove the binding from the context if this was the last reference
+            context.bindings.delete_if {|k,v| v == @binding }
           end
-          @variable = nil
+          @binding = nil
         end
 
         def rebind(context)
@@ -890,18 +968,18 @@ module ActiveFacts
           bind context
         end
 
-        def rebind_to(context, other_var_ref)
-          debug :binding, "Rebinding #{inspect} to #{other_var_ref.inspect}"
+        def rebind_to(context, other_ref)
+          debug :binding, "Rebinding #{inspect} to #{other_ref.inspect}"
 
-          old_variable = variable   # Remember to move all refs across
+          old_binding = binding   # Remember to move all refs across
           unbind(context)
 
-          new_variable = other_var_ref.variable
-          [self, *old_variable.refs].each do |ref|
-            ref.variable = new_variable
-            new_variable.refs << ref
+          new_binding = other_ref.binding
+          [self, *old_binding.refs].each do |ref|
+            ref.binding = new_binding
+            new_binding.refs << ref
           end
-          old_variable.rebound_to = new_variable
+          old_binding.rebound_to = new_binding
         end
 
         # These are called when we successfully match a fact type reading that has relevant adjectives:
@@ -931,17 +1009,18 @@ module ActiveFacts
 
           debug :constraint, "Processing embedded constraint #{@quantifier.inspect} on #{@role_ref.role.object_type.name} in #{fact_type.describe}" do
             # Preserve the role order of the clause, excluding this role:
-            constrained_roles = (@clause.var_refs-[self]).map{|vr| vr.role_ref.role}
+            constrained_roles = (@clause.refs-[self]).map{|vr| vr.role_ref.role}
             if constrained_roles.empty?
               debug :constraint, "Quantifier over unary role has no effect"
               return
             end
             constraint = find_pc_over_roles(constrained_roles)
             if constraint
-              debug :constraint, "Setting max frequency to #{@quantifier.max} for existing constraint #{constraint.object_id} over #{constraint.role_sequence.describe} in #{fact_type.describe}"
               raise "Conflicting maximum frequency for constraint" if constraint.max_frequency && constraint.max_frequency != @quantifier.max
+              debug :constraint, "Setting max frequency to #{@quantifier.max} for existing constraint #{constraint.object_id} over #{constraint.role_sequence.describe} in #{fact_type.describe}" unless constraint.max_frequency
               constraint.max_frequency = @quantifier.max
               raise "Conflicting minimum frequency for constraint" if constraint.min_frequency && constraint.min_frequency != @quantifier.min
+              debug :constraint, "Setting min frequency to #{@quantifier.min} for existing constraint #{constraint.object_id} over #{constraint.role_sequence.describe} in #{fact_type.describe}" unless constraint.min_frequency
               constraint.min_frequency = @quantifier.min
             else
               role_sequence = constellation.RoleSequence(:new)
@@ -956,7 +1035,7 @@ module ActiveFacts
                   :max_frequency => @quantifier.max,
                   :min_frequency => @quantifier.min
                 )
-              debug :constraint, "Made new PC min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} constraint #{constraint.object_id} over #{(e = fact_type.entity_type) ? e.name : role_sequence.describe} in #{fact_type.describe}"
+              debug :constraint, "Made new embedded PC GUID=#{constraint.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{(e = fact_type.entity_type) ? e.name : role_sequence.describe} in #{fact_type.describe}"
               @quantifier.enforcement.compile(constellation, constraint) if @quantifier.enforcement
               @embedded_presence_constraint = constraint
             end
@@ -982,6 +1061,18 @@ module ActiveFacts
           @context_note = context_note
         end
 
+        def is_unique
+          @max and @max == 1
+        end
+
+        def is_mandatory
+          @min and @min >= 1
+        end
+
+        def is_zero
+          @min == 0 and @max == 0
+        end
+
         def inspect
           "[#{@min}..#{@max}]#{
             @context_note && ' ' + @context_note.inspect