occam-verify-cli 1.0.301 → 1.0.303

package/src/dom/declaration.js

@@ -7,8 +7,9 @@ import { domAssigned } from "../dom";
 import { unifyStatementIntrinsically } from "../utilities/unification";
 
 export default domAssigned(class Declaration {
-  constructor(string, reference, statement) {
+  constructor(string, node, reference, statement) {
     this.string = string;
+    this.node = node;
     this.reference = reference;
     this.statement = statement;
   }
@@ -17,6 +18,10 @@ export default domAssigned(class Declaration {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getReference() {
     return this.reference;
   }
@@ -25,23 +30,52 @@ export default domAssigned(class Declaration {
     return this.statement;
   }
 
+  isSimple() { return this.node.isSimple(); }
+
+  getMetavariable() {
+    let metavariable = null;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      metavariable = this.reference.getMetavariable();
+    }
+
+    return metavariable;
+  }
+
   matchSubstitution(substitution, context) {
-    let substitutionMatches;
+    let substitutionMatches = false;
 
     const declarationString = this.string,  ///
           substitutionString = substitution.getString();
 
     context.trace(`Matching the '${substitutionString}' substitution against the '${declarationString}' declaration...`);
 
-    const statement = substitution.getStatement(),
-          metavariable = substitution.getMetavariable(),
-          statementEqualToStatement = this.statement.isEqualTo(statement),
-          referenceMetavariableEqualToMetavariable = this.reference.isMetavariableEqualTo(metavariable);
+    const simple = this.isSimple();
+
+    if (simple) {
+      const metavariable = this.reference.getMetavariable(),
+            judgement = context.findJudgementByMetavariable(metavariable);
 
-    substitutionMatches = (referenceMetavariableEqualToMetavariable && statementEqualToStatement);
+      if (judgement !== null) {
+        const declaration = judgement.getDeclaration();
+
+        substitutionMatches = declaration.matchSubstitution(substitution, context);
+      }
+    } else {
+      const statement = substitution.getStatement(),
+            metavariable = substitution.getMetavariable(),
+            statementEqualToStatement = this.statement.isEqualTo(statement),
+            referenceMetavariableEqualToMetavariable = this.reference.isMetavariableEqualTo(metavariable);
+
+      if (referenceMetavariableEqualToMetavariable && statementEqualToStatement) {
+        substitutionMatches = true;
+      }
+    }
 
     if (substitutionMatches) {
-      context.debug(`...matched the '${declarationString}' substitution against the '${substitutionString}' declaration.`);
+      context.debug(`...matches the '${declarationString}' substitution against the '${substitutionString}' declaration.`);
     }
 
     return substitutionMatches;
@@ -54,29 +88,37 @@ export default domAssigned(class Declaration {
 
     context.trace(`Verifying the '${declarationString}' declaration...`);
 
-    const referenceVerifies = this.verifyReference(assignments, stated, context);
+    const simple = this.isSimple();
 
-    if (referenceVerifies) {
-      const statementVerifies = this.verifyStatement(assignments, stated, context);
+    if (simple) {
+      const referenceVerifiesAsMetavariable = this.verifyReferenceAsMetavariable(assignments, stated, context);
 
-      if (statementVerifies) {
-        let verifiesWhenStated = false,
-            verifiesWhenDerived = false;
+      verifies = referenceVerifiesAsMetavariable; ///
+    } else {
+      const referenceVerifies = this.verifyReference(assignments, stated, context);
 
-        if (stated) {
-          verifiesWhenStated = this.verifyWhenStated(assignments, context);
-        } else {
-          verifiesWhenDerived = this.verifyWhenDerived(context);
-        }
+      if (referenceVerifies) {
+        const statementVerifies = this.verifyStatement(assignments, stated, context);
 
-        if (verifiesWhenStated || verifiesWhenDerived) {
-          verifies = true;
+        if (statementVerifies) {
+          let verifiesWhenStated = false,
+              verifiesWhenDerived = false;
+
+          if (stated) {
+            verifiesWhenStated = this.verifyWhenStated(assignments, context);
+          } else {
+            verifiesWhenDerived = this.verifyWhenDerived(context);
+          }
+
+          if (verifiesWhenStated || verifiesWhenDerived) {
+            verifies = true;
+          }
         }
       }
-    }
 
-    if (verifies) {
-      context.debug(`...verified the '${declarationString}' declaration.`);
+      if (verifies) {
+        context.debug(`...verified the '${declarationString}' declaration.`);
+      }
     }
 
     return verifies;
@@ -101,23 +143,46 @@ export default domAssigned(class Declaration {
   verifyStatement(assignments, stated, context) {
     let statementVerifies;
 
-    const statementString = this.statement.getString();
+    if (this.statement === null) {
+      statementVerifies = true;
+    } else {
+      const statementString = this.statement.getString();
 
-    context.trace(`Verifying the '${statementString}' statement...`);
+      context.trace(`Verifying the '${statementString}' statement...`);
 
-    stated = true;  ///
+      stated = true;  ///
 
-    assignments = null; ///
+      assignments = null; ///
 
-    statementVerifies = this.statement.verify(assignments, stated, context);
+      statementVerifies = this.statement.verify(assignments, stated, context);
 
-    if (statementVerifies) {
-      context.debug(`...verified the '${statementString}' statement.`);
+      if (statementVerifies) {
+        context.debug(`...verified the '${statementString}' statement.`);
+      }
     }
 
     return statementVerifies;
   }
 
+  verifyReferenceAsMetavariable(assignments, stated, context) {
+    let referenceVerifiesAsMetavariable;
+
+    const referenceString = this.reference.getString();
+
+    context.trace(`Verifying the '${referenceString}' reference as a metavariable...`);
+
+    const metavariable = this.reference.getMetavariable(),
+          metavariableVerifies = metavariable.verify(context);
+
+    referenceVerifiesAsMetavariable = metavariableVerifies; ///
+
+    if (referenceVerifiesAsMetavariable) {
+      context.debug(`...verified the '${referenceString}' reference as a metavariable.`);
+    }
+
+    return referenceVerifiesAsMetavariable;
+  }
+
   verifyWhenStated(assignments, context) {
     let verifiesWhenStated;
 
@@ -170,20 +235,24 @@ export default domAssigned(class Declaration {
   unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnifies;
 
-    const context = generalContext,  ///
-          statementString = statement.getString(),
-          declarationStatementString = this.statement.getString();
+    if (this.statement === null) {
+      statementUnifies = false;
+    } else {
+      const context = generalContext,  ///
+            statementString = statement.getString(),
+            declarationStatementString = this.statement.getString();
 
-    context.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
+      context.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
 
-    const generalStatement = this.statement,
-          specificStatement = statement,  ///
-          statementUUnifiesIntrinsically = unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+      const generalStatement = this.statement,
+            specificStatement = statement,  ///
+            statementUUnifiesIntrinsically = unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext);
 
-    statementUnifies = statementUUnifiesIntrinsically;  ///
+      statementUnifies = statementUUnifiesIntrinsically;  ///
 
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
+      if (statementUnifies) {
+        context.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
+      }
     }
 
     return statementUnifies;
@@ -271,7 +340,7 @@ function declarationFromDeclarationNode(declarationNode, context) {
         string = context.nodeAsString(node),
         reference = Reference.fromDeclarationNode(declarationNode, context),
         statement = Statement.fromDeclarationNode(declarationNode, context),
-        declaration = new Declaration(string, reference, statement);
+        declaration = new Declaration(string, node, reference, statement);
 
   return declaration;
 }

package/src/dom/deduction.js

@@ -55,12 +55,12 @@ export default domAssigned(class Deduction {
           statementString = statement.getString(),
           deductionString = deduction.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`, this.node);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`);
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`, this.node);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`);
     }
 
     return statementUnifies;

package/src/dom/frame.js

@@ -11,12 +11,11 @@ import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 const { first } = arrayUtilities;
 
 export default domAssigned(class Frame {
-  constructor(string, node, tokens, declarations, metavariables) {
+  constructor(string, node, tokens, declarations) {
     this.string = string;
     this.node = node;
     this.tokens = tokens;
     this.declarations = declarations;
-    this.metavariables = metavariables;
   }
 
   getString() {
@@ -35,9 +34,7 @@ export default domAssigned(class Frame {
     return this.declarations;
   }
 
-  getMetavariables() {
-    return this.metavariables;
-  }
+  getLength() { return this.declarations.length; }
 
   getMetavariable() {
     let metavariable = null;
@@ -45,14 +42,30 @@ export default domAssigned(class Frame {
     const simple = this.isSimple();
 
     if (simple) {
-      const firstMetavariable = first(this.metavariables);
+      const firstDeclaration = first(this.declarations),
+            declaration = firstDeclaration; ///
 
-      metavariable = firstMetavariable; ///
+      metavariable = declaration.getMetavariable();
     }
 
     return metavariable;
   }
 
+  isSimple() {
+    let simple = false;
+
+    const length = this.getLength();
+
+    if (length === 1) {
+      const firstDeclaration = first(this.declarations),
+            declaration = firstDeclaration; ///
+
+      simple = declaration.isSimple();
+    }
+
+    return simple;
+  }
+
   isEqualTo(frame) {
     const frameString = frame.getString(),
           equalTo = (frameString === this.string);
@@ -60,14 +73,6 @@ export default domAssigned(class Frame {
     return equalTo;
   }
 
-  isSimple() {
-    const metavariablesLength = this.metavariables.length,
-          declarationsLength = this.declarations.length,
-          simple = ((metavariablesLength === 1) && (declarationsLength === 0));
-
-    return simple;
-  }
-
   matchSubstitution(substitution, context) {
     let substitutionMatches = false;
 
@@ -86,16 +91,6 @@ export default domAssigned(class Frame {
       });
     }
 
-    if (!substitutionMatches) {
-      substitutionMatches = this.metavariables.some((metavariable) => {
-        const substitutionMatchesMetavariable = metavariable.matchSubstitution(substitution, context);
-
-        if (substitutionMatchesMetavariable) {
-          return true;
-        }
-      });
-    }
-
     if (substitutionMatches) {
       context.debug(`...matched the '${substitutionString}' substitutions against the '${frameString}' frame.`);
     }
@@ -136,21 +131,17 @@ export default domAssigned(class Frame {
     const declarationsVerify = this.verifyDeclarations(assignments, stated, context);
 
     if (declarationsVerify) {
-      const  metavariablesVerify = this.verifyMetavariables(assignments, stated, context);
-
-      if (metavariablesVerify) {
-        let verifiesWhenStated = false,
-            verifiesWhenDerived = false;
+      let verifiesWhenStated = false,
+          verifiesWhenDerived = false;
 
-        if (stated) {
-          verifiesWhenStated = this.verifyWhenStated(assignments, context);
-        } else {
-          verifiesWhenDerived = this.verifyWhenDerived(context);
-        }
+      if (stated) {
+        verifiesWhenStated = this.verifyWhenStated(assignments, context);
+      } else {
+        verifiesWhenDerived = this.verifyWhenDerived(context);
+      }
 
-        if (verifiesWhenStated || verifiesWhenDerived) {
-          verifies = true;
-        }
+      if (verifiesWhenStated || verifiesWhenDerived) {
+        verifies = true;
       }
     }
 
@@ -168,18 +159,12 @@ export default domAssigned(class Frame {
 
     context.trace(`Verifying the '${frameString}' stated frame...`);
 
-    const declarationsLength = this.declarations.length;
+    const simple = this.isSimple();
 
-    if (declarationsLength > 0) {
-      context.trace(`The '${frameString}' stated frame cannot have declarations.`);
+    if (!simple) {
+      context.trace(`The '${frameString}' stated frame must be simple.`);
     } else {
-      const metavariablesLength = this.metavariables.length;
-
-      if (metavariablesLength > 1) {
-        context.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);
-      } else {
-        verifiesWhenStated = true;
-      }
+      verifiesWhenStated = true;
     }
 
     if (verifiesWhenStated) {
@@ -208,10 +193,10 @@ export default domAssigned(class Frame {
   verifyDeclarations(assignments, stated, context) {
     let declarationsVerify = true;  ///
 
-    const declarationsLength = this.declarations.length;
+    const length = this.getLength();
 
-    if (declarationsLength > 0) {
-      const sOrNothing = (declarationsLength > 1) ?
+    if (length > 0) {
+      const sOrNothing = (length > 1) ?
                            S :
                              NOTHING,
             declarationsString = declarationsStringFromDeclarations(this.declarations);
@@ -236,33 +221,6 @@ export default domAssigned(class Frame {
     return declarationsVerify;
   }
 
-  verifyMetavariables(assignments, stated, context) {
-    let metavariablesVerify = true;
-
-    const metavariablesLength = this.metavariables.length;
-
-    if (metavariablesLength > 0) {
-      const sOrNothing = (metavariablesLength > 1) ?
-                           S :
-                             NOTHING,
-            metavariablesString = metavariablesStringFromMetavariables(this.metavariables);
-
-      context.trace(`Verifying the '${metavariablesString}' metavariable${sOrNothing}...`);
-
-      metavariablesVerify = this.metavariables.every((metavariable) => {
-        const metavariableVerifies = metavariable.verify(context);
-
-        return metavariableVerifies;
-      });
-
-      if (metavariablesVerify) {
-        context.debug(`...verified the '${metavariablesString}' metavariable${sOrNothing}.`);
-      }
-    }
-
-    return metavariablesVerify;
-  }
-
   verifyGivenMetaType(metaType, assignments, stated, context) {
     let verifiesGivenMetaType = false;
 
@@ -379,17 +337,3 @@ function declarationsStringFromDeclarations(declarations) {
 
   return declarationsString;
 }
-
-function metavariablesStringFromMetavariables(metavariable) {
-  const metavariablesString = metavariable.reduce((metavariablesString, metavariable) => {
-    const metavariableString = metavariable.getString();
-
-    metavariablesString = (metavariablesString === null) ?
-                            metavariableString :
-                             `${metavariablesString}, ${metavariableString}`;
-
-    return metavariablesString;
-  }, null);
-
-  return metavariablesString;
-}

package/src/dom/metavariable.js

@@ -87,32 +87,6 @@ export default domAssigned(class Metavariable {
     return equalTo;
   }
 
-  matchSubstitution(substitution, context) {
-    let substitutionMatched = false;
-
-    const metavariableString = this.string,  ///
-          substitutionString = substitution.getString();
-
-    context.trace(`Matching the '${substitutionString}' substitution against the '${metavariableString}' metavariable...`);
-
-    const metavariable = this, ///
-          judgement = context.findJudgementByMetavariable(metavariable);
-
-    if (judgement !== null) {
-      const declaration = judgement.getDeclaration();
-
-      substitutionMatched = declaration.matchSubstitution(substitution, context);
-    } else {
-      context.debug(`The '${metavariableString}' metavariable does not have a judgement.`);
-    }
-
-    if (substitutionMatched) {
-      context.debug(`...matched the '${substitutionString}' substitution against the '${metavariableString}' metavariable.`);
-    }
-
-    return substitutionMatched;
-  }
-
   verify(context) {
     let verifies;
 
@@ -206,50 +180,6 @@ export default domAssigned(class Metavariable {
     return frameUnifies;
   }
 
-  unifyReference(reference, substitutions, generalContext, specificContext) {
-    let referenceUnifies = false;
-
-    const referenceString = reference.getString(),
-          metavariableString = this.string; ///
-
-    specificContext.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
-
-    const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext);
-
-    if (referenceMetavariableUnifies) {
-      referenceUnifies = true;
-    } else {
-      const metavariable = this, ///
-            simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
-
-      if (simpleSubstitutionPresent) {
-        const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable),
-              substitution = simpleSubstitution,  ///
-              substitutionReferenceEqualToReference = substitution.isReferenceEqualTo(reference);
-
-        if (substitutionReferenceEqualToReference) {
-          referenceUnifies = true;
-        }
-      } else {
-        const { ReferenceSubstitution } = dom,
-              context = specificContext,  ///
-              metavariable = this,  ///
-              referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
-              substitution = referenceSubstitution;  ///
-
-        substitutions.addSubstitution(substitution, specificContext);
-
-        referenceUnifies = true;
-      }
-    }
-
-    if (referenceUnifies) {
-      specificContext.debug(`...unified the '${referenceString}' reference with the '${metavariableString}' metavariable.`);
-    }
-
-    return referenceUnifies;
-  }
-
   unifyStatement(statement, substitution, substitutions, generalContext, specificContext) {
     let statementUnifies = false;
 
@@ -355,39 +285,6 @@ export default domAssigned(class Metavariable {
     return frameMetavariableUnifies;
   }
 
-  unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext) {
-    let referenceMetavariableUnifies = false;
-
-    const generalContextFilePath = generalContext.getFilePath(),
-          specificContextFilePath = specificContext.getFilePath();
-
-    if (generalContextFilePath === specificContextFilePath) {
-      const referenceString = reference.getString();
-
-      if (referenceString === this.string) {
-        referenceMetavariableUnifies = true;
-      } else {
-        const metavariableString = this.string, ///
-              referenceMetavariable = reference.getMetavariable(),
-              referenceMetavariableString = referenceMetavariable.getString();
-
-        specificContext.trace(`Unifying the reference's ${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
-
-        const specificMetavariable = referenceMetavariable, ///
-              generalMetavariable = this, ///
-              metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
-
-        referenceMetavariableUnifies = metavariableUnifiesIntrinsically; ///
-
-        if (referenceMetavariableUnifies) {
-          specificContext.debug(`...unified the reference's '${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
-        }
-      }
-    }
-
-    return referenceMetavariableUnifies;
-  }
-
   unifyStatementMetavariable(statement, substitutions, generalContext, specificContext) {
     let statementMetavariableUnifies = false;
 

package/src/dom/premise.js

@@ -152,7 +152,7 @@ export default domAssigned(class Premise {
           premiseStatement = premise.getStatement(),
           premiseStatementString = premiseStatement.getString();
 
-    specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`, this.node);
+    specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
 
     if (this.statement !== null) {
       const context = generalContext,
@@ -164,7 +164,7 @@ export default domAssigned(class Premise {
     }
 
     if (subproofUnifies) {
-      specificContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`, this.node);
+      specificContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
     }
 
     return subproofUnifies;
@@ -177,14 +177,14 @@ export default domAssigned(class Premise {
           premiseString = premise.getString(),
           statementString = statement.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`, this.node);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
 
     if (this.statement !== null) {
       statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
     }
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`, this.node);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
     }
 
     return statementUnifies;

package/src/dom/procedureCall.js

@@ -75,7 +75,7 @@ export default domAssigned(class ProcedureCall {
 
     const procedureCallString = this.string; ///
 
-    context.trace(`Unifying the '${procedureCallString}' procedure call independently...`, this.node);
+    context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);
 
     const procedure = context.findProcedureByReference(this.reference),
           nodes = this.findNodes(substitutions),
@@ -93,7 +93,7 @@ export default domAssigned(class ProcedureCall {
     }
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${procedureCallString}' procedure call independently.`, this.node);
+      context.debug(`...unified the '${procedureCallString}' procedure call independently.`);
     }
 
     return unifiesIndependently;