tpmkms 9.8.0 → 9.9.0

package/common/helpers/properties.js

@@ -3,7 +3,7 @@ const { conjugateVerb } = require('../english_helpers')
 const { unflatten, flattens, Digraph } = require('../runtime').theprogrammablemind
 const _ = require('lodash')
 const deepEqual = require('deep-equal')
-const { chooseNumber, removeProp } = require('../helpers.js')
+const { chooseNumber } = require('../helpers.js')
 const { Frankenhash } = require('./frankenhash.js')
 const { compose, translationMapping, translationMappingToInstantiatorMappings } = require('./meta.js')
 
@@ -117,9 +117,14 @@ class API {
              id: edAble.operator,
              level: 0,
              localHierarchy,
+             isEd: true,
              bridge: `{ 
                ...before, 
                marker: operator('${after[0].tag}'),
+               isEdProperties: ['${after[0].tag}', '${before[0].tag}'], 
+               relationBacked: ${relation ? true : false},
+               orderingArgs: ${JSON.stringify(ordering)},
+               relationArgs: ${JSON.stringify([...before, ...after])},
                constraints: [ 
                     { 
                        property: '${after[0].tag}', 
@@ -129,95 +134,28 @@ class API {
                           { 
                             ...next(operator), 
                             constrained: true, 
+                            beforeTag: "${before[0].tag}",
+                            afterTag: "${after[0].tag}",
                             ${before[0].tag}: default(after[0].object, after[0]), 
                             ${after[0].tag}: { ...before[0] }
                           } 
                     }
                ] }`,
-             deferred: `{ ...next(operator), 'isEd': true, subject: 'ownee', '${after[0].tag}': { operator: operator, number: operator.number, ...before[0] }, ${before[0].tag}: after[0].object }` })
+             deferred: `{ 
+               ...next(operator), 
+               isEd: true, 
+               subject: 'ownee', 
+               beforeTag: "${before[0].tag}",
+               afterTag: "${after[0].tag}",
+               '${after[0].tag}': { operator: operator, number: operator.number, ...before[0] }, 
+               ${before[0].tag}: after[0].object 
+             }` 
+    })
     // TODO have a prepositions category and underPrep category
     config.addHierarchy(edAble.operator, 'isEdAble')
     config.addHierarchy(before[0].id, 'isEder')
     config.addHierarchy(after[0].id, 'isEdee')
     config.addHierarchy('isEdee', 'queryable')
