tpmkms 9.8.0 → 9.9.0

package/common/properties.js

@@ -1,5 +1,6 @@
-const { knowledgeModule, where, debug } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where, debug, unflatten, flattens } = require('./runtime').theprogrammablemind
 const { defaultContextCheckProperties, defaultContextCheck, words } = require('./helpers')
+const _ = require('lodash')
 const dialogues = require('./dialogues')
 const hierarchy = require('./hierarchy')
 const meta = require('./meta')
@@ -57,7 +58,7 @@ V2
 //        [
 //          ({objects, context, args, hierarchy}) => 
 //                hierarchy.isA(context.marker, 'property') && 
-//                args({ types: ['myObjectType'], properties: ['object'] }) && context.evaluate, 
+//                args({ types: ['myObjectType'], properties: ['object'] }),
 //          ({objects, context}) => {
 //          context.value = "value" // set the value here somehow
 //          }
@@ -83,9 +84,9 @@ function addPropertyMarker(args) {
       markerWords = [markerWords]
     }
 
-    const { fragments, s, config } = args
+    const { fragments, e, config } = args
     const instance = await fragments("concept is a property", { concept: { marker: property, level: 0, value: property, word: property } })
-    await s(instance)
+    await e(instance, where())
     const propertyMarker = `${property}Marker`
     config.addOperator(`((@<= 'quantity' && context.unit.dimension == ${dimension}) [${propertyMarker}|])`)
     config.addBridge({
@@ -94,8 +95,17 @@ function addPropertyMarker(args) {
       isA: ['adjective', 'propertyMarker', 'queryable'],
       enhanced_associations: true,
       initial: { markedProperty: property },
-      check: defaultContextCheckProperties(['markedProperty']),
-      bridge: `{ ...before[0], checks: append(before.checks, ['repeats']), propertyType: '${property}', : true, isPropertyValue: true, ${property}: operator, interpolate: append(before[0].interpolate, [{ property: '${property}' }]) }`,
+      check: defaultContextCheckProperties(['markedProperty', 'quantity']),
+      bridge: `{ 
+        ...next(operator),
+        quantity: before[0],
+        notConjunctableWith: ['quantity'],
+        checks: append(before.checks, ['repeats']), 
+        propertyType: '${property}', 
+        isPropertyValue: true, 
+        ${property}: operator, 
+        interpolate: append(map(before[0].interpolate, { inside: 'quantity', value: element }), [{ property: '${property}' }]) 
+      }`,
     })
   }
 }