-    config.addSemantic({
-      notes: 'semantic for setting value with constraint',
-      match: ({context, isA}) => isA(context.marker, after[0].tag) && context.evaluate && context.constraints,
-      // match: ({context, isA}) => context.marker == after[0].tag && context.evaluate,
-      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
-          }
-        }
-        // value.marker = 'owns'
-        // value.greg = true
-        // value.ownee.query = true
-        value.query = true
-        const instance = await e(value)
-        if (instance.verbatim) {
-          context.evalue = { verbatim: instance.verbatim }
-          return
-        }
-        if (instance.evalue.marker == 'answerNotKnown') {
-          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 }
-      },
-    })
-    config.addGenerator({
-      notes: 'generator for constraint',
-      match: ({context}) => context.marker == edAble.operator && context.paraphrase && context.constrained,
-      apply: async ({context, g}) => {
-        if (context[before[0].tag].marker == 'by') {
-          // the cat wendy owned
-          return `${await g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${await g({...context[before[0].tag], paraphrase: true})}`
-        } else {
-          // the cat owned by wendy
-          return `${await g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${['by', await g({...context[before[0].tag], paraphrase: true})].filter((t) => t).join(' ')}`
-        }
-      },
-    })
-    config.addGenerator({
-      match: ({context}) => {
-        if (context.marker == operator && context.paraphrase) {
-          if (context['do']) {
-            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}) => {
-        const chosen = chooseNumber(context, word.singular, word.plural)
-        return `${await g(context[before[0].tag])} ${chosen} ${await g(context[after[0].tag])}`
-      }
-    })
-    config.addGenerator({
-      match: ({context}) => context.marker == edAble.operator && context.isEd,
-      apply: async ({context, g}) => {
-        const chosen = chooseNumber(context[after[0].tag], 'is', 'are')
-        if (context[before[0].tag].evalue && context[before[0].tag].evalue.marker == 'answerNotKnown') {
-          return await g(context[before[0].tag])
-        }
-        return `${await g(context[after[0].tag])} ${chosen} ${edAble.word} by ${await g(context[before[0].tag])}`
-      }
-    })
-
     {
       const whoIsWhatVerbedBy = `${before[0].tag}var is ${after[0].tag}var ${edAble.word} by`
       const thisIsVerbedByThat = `${after[0].tag}var is ${edAble.word} by ${before[0].tag}var`
@@ -226,25 +164,16 @@ class API {
       // config.addFragments([whoIsWhatVerbedBy])
       config.addFragments([
           whoIsWhatVerbedBy, 
-          {
-            /*
-            hierarchy: [
-              ['owneevar', 'ownee']
-            ],
-            */
-            query: thisIsVerbedByThat
-          },
+          thisIsVerbedByThat,
       ])
       
-      // config.addHierarchy({ child: 'owneeVar', parent: 'isEdee', maybe: true})
-      // config.addHierarchy({ child: 'ownerVar', parent: 'isEder', maybe: true})
-      // config.addFragments([`${before[0].tag}Var is ${after[0].tag}Var ${edAble.word} by`, `${after[0].tag}Var is ${edAble.word} by ${before[0].tag}Var`])
-      // config.addFragments(["ownerVar is owneeVar owned by", "owneeVar is owned by ownerVar"])
-
       const generator = {
         notes: `generator for who/what is X owned by`,
-        // match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.one && context.one.marker == 'ownee' && context.one.constraints && context.one.constraints[0] && context.one.constraints[0].constraint.marker == 'owned' && context.one.constraints[0].constraint.owner.implicit,
-        match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.one && context.one.marker == after[0].tag && context.one.constraints && context.one.constraints[0] && context.one.constraints[0].constraint.marker == edAble.operator && context.one.constraints[0].constraint[before[0].tag].implicit,
+        match: ({context, hierarchy}) => 
+            hierarchy.isA(context.marker, 'is') && 
+            context.one?.isEdProperties &&
+            context.one?.constraints[0].constraint.beforeTag && 
+            context.one?.constraints[0].constraint[context.one.constraints[0].constraint.beforeTag].implicit,
         apply: async ({context, fragments, g, gs, callId}) => {
           const isToFromM = [{"from":["one"],"to":["two"]},{"from":["two"],"to":["one"]}]
           const fromF = (await fragments(whoIsWhatVerbedBy)).contexts()[0]
@@ -259,7 +188,6 @@ class API {
               '[{"from":["two"],"to":["owner"]},{"from":["one"],"to":["ownee"]},{"from":["number"],"to":["number"]}]'
           */
           const tmPrime = compose(isToFromM, tm)
-          // const from = context.one.constraints[0].constraint
           const from = context
           const im = translationMappingToInstantiatorMappings(tmPrime, from, to)
           const translation = await toF.instantiate(im)
@@ -291,7 +219,7 @@ class API {
       config, 
       localHierarchy=[], 
       relation, 
-      ordering, 
+      ordering={}, 
       doAble, 
       flatten,
       can,
@@ -343,23 +271,12 @@ class API {
       config.addOperator({ pattern: `(${beforeOperators} [${operator}|] ${afterOperators})`, allowDups: true })
     }
 
-    if (false) {
-      for (const argument of before.concat(after)) {
-        if (create.includes(argument.id)) {
-          // config.addHierarchy('unknown', argument.id)
-          // config.addHierarchy('what', argument.id)
-          config.addHierarchy(argument.id, 'unknown')
-          config.addHierarchy(argument.id, 'what')
-        }
-      } 
-    } else {
-      for (const argument of before.concat(after)) {
-        if (create.includes(argument.id)) {
-          // config.addHierarchy(argument.id, 'unknown')
-          // config.addHierarchy(argument.id, 'what')
-          localHierarchy.push([argument.id, 'unknown'])
-          localHierarchy.push([argument.id, 'what'])
-        }
+    for (const argument of before.concat(after)) {
+      if (create.includes(argument.id)) {
+        // config.addHierarchy(argument.id, 'unknown')
+        // config.addHierarchy(argument.id, 'what')
+        localHierarchy.push([argument.id, 'unknown'])
+        localHierarchy.push([argument.id, 'what'])
       }
     }
 
@@ -404,7 +321,20 @@ class API {
           id: operator, 
           level: 0, 
           localHierarchy: [...localHierarchy, ['object', 'unknown']],
-          bridge: `{ ... next(operator) ${flattenProperty} ${doParams} ${beforeArgs} ${afterArgs}, operator: { ...operator, evaluateWord: true, imperative: ${imperative}, isVerb: true, number: 'one' }, unflatten: ${JSON.stringify(unflattenArgs)}, focusable: ${JSON.stringify(focusable)}, interpolate: ${interpolate} }`, 
+          bridge: `{ 
+            ...next(operator) 
+            ${flattenProperty} 
+            ${doParams} 
+            ${beforeArgs} 
+            ${afterArgs}, 
+            relationBacked: ${relation ? true : false},
+            orderingArgs: ${JSON.stringify(ordering)},
+            relationArgs: ${JSON.stringify([...before, ...after])},
+            operator: { ...operator, evaluateWord: true, imperative: ${imperative}, isVerb: true, number: 'one' }, 
+            unflatten: ${JSON.stringify(unflattenArgs)}, 
+            focusable: ${JSON.stringify(focusable)}, 
+            interpolate: ${interpolate} 
+          }`, 
           allowDups: true 
         })
         if (words.length > 0) {
@@ -462,201 +392,12 @@ class API {
       config.addAssociation({ context: [[afterIds[0], 1], ['canPassive', 0], ['beCanPassive', 0], [operator, 0], ['byCanPassive', 0], [beforeIds[0], 0]], choose: 1 })
     }
 
-    if (false) {
-      config.addGenerator({
-        notes: 'ordering generator for paraphrase',
-        match: ({context}) => context.marker == operator && context.paraphrase && !context.query,
-        apply: async ({context, gp, g}) => {
-          const beforeGenerator = []
-          for (const arg of before) {
-            beforeGenerator.push(await g(context[arg.tag]))
-          }
-          const afterGenerator = []
-          for (const arg of after) {
-            afterGenerator.push(await gp(context[arg.tag]))
-          }
-          const word = context.word
-          const sub = []
-          if (context.subphrase) {
-            sub.push(['that'])
-          }
-          return beforeGenerator.concat(sub).concat([word]).concat(afterGenerator).join(' ')
-        }
-      })
-    }
-
-    if (true) {
-      config.addGenerator({
-        notes: 'ordering generator for response',
-        match: ({context}) => context.marker == operator && context.evalue && context.isResponse,
-        apply: async ({context, s, 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 (!context.do?.query || evalue.truthValueOnly || context.truthValueOnly || brief) {
-          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 s({ ...evalue, toVoice: context.voice, flatten: false})
-            }
-
-            const details = await g(Object.assign({}, evalue, { paraphrase: true }))
-            if (yesno) {
-              return `${yesno} ${details}`
-            }
-            else {
-              return details
-            }
-          }
-        }
-      })
-    }
- 
-    if (ordering) {
-      config.addSemantic({
-        notes: 'ordering setter',
-        // TODO use hierarchy for operator
-        match: ({context}) => context.marker == operator,
-        apply: ({context, km}) => {
-          //const api = km('ordering').api
-          // api.setCategory(ordering.name, context[ordering.object].value, context[ordering.category].value, context)
-          const propertiesAPI = km('properties').api
-          context.ordering = ordering.name
-          const fcontexts = flattens(['list'], [context])
-          for (const fcontext of fcontexts) {
-            fcontext.paraphrase = true
-            fcontext[ordering.object].paraphrase = true
-            fcontext[ordering.category].paraphrase = true
-          }
-          propertiesAPI.relation_add(fcontexts) 
-        }
-      })
-      config.addSemantic({
-        notes: 'ordering query',
-        match: ({context}) => context.marker == operator && context.query,
-        apply: ({context, km}) => {
-          const api = km('ordering').api
-          const propertiesAPI = km('properties').api
-          context.ordering = ordering.name
-          const matches = propertiesAPI.relation_get(context, ['ordering', ordering.object, ordering.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', ordering.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 == ordering.marker
-          }
-        }
-      })
-    }
-
     if (ordering || relation || doAble) {
       config.addHierarchy(operator, 'canBeQuestion')
       config.addHierarchy(operator, 'ifAble')
       config.addHierarchy(operator, 'orAble')
     }
 
-    if (relation) {
-      config.addSemantic({
-        notes: `setter for ${operator}`,
-        match: ({context}) => context.marker == operator && !context.toVoice,
-        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)
-        }
-      })
-      config.addSemantic({
-        notes: `getter for ${operator}`,
-        match: ({context}) => context.marker == operator && context.query,
-        apply: ({context, km, callId}) => {
-          const api = km('properties').api
-          context.evalue = {
-            marker: 'list',
-            listable: true,
-            value: unflatten(api.relation_get(context, before.concat(after).map( (arg) => arg.tag ) ))
-          }
-          context.evalue.isResponse = true
-          context.isResponse = true
-          if (context.evalue.value.length == 0) {
-            context.evalue.marker = 'answerNotKnown';
-            context.evalue.listable = true
-            context.evalue.value = [];
-          } else {
-            // context.evalue.truthValue = true
-          }
-        }
-      })
-    }
-
     if (semanticApply) {
       config.addSemantic({
         notes: `override semantic apply for ${operator}`,
@@ -675,8 +416,6 @@ class API {
   }
 
   relation_add (relations) {
-    removeProp(relations, (val, prop, obj) => prop === 'range')
-
     if (!Array.isArray(relations)) {
       relations = [relations]
     }
@@ -725,6 +464,64 @@ class API {
     return value
   }
 
+  async relation_unify_helper (args, template, value) {
+    const matches = (t, v) => {
+      if (typeof t == 'string' || typeof v == 'string') {
+        return t == v
+      }
+
+      if (!t || !v) {
+        return null
+      }
+
+      if (t.query) {
+        return true
+      }
+
+      if (t.concept) {
+        // const api = args.km('properties').api
+        if (v.unknown && !t.value) {
+          return true;
+        }
+        return this.isA(v.value, t.value)
+      }
+
+      /* wtf
+      if (!t.value && !v.value) {
+        return this.isA(v.value, t.value);
+      }
+      */
+
+      return t.value && v.value && t.value == v.value
+    }
+
+    for (const arg of args) {
+      const u = await this.args.unify(template[arg], value[arg])
+      if (u) {
+        continue
+      }
+      if (!matches(template[arg], value[arg])) {
+        return null
+      }
+    }
+    return value
+  }
+
+  async relation_unify (context, args) {
+    const andTheAnswerIs = []
+    for (const relation of this._objects.relations) {
+      if (await this.relation_unify_helper(args, context, relation)) {
+        const queriedArgs = args.filter( (arg) => context[arg].query )
+        if (queriedArgs.length == 1) {
+          relation[queriedArgs[0]] = { ...relation[queriedArgs[0]], focus: true }
+        }
+
+        andTheAnswerIs.push(Object.assign({}, relation, { paraphrase: true }))
+      }
+    }
+    return andTheAnswerIs
+  }
+
   relation_get (context, args) {
     const andTheAnswerIs = []
     for (const relation of this._objects.relations) {
@@ -747,7 +544,7 @@ class API {
     }
   }
   */
-
+  /*
   setShared(path, handler) {
     if (!handler) {
       handler = new Object({
@@ -763,6 +560,7 @@ class API {
     this.propertiesFH.setInitHandler( { path, handler } )
     return handler
   }
+  */
 
   setReadOnly(path) {
     const handler = new Object({
@@ -778,12 +576,6 @@ class API {
     this.propertiesFH.setHandler(path, handler)
   }
 
-  /*
-  async getObject(object) {
-    return this.propertiesFH.getValue([object])
-  }
-  */
-
   getHandler(object, property) {
     return this.propertiesFH.getHandler([object, property])
   }
@@ -798,23 +590,23 @@ class API {
     return this._km("stm").api.getVariable(context) || context.value;
   }
 
-  async getProperty(object, property, g) {
+  async getProperty(object, property) {
     object = this.toValue(object)
     property = this.toValue(property)
     const handler = this.propertiesFH.getHandler([object, property])
     if (handler) {
       return await handler.getValue([object, property])
     }
-    return await this.getPropertyDirectly(object, property, g)
+    return await this.getPropertyDirectly(object, property)
   }
 
-  async getPropertyDirectly(object, property, g) {
+  async getPropertyDirectly(object, property) {
     if (property == 'property') {
       const objectProps = await this.propertiesFH.getValue([object])
       const values = []
       for (const key of Object.keys(objectProps)) {
         if (objectProps[key].has) {
-          values.push(`${await g(key)}: ${await g({ ...objectProps[key].value, paraphrase: true })}`)
+          values.push({ marker: 'labelledValue', label: key, value: objectProps[key].value, useColon: true })
         }
       }
       return { marker: 'list', listable: true, value: values }
@@ -828,27 +620,34 @@ class API {
   }
 
   setProperty(object, property, value, has, skipHandler) {
+    const objectId = object.value
+    const propertyId = property.value
+
     if (!skipHandler) {
-      const handler = this.propertiesFH.getHandler([object, property])
+      const handler = this.propertiesFH.getHandler([objectId, propertyId])
       if (handler) {
-        return handler.setValue([object, property], value, has)
+        return handler.setValue([objectId, propertyId], value, has)
       }
     }
-    this.propertiesFH.setValue([object, property], value, has)
+    this.propertiesFH.setValue([objectId, propertyId], value, has)
+
     if (has && value) {
-      let values = this._objects.property[property] || []
+      let values = this._objects.property[propertyId] || []
       if (!values.includes(value)) {
         values = values.concat(value)
       }
-      this._objects.property[property] = values
-      // this._objects.property[property] = (this.objects.property[property] || []).concat(value)
+      this._objects.property[propertyId] = values
+      // this._objects.property[propertyId] = (this.objects.property[propertyId] || []).concat(value)
       // "mccoy's rank is doctor",
       // infer doctor is a type of rank
-      this.rememberIsA(value.value, property);
+      this.rememberIsA(value.value, propertyId);
     }
-    if (!this._objects.concepts.includes(object)) {
-      this._objects.concepts.push(pluralize.singular(object))
+
+    if (!this._objects.concepts.includes(objectId)) {
+      this._objects.concepts.push(pluralize.singular(objectId))
     }
+
+    this.relation_add({ marker: 'propertyRelation', object, property, value, focusable: ['object', 'property', 'value'] })
   }
 
   async knownObject(object) {