@@ -127,60 +137,106 @@ const config = {
     // the plural of cat is cats what is the plural of cat?
     // does greg have ears (yes) greg does not have ears does greg have ears (no)
     // TODO fix @=unknown does not work?!??
-    "((@<= object || @<=unknown) [hasPropertyValue|is] (context.isPropertyValue == true))",
+    "([isPropertyValue])",
+    "((@<= object || @<=unknown) [hasPropertyValue|is,are] (context.isPropertyValue == true))",
   ],
   // TODO remove these and use localHierarchy if needed
   hierarchy: [
     ['unknown', 'hierarchyAble'],
     ['what', 'object'],
+    ['who', 'object'],
   ],
   bridges: [
     {
+      where: where(),
       id: 'howPropertyMarker',
       bridge: "{ ...after[0], query: ['what'], how: operator, operator: after[0], interpolate: [ { property: 'how' }, { property: 'operator' } ] }",
     },
     {
+      where: where(),
+      id: 'isPropertyValue',
+      initial: { isPropertyValue: true },
+    },
+    {
+      where: where(),
       id: 'hasPropertyValue',
       isA: ['verb'],
       preferOver: ['is'],
       enhanced_associations: true,
       bridge: "{ ...operator, object: before[0], flatten: true, operator: operator, propertyValue: after[0], interpolate: [{ property: 'object' }, { property: 'operator' }, { property: 'propertyValue' }] }",
-      semantic: async ({context, e, fragments}) => {
-        const propertyType = {
-          marker: context.propertyValue.propertyType,
-          level: 0,
-          value: context.propertyValue.propertyType,
-        }
+      semantic: async ({gp, context, api, callId, e, debug, toArray, fragments, resolveEvaluate, getWordFromDictionary}) => {
+        // TODO is there some way to make lookup up and setting the value into the same operation?
+        if (context.query) {
+          const propertyId = context.propertyValue.markedProperty
+          const object = context.object
+          const value = context.propertyValue
+          const pattern = {
+            marker: 'propertyRelation',
+            object,
+            property: { marker: propertyId, value: propertyId },
+            value,
+          }
+
+          const relations = await api.relation_unify(pattern, ['object', 'property', 'value'])
+
+          relations.forEach((r) => {
+            r.objectPropertyValueStyle = {
+              template: "object is isPropertyValue",
+              mapping: {
+                object: 'object',
+                isPropertyValue: 'value',
+              }
+            }
+          })
 
-        const instance = await fragments("the property of object is value", { property: propertyType, object: context.object, value: context.propertyValue })
-        await e(instance)
+          resolveEvaluate(context, relations)
+        } else {
+          const propertyType = {
+            marker: context.propertyValue.propertyType,
+            level: 0,
+            word: context.propertyValue.propertyType,
+            value: context.propertyValue.propertyType,
+          }
+          for (const object of toArray(context.object)) {
+            const instance = await fragments("the property of object is value", { property: propertyType, object, value: context.propertyValue })
+            const text = await gp(instance)
+            instance.query = context.query
+            await e(instance, where())
+          }
+        }
       }
     },
 
     { 
+      where: where(),
       id: 'propertyRelation', 
       // scope: 'development',
       words: words('propertyRelation'),
-      evaluator: ({context, api, objects, toList}) => {
+      semantic: ({context, api, objects, toList}) => {
         context.evalue = toList(objects.relations)
         context.evalue.isResponse = true
         context.evalue.paraphrase = false
       }
     },
     { 
+      where: where(),
       id: 'propertyMarker', 
     },
     { 
+      where: where(),
       id: 'xfx', 
       isA: ['queryable'],
     },
     { 
+      where: where(),
       id: 'between', 
       isA: ['preposition'],
       enhanced_associations: false,
       bridge: "{ ...next(operator), arguments: after[0] }" 
     },
-    { id: 'between', level: 1, bridge: "{ ...before[0], arguments: operator.arguments }" },
+    { 
+      where: where(),
+      id: 'between', level: 1, bridge: "{ ...before[0], arguments: operator.arguments }" },
 
     { 
       id: 'hierarchyAble', 
@@ -209,14 +265,6 @@ const config = {
       localHierarchy: [['property', 'queryable'], ['property', 'theAble'], ['property', 'unknown']],
       bridge: "{ ...next(operator) }" 
     },
-    /*
-    { 
-      id: "property", 
-      words: ['properties'],
-      isA: ['queryable', 'theAble'],
-      level: 0, 
-    },
-    */
     { 
       id: "object", 
       isA: ['queryable', 'theAble', 'listable'],
@@ -317,6 +365,137 @@ const config = {
     { "context": [['what', 0], ['is', 0], ['objectPrefix', 0], ], "choose": [0] }, 
   ],
   generators: [
+    {
+      where: where(),
+      match: ({context, hierarchy}) => context.objectPropertyValueStyle,
+      apply: async ({context, fragments, gp}) => {
+        const mapping = {}
+        for (const key of Object.keys(context.objectPropertyValueStyle.mapping)) {
+          mapping[key] = context[context.objectPropertyValueStyle.mapping[key]]
+        }
+        const fragment = await fragments(context.objectPropertyValueStyle.template, mapping)
+        return await gp(fragment)
+      }
+    },
+    {
+      where: where(),
+      // match: ({context}) => context.marker == 'propertyRelation' && !context.paraphrase,
+        // paraphrase: evaluate propertyrelation
+        // response: 23 years old of bob is 23 years old
+      match: ({context}) => context.marker == 'propertyRelation',
+        // paraphrase: evaluate object's property
+        // response: bob's age is 23 years old
+      match: ({context}) => context.marker == 'propertyRelation' && context.isResponse,
+      apply: async ({context, gp, fragments}) => {
+        const instance = await fragments("the property of object", {
+          // property: { ...context.property, interpolate: undefined },
+          property: context.property,
+          object: context.object
+        }, ['interpolate'])
+        return await gp(instance)
+      }
+    },
+    {
+      notes: 'ordering generator for response',
+      match: ({context}) => (context.orderingArgs && Object.keys(context.orderingArgs).length !== 0) && context.evalue && context.isResponse,
+      apply: async ({context, e, g, km, flatten}) => {
+        const brief = km("dialogues").api.getBrief()
+
+        let { evalue } = context
+        let yesno = ''
+        let hasVariables = false
+        if (context.focusable) {
+          for (const f of context.focusable) {
+            if (context[f].query) {
+              hasVariables = true
+              break
+            }
+          }
+        }
+
+        if (evalue.truthValueOnly || context.truthValueOnly || context.wantsTruthValue || !hasVariables) {
+          function any(value, test) {
+            if (test(value)) {
+              return true
+            }
+            const values = flatten(['list'], value)
+            for (const value of values) {
+              if (test(value)) {
+                return true
+              }
+            }
+          }
+          if (any(evalue, (value) => value.truthValue)) {
+            yesno = 'yes'
+          } else if (evalue.truthValue === false || context.truthValueOnly) {
+            yesno = 'no'
+          }
+        }
+        if (evalue.truthValueOnly) {
+          return `${yesno}`
+        } else {
+          if (context.voice) {
+            evalue = await e({ ...evalue, toVoice: context.voice, flatten: false}, where())
+          }
+
+          const details = await g(Object.assign({}, evalue, { paraphrase: true }))
+          if (yesno) {
+            return `${yesno} ${details}`
+          }
+          else {
+            return details
+          }
+        }
+      }
+    },
+
+    {
+      match: ({context}) => {
+        if (context.do && context.paraphrase) {
+          const left = context['do'].left
+          if (context[left]) {
+            // who owns X should not be 'does who own x' but instead 'who owns x'
+            if (context[left].query) {
+              return true;
+            }
+          }
+        }
+
+        return false;
+      },
+
+      apply: async ({context, g, gw}) => {
+        const chosen = await(gw({ number: context.number, word: context.word, isVerb: true}))
+        return `${await g(context[context.do.left])} ${chosen} ${await g(context[context.do.right])}`
+      }
+    },
+
+    {
+      match: ({context}) => context.isEd,
+      apply: async ({context, g}) => {
+        const chosen = chooseNumber(context[context.afterTag], 'is', 'are')
+        if (context[context.beforeTag].evalue && context[context.beforeTag].evalue.marker === 'undefined') {
+          return await g(context[context.beforeTag])
+        }
+        return `${await g(context[context.afterTag])} ${chosen} ${context.word} by ${await g(context[context.beforeTag])}`
+      }
+    },
+
+    {
+      notes: 'generator for constraint',
+      match: ({context}) => context.paraphrase && context.constrained,
+      apply: async ({callId, context, g}) => {
+        if (context[context.beforeTag].marker == 'by') {
+          // the cat wendy owned
+          return `${await g({...context[context.afterTag], paraphrase: true})} ${context.word} ${await g({...context[context.beforeTag], paraphrase: true})}`
+        } else {
+          // the cat owned by wendy
+          return `${await g({...context[context.afterTag], paraphrase: true})} ${context.word} ${['by', await g({...context[context.beforeTag], paraphrase: true})].filter((t) => t).join(' ')}`
+        }
+      },
+    },
+
+
     {
       notes: 'expression with constraints',
       where: where(),
@@ -333,11 +512,7 @@ const config = {
         const paraphrase = Object.assign({}, constraint.paraphrase)
         paraphrase.paraphrase = true;
         paraphrase[constraint.property] = property
-        if (false && context.isResponse) {
-          return await g({...constraint.paraphrase, paraphrase: true})
-        } else {
-          return await g(constrained)
-        }
+        return await g(constrained)
       },
     },
     {
@@ -437,9 +612,8 @@ const config = {
              },
     },
     {
-      // ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.value && !context.evaluate,
       where: where(),
-      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.possession && !context.evaluate && !context.object.marker == 'objectPrefix',
+      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.possession && context.paraphrase && !context.object.marker == 'objectPrefix',
       apply: async ({context, g}) => {
         const property = Object.assign({}, context, { object: undefined })
         return `${await g(property)} of ${await g({ ...context.object, paraphrase: true })}`
@@ -451,7 +625,7 @@ const config = {
       // match: ({context}) => context.paraphrase && !context.modifiers && context.object, 
       match: ({context}) => !context.modifiers && (context.object || context.objects) && !context.interpolate, 
       apply: async ({context, g, gs}) => {
-        if (context.evalue) {
+        if (context.evalue && !context.paraphrase) {
           return await g(context.evalue)
         } else if (context.objects) {
           const objects = [ ...context.objects ]
@@ -477,12 +651,237 @@ const config = {
     },
   ],
   semantics: [
+    {
+      notes: 'unify for properties -> the age of who',
+      where: where(),
+      match: ({context, isA}) => 
+        context.marker == 'unify' && 
+        context.terms?.some((term) => {
+          return term.objects && isA(term.objects[0], 'property') && term.query
+        }),
+      apply: async (args) => {
+        const {context, km, callId, api, resolveEvaluate} = args
+        let value, property, object
+        if (context.terms[0].query) {
+          property = context.terms[0].objects[0]
+          object = context.terms[0].objects[1]
+          value = context.terms[1]
+        } else {
+          property = context.terms[1].objects[0]
+          object = context.terms[1].objects[1]
+          value = context.terms[0]
+        }
+        const pattern = {
+          marker: 'propertyRelation',
+          object,
+          property,
+          value,
+        }
+        const relations = await api.relation_unify(pattern, ['object', 'property', 'value'])
+
+        relations.forEach((r) => {
+          r.objectPropertyValueStyle = {
+            template: "the property of object",
+            mapping: {
+              object: 'object',
+              property: 'property',
+            }
+          }
+        })
+
+        resolveEvaluate(context, relations)
+      }
+    },
+    {
+      notes: 'unify for properties -> whose age',
+      where: where(),
+      match: ({context, isA}) => {
+        return context.marker == 'unify' && context.terms[0].whose && context.terms[1].markedProperty == context.terms[0].value
+      },
+      apply: async (args) => {
+        const {context, km, callId, api, fragments, resolveEvaluate} = args
+        let value, property, object
+        if (context.terms[0].query) {
+          property = { ...context.terms[0] },
+          object = { marker: 'who', value: 'who' }
+          value = context.terms[1]
+        } else {
+          property = { ...context.terms[1] }
+          object = { marker: 'who', value: 'who' }
+          value = context.terms[0]
+        }
+        property = await fragments("the property", { property }, ['interpolate'])
+        
+        const pattern = {
+          marker: 'propertyRelation',
+          object,
+          property,
+          value,
+        }
+
+        const relations = await api.relation_unify(pattern, ['object', 'property', 'value'])
+        relations.forEach((r) => {
+          r.objectPropertyValueStyle = {
+            template: "object's property",
+            mapping: {
+              object: 'object',
+              property: 'property',
+              value: 'value',
+            }
+          }
+          r.property = { ...r.property, determiner: null }
+        })
+       
+        const text = await args.gp(relations[0]) // 'the age is 23 years old'
+        resolveEvaluate(context, relations)
+      }
+    },
+    {
+      notes: 'getter for relation based verbs',
+      match: ({context}) => context.relationBacked && context.query,
+      apply: ({context, km, callId}) => {
+        const api = km('properties').api
+        context.evalue = {
+          marker: 'list',
+          listable: true,
+          value: unflatten(api.relation_get(context, context.relationArgs.map( (arg) => arg.tag ) ))
+        }
+        context.evalue.isResponse = true
+        context.isResponse = true
+        if (context.evalue.value.length == 0) {
+          context.evalue.marker = 'undefined';
+          context.evalue.listable = true
+          context.evalue.value = [];
+        } else {
+          // context.evalue.truthValue = true
+        }
+      }
+    },
+
+    {
+      notes: `setter for relation based verbs`,
+      match: ({context}) => context.relationBacked && !context.toVoice && context.isVerb,
+      apply: ({context, km, hierarchy, config}) => {
+        const api = km('properties').api
+        // add types for arguments
+        for (const argument of context.focusable || []) {
+          const value = api.toValue(context[argument])
+          if (value) {
+            const minimas = hierarchy.minima(context[argument].types)
+            for (const type of minimas) {
+              if (config.exists(value)) {
+                config.addHierarchy(value, type);
+              }
+            }
+          }
+        }
+        api.relation_add(context)
+      }
+    },
+    {
+      notes: 'ordering query',
+      match: ({context}) => context.query && (context.orderingArgs && Object.keys(context.orderingArgs).length !== 0),
+      apply: ({context, km}) => {
+        const api = km('ordering').api
+        const propertiesAPI = km('properties').api
+        context.ordering = context.orderingArgs.name
+        const matches = propertiesAPI.relation_get(context, ['ordering', context.orderingArgs.object, context.orderingArgs.category])
+        if (matches.length > 0 || (typeof context.query == 'boolean' && context.query)) {
+          // does greg like bananas
+          if (matches.length == 0) {
+            const response = _.clone(context)
+            response.isResponse = true
+            response.query = undefined
+            context.evalue = { marker: 'list', listable: true, value: [response] }
+          } else {
+            context.evalue = { marker: 'list', listable: true, value: unflatten(matches) }
+            context.evalue.isResponse = true
+          }
+          context.evalue.truthValue = matches.length > 0
+          context.evalue.truth = { marker: 'yesno', value: matches.length > 0, isResponse: true, focus: true }
+          context.evalue.focusable = ['truth']
+          if (!context.evalue.truthValue) {
+            context.evalue.truthValueOnly = true
+          }
+
+          // ADD this line back and remove it to check
+          // context.response = { marker: 'list', listable: true, value: [response], isResponse: true }
+          // Object.assign(context, { marker: 'list', listable: true, value: responses, focusable: ['value'], paraphrase: true, truthValue: matches.length > 0 })
+        } else {
+          // see if anything is preferred greg
+          // what does greg like
+          const matches = propertiesAPI.relation_get(context, ['ordering', context.orderingArgs.object])
+          if (matches.length == 0) {
+            // Object.assign(context, { marker: 'idontknow', query: _.clone(context) })
+            context.evalue = { marker: 'idontknow', query: _.clone(context), isResponse: true }
+          } else {
+            context.evalue = { marker: 'list', listable: true, value: matches, isResponse: true }
+          }
+          context.isResponse = true
+          context.evalue.truthValue = matches.length > 0 && matches[0].marker == context.orderingArgs.marker
+        }
+      }
+    },
+
+    {
+          notes: 'ordering setter',
+        // TODO use hierarchy for operator
+        // match: ({context}) => context.marker == operator,
+        match: ({context}) => (context.orderingArgs && Object.keys(context.orderingArgs).length !== 0),
+        apply: ({context, km}) => {
+          const propertiesAPI = km('properties').api
+          context.ordering = context.orderingArgs.name
+          const fcontexts = flattens(['list'], [context])
+          for (const fcontext of fcontexts) {
+            fcontext.paraphrase = true
+            fcontext[context.orderingArgs.object].paraphrase = true
+            fcontext[context.orderingArgs.category].paraphrase = true
+          }
+          propertiesAPI.relation_add(fcontexts)
+        }
+    },
+    {
+      notes: 'semantic for setting value with constraint',
+      //match: ({context, isA}) => isA(context.marker, after[0].tag) && context.constraints,
+      match: ({context, isA}) => context.constraints,
+      apply: async ({km, context, e, log, isA}) => {
+        const constraint = context.constraints[0];
+        const value = constraint.constraint;
+        let property = constraint.property;
+        const properties = constraint.properties;
+        for (const p of properties) {
+          if (value[p].concept) {
+            property = p
+            // constraint.property = p; // set what is used
+            constraint.property = {...constraint.property, ...p}; // set what is used
+
+          }
+        }
+        // value.marker = 'owns'
+        // value.greg = true
+        // value.ownee.query = true
+        value.query = true
+        value.greg99 = 23
+        const instance = await e(value, where())
+        if (instance.verbatim) {
+          context.evalue = { verbatim: instance.verbatim }
+          return
+        }
+        if (instance.evalue.marker === 'undefined') {
+          context.evalue = instance.evalue
+          return
+        }
+        const selected = instance.evalue.value.map( (r) => r[property] )
+        context.constraints = undefined;
+        context.evalue = { marker: 'list', listable: true, value: selected }
+      },
+    },
     {
       where: where(),
       notes: "how deep is the pool",
       priority: -1,
       match: ({context}) => context.marker == 'is' && (context.one.how || context.two.how),
-      apply: async ({ resolveResponse, g, context, toArray, toList, fragments, kms, e, toEValue }) => {
+      apply: async ({ resolveEvaluate, g, context, toArray, toList, fragments, kms, e, toEValue }) => {
         const propertyMarkerContext = context.one
         let object = context.two
         if (context.two.how) {
@@ -496,20 +895,20 @@ const config = {
           properties.push({ marker: property, value: property, word: property })
         }
         const propertyOfObject = await fragments("the property of object", { property: toList(properties, true), object })
-        const value = toEValue(await e(propertyOfObject))
+        const value = toEValue(await e(propertyOfObject, where()))
         value.focusableForPhrase = true
         propertyOfObject.focusableForPhrase = false
         const response = await fragments("the property is value", { property: propertyOfObject, value })
         response.isResponse = true
-        resolveResponse(context, response) 
+        resolveEvaluate(context, response) 
       }
     },
     {
       where: where(),
-      match: ({context}) => context.marker == 'concept' && context.same,
+      match: ({context}) => context.marker == 'same' && context.one.marker == 'concept',
       apply: async (args) => {
         const {context} = args
-        await args.makeObject({ ...args, context: context.same })
+        await args.makeObject({ ...args, context: context.two})
         context.sameWasProcessed = true
       }
     },
@@ -517,13 +916,14 @@ const config = {
       // TODO maybe use the dialogue management to get params
       notes: 'wants is xfx between wanter and wantee',
       where: where(),
-      match: ({context}) => context.same && context.same.marker == 'xfx',
+      match: ({context}) => context.marker == 'same' && context.two.marker == 'xfx',
       // debug: 'call3',
       apply: ({context, km, config}) => {
         const papi = km('properties').api
-        const singular = pluralize.singular(context.word)
-        const plural = pluralize.plural(context.word)
-        const args = context.same.arguments.value;
+        const { one, two } = context
+        const singular = pluralize.singular(one.word)
+        const plural = pluralize.plural(one.word)
+        const args = two.arguments.value;
         papi.createBinaryRelation(config, singular, [singular, plural], args[0].word, args[1].word)
       },
       priority: -1,
@@ -531,9 +931,9 @@ const config = {
     {
       notes: 'marking something as readonly',
       where: where(),
-      match: ({context}) => context.same && context.same.marker == 'readonly',
+      match: ({context}) => context.marker == 'same' && context.two.marker == 'readonly',
       apply: ({context, km, objects}) => {
-        km('properties').api.setReadOnly([context.value]) 
+        km('properties').api.setReadOnly([context.one.value]) 
         context.sameWasProcessed = true
       }
     },
@@ -556,19 +956,15 @@ const config = {
       notes: 'crew members. evaluate a concepts to get instances',
       where: where(),
       match: ({context, hierarchy, api, isA}) => 
-                          // (hierarchy.isA(context.marker, 'concept') && !hierarchy.isA(context.marker, 'property')) &&
-                          // concept unless its a property then use the property handler unless its a dimension "unit of dimension" acts like hierarchy
-                          // hierarchy.isA(context.marker, 'concept') && ((!context.propertyOf && !context.isProperty) || isA(context.object, 'dimension')) &&
                           hierarchy.isA(context.marker, 'concept') && ((!context.propertyOf && !context.isProperty) || isA(context.objects[context.objects.length-1], 'dimension')) &&
                           (!context.pullFromContext || context.number == 'many') &&
-                          context.evaluate &&
+                          (context.pullFromContext || isA(context, 'type') || context.metaDefinition) &&
                           !(context.types || []).includes('property') &&
                           // !context.value &&  // greghere
                           !context.ordinal &&
-                          (!context.objects || context.objects.length !== 2 || !context.objects[1].instance) &&
-                          (api.objects && api.objects.children && api.objects.children[context.marker]) &&
-                          !context.evaluate.toConcept,
-      apply: ({context, hierarchy, objects, api, km}) => {
+                          (!context.objects || context.objects.length !== 2 || !context.objects[1].isInstance) &&
+                          (api.objects && api.objects.children && api.objects.children[context.marker]),
+      apply: ({context, isA, contextHierarchy, hierarchy, objects, api, km}) => {
         const values = api.objects.children[context.marker]
         const phrases = values.map( (value) => km('concept').api.getWordForValue(value) )
         // context.focusableForPhrase = true
@@ -586,11 +982,18 @@ const config = {
       where: where(),
       match: ({context}) => context.marker == 'have' && !context.query,
       apply: ({context, objects, api}) => {
+        if (context.object.unknown) {
+          context.object.value = pluralize.singular(context.object.value)
+        }
+        if (context.property.unknown) {
+          context.property.value = pluralize.singular(context.property.value)
+        }
         if (context.negation) {
-          api.setProperty(pluralize.singular(context.object.value), pluralize.singular(context.property.value), null, false)
+          api.setProperty(context.object, context.property, null, false)
         } else {
-          api.setProperty(pluralize.singular(context.object.value), pluralize.singular(context.property.value), null, true)
+          api.setProperty(context.object, context.property, null, true)
         }
+        // TODO delete this?
         context.sameWasProcessed = true
       }
     },
@@ -598,12 +1001,13 @@ const config = {
       notes: 'greg has eyes?',
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'have') && context.query,
-      apply: async ({context, g, api, objects}) => {
+      apply: async ({error, context, g, api, objects}) => {
         const object = pluralize.singular(context.object.value);
         const property = pluralize.singular(context.property.value);
         context.isResponse = true
         if (!await api.knownObject(object)) {
-          context.verbatim = `There is no object named ${await g({...context.object, paraphrase: true})}`
+          // context.verbatim = `There is no object named ${await g({...context.object, paraphrase: true})}`
+          error(`there is no object named ${await g({...context.object, paraphrase: true})}`)
           return
         }
         if (!await api.hasProperty(object, property)) {
@@ -623,26 +1027,31 @@ const config = {
     {
       notes: 'set the property of an object',
       where: where(),
-      // match: ({context}) => context.marker == 'property' && context.same && context.object,
-      match: ({context, hierarchy, uuid}) => hierarchy.isA(context.marker, 'property') && context.same && context.objects && !context[`disable${uuid}`],
+      match: async (args) => await args.callOnce(args, 'properties.1', ({context, hierarchy, uuid}) => 
+        context.marker == 'same' && 
+        hierarchy.isA(context.one.marker, 'property') && 
+        context.one.objects),
       apply: async (args) => {
         const {context, fragments, objects, km, api, log, s, uuid} = args
-        const objectContext = context.objects[context.objects.length-1];
-        const propertyContext = context;
-        const objectId = objectContext.unknown ? pluralize.singular(objectContext.value) : objectContext.value
+        const objectContext = context.one.objects[context.one.objects.length-1];
+        const propertyContext = context.one.objects[0];
+        // const propertyContext = context.one;
+        if (objectContext.unknown) {
+          objectContext.value = pluralize.singular(objectContext.value)
+        }
+        const objectId = objectContext.value
 
         await api.makeObject({ ...args, context: objectContext })
         await api.makeObject({ ...args, context: propertyContext })
-        propertyContext[`disable${uuid}`] = true
-        const propertyId = (await km("dialogues").api.evaluateToConcept(propertyContext, context, log, s)).evalue;
+        const propertyId = propertyContext.value
         try {
-          api.setProperty(objectId, propertyId, context.same, true)
+          api.setProperty(objectContext, propertyContext, context.two, true)
           context.sameWasProcessed = true
         } catch (e) {
           log(`Error processing set property of an object: ${e}`)
           const config = km('properties')
           const value = await api.getProperty(objectId, propertyId)
-          if (value?.value == context.same?.value) {
+          if (value?.value == context.two?.value) {
             context.evalue = [
               { marker: 'yesno', value: true, paraphrase: true },
             ]
@@ -670,10 +1079,9 @@ const config = {
       notes: 'get/evaluate a property',
       where: where(),
       match: ({context, hierarchy, toArray}) => {
-        return (toArray(context).every((value) => hierarchy.isA(value.marker, 'property')) || (hierarchy.isA(context.marker, 'list') && context.possession)) && context.evaluate && context.objects && !context.evaluate.toConcept
+        return (toArray(context).every((value) => hierarchy.isA(value.marker, 'property')) || (hierarchy.isA(context.marker, 'list') && context.possession)) && context.objects
       },
-      // match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.evaluate,
-      apply: async ({debug, isA, hierarchy, getWordFromDictionary, flatten, asList, context, api, kms, objects, g, s, log, recall}) => {
+      apply: async ({stack, error, debug, isA, hierarchy, getWordFromDictionary, flatten, asList, context, api, kms, objects, g, gp, s, log, recall}) => {
         async function toValue(objectContext) {
           if (!objectContext.value) {
             return objectContext;
@@ -707,7 +1115,9 @@ const config = {
 
               const propertyPhrase = await g({...nextContext, paraphrase: true})
               const objectPhrase = await g({...currentContext, paraphrase: true})
-              context.verbatim = `There is no interpretation for "${propertyPhrase} of ${objectPhrase}"`
+              // context.verbatim = `There is no interpretation for "${propertyPhrase} of ${objectPhrase}"`
+              error(`There is no interpretation for "${propertyPhrase} of ${objectPhrase}"`)
+
               return
             }
 
@@ -725,7 +1135,13 @@ const config = {
                 fromMentions = await recall({ context: nextContext, all: nextContext.number == 'many', frameOfReference: currentContext })
               }
               if (!fromMentions) {
-                context.verbatim = `There is no property ${await g({...nextContext, paraphrase: true})} of ${await g({...currentContext, paraphrase: true})}`
+                if (!currentValue && currentContext.unknown) {
+                  // context.verbatim = `What "${await gp(currentContext)}" means is unknown`
+                  context.verbatim = `What "${await gp(currentContext)}" means is unknown`
+                } else {
+                  // context.verbatim = `There is no property ${await g({...nextContext, paraphrase: true})} of ${await g({...currentContext, paraphrase: true})}`
+                  error(`There is no property ${await g({...nextContext, paraphrase: true})} of ${await g({...currentContext, paraphrase: true})}`)
+                }
                 return
               }
             }
@@ -733,7 +1149,7 @@ const config = {
               currentContext = fromMentions
               currentValue = fromMentions // TODO not sure what is right here so just do something and fix when actually needed SOP
             } else {
-              currentContext = await api.getProperty(currentValue, nextValue, g)
+              currentContext = await api.getProperty(currentValue, nextValue)
               currentValue = currentContext.value
             }
           }
@@ -756,7 +1172,7 @@ const config = {
           context.evalue = asList(results, true)
           context.object = undefined;
         } else {
-          context.evalue = { marker: 'answerNotKnown' }
+          context.evalue = { marker: 'undefined' }
           context.object = undefined;
         }
       }
@@ -772,12 +1188,6 @@ function initializer({objects, config, isModule}) {
 }
 
 const template = {
-  fragments: [
-    "the property1 of object1 is value1",
-    "the property of object is value",
-    "the property of object",
-    "the property is value",
-  ],
   configs: [
     "property is a concept",
     { query: "concept is a property", isFragment: true },
@@ -795,6 +1205,14 @@ const template = {
         },
       ],
     },
+    { query: "the property1 of object1 is value1", isFragment: true },
+    { query: "the property of object is value", isFragment: true },
+    { query: "the property of object", isFragment: true, preserve: ['interpolate'] },
+    { query: "the property is value", isFragment: true },
+    { query: "object's property", isFragment: true, preserve: ['interpolate'] },
+    { query: "object's property is value", isFragment: true, preserve: ['one.interpolate'] },
+    { query: "object is isPropertyValue", isFragment: true }, // bob is 23 years old
+    { query: "the property", isFragment: true },
   ],
 }