occam-verify-cli 1.0.207 → 1.0.211

package/src/dom/axiom.js

@@ -2,14 +2,21 @@
 
 import { arrayUtilities } from "necessary";
 
+import LocalContext from "../context/local";
 import TopLevelAssertion  from "./topLevelAssertion";
 
 import { domAssigned } from "../dom";
-import { satisfiesAssertionFromStatement } from "../utilities/context";
 
-const { match, backwardsSome } = arrayUtilities;
+const { match } = arrayUtilities;
 
 export default domAssigned(class Axiom extends TopLevelAssertion {
+  isSatisfiable() {
+    const signature = this.getSignature(),
+          satisfiable = (signature !== null);
+
+    return satisfiable;
+  }
+
   verify() {
     let verified;
 
@@ -19,7 +26,11 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
 
     fileContext.trace(`Verifying the '${axiomString}' axiom...`);
 
-    verified = super.verify();
+    const signatureVerified = this.verifySignature();
+
+    if (signatureVerified) {
+      verified = super.verify();
+    }
 
     if (verified) {
       const axiom = this; ///
@@ -32,10 +43,43 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     return verified;
   }
 
-  unifyStatement(statement, substitutions, context) {
+  verifySignature() {
+    let signatureVerified = true;
+
+    const satisfiable = this.isSatisfiable();
+
+    if (satisfiable) {
+      const signature = this.getSignature(),
+            fileContext = this.getFileContext(),
+            localContext = LocalContext.fromFileContext(fileContext),
+            context = localContext; ///
+
+      signatureVerified = signature.verify(context);
+    }
+
+    return signatureVerified;
+  }
+
+  matchSignature(signature, substitutions, generalContext, specificContext) {
+    let signatureMatches = false;
+
+    const satisfiable = this.isSatisfiable();
+
+    if (satisfiable) {
+      const signatureA = signature; ///
+
+      signature = this.getSignature()
+
+      const signatureB = signature; ///
+
+      signatureMatches = signatureA.match(signatureB, substitutions, generalContext, specificContext);
+    }
+
+    return signatureMatches;
+  }
+
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
     const deduction = this.getDeduction(),
-          generalContext = context, ///
-          specificContext = context,  ///
           statementUnified = deduction.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     return statementUnified;
@@ -145,34 +189,18 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
   }
 
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
-    let statementAndStepsOrSubproofsUnified;
-
-    statementAndStepsOrSubproofsUnified = super.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
-
-    if (statementAndStepsOrSubproofsUnified) {
-      const satisfiable = this.isSatisfiable();
+    let statementAndStepsOrSubproofsUnified = false;
 
-      if (satisfiable) {
-        const substitutionsMatch = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
-          const stepSubstep = stepOrSubproof.isStep();
+    const satisfiable = this.isSatisfiable();
 
-          if (stepSubstep) {
-            const step = stepOrSubproof,  ///
-                  statement = step.getStatement(),
-                  satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
+    if (satisfiable) {
+      const string = this.getString(),
+            axiomString = string, ///
+            statementString = statement.getString();
 
-            if (satisfiesAssertion !== null) {
-              const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
-
-              if (substitutionsMatch) {
-                return true;
-              }
-            }
-          }
-        });
-
-        statementAndStepsOrSubproofsUnified = substitutionsMatch; ///
-      }
+      context.debug(`The '${statementString}' statement cannot be unified with the '${axiomString}' axiom because the latter is satisfiable.`);
+    } else {
+      statementAndStepsOrSubproofsUnified = super.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
     }
 
     return statementAndStepsOrSubproofsUnified;

package/src/dom/metavariable.js

@@ -2,9 +2,6 @@
 
 import dom from "../dom";
 import LocalContext from "../context/local";
-import FrameSubstitution from "../substitution/frame";
-import ReferenceSubstitution from "../substitution/reference";
-import StatementSubstitution from "../substitution/statement";
 import MetavariablePartialContext from "../context/partial/metavariable";
 
 import { domAssigned } from "../dom";
@@ -189,7 +186,8 @@ export default domAssigned(class Metavariable {
           frameUnified = true;
         }
       } else {
-        const context = specificContext,  ///
+        const { FrameSubstitution } = dom,
+              context = specificContext,  ///
               metavariable = this,  ///
               frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
               substitution = frameSubstitution;  ///
@@ -232,7 +230,8 @@ export default domAssigned(class Metavariable {
           referenceUnified = true;
         }
       } else {
-        const context = specificContext,  ///
+        const { ReferenceSubstitution } = dom,
+              context = specificContext,  ///
               metavariable = this,  ///
               referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
               substitution = referenceSubstitution;  ///
@@ -279,7 +278,8 @@ export default domAssigned(class Metavariable {
           statementUnified = true;
         }
       } else {
-        const metavariable = this,
+        const { StatementSubstitution } = dom,
+              metavariable = this,
               statementSubstitution = StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context);
 
         substitution = statementSubstitution;  ///

package/src/dom/signature.js

@@ -0,0 +1,145 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import dom from "../dom";
+
+import { domAssigned } from "../dom";
+import { termsFromJSON, termsToTermsJSON } from "../utilities/json";
+import { stringFromTerms, variableFromTerm, termsFromTermNodes } from "../utilities/node";
+
+const { match, correlate } = arrayUtilities;
+
+export default domAssigned(class Signature {
+  constructor(string, terms) {
+    this.string = string;
+    this.terms = terms;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getTerms() {
+    return this.terms;
+  }
+
+  verify(context) {
+    let verified;
+
+    const signatureString = this.string;
+
+    context.trace(`Verifying the ${signatureString} signature...`);
+
+    verified = this.terms.every((term) => {
+      const termVerified = term.verify(context, () => {
+        const verifiedAhead = true;
+
+        return verifiedAhead;
+      });
+
+      if (termVerified) {
+        return true;
+      }
+    });
+
+    if (verified) {
+      context.debug(`...verified the ${signatureString} signature.`);
+    }
+
+    return verified;
+  }
+
+  match(signature, substitutions, generalContext, specificContext) {
+    const terms = signature.getTerms(),
+          termsA = this.terms,  ///
+          termsB = terms, ///
+          matches = match(termsA, termsB, (termA, termB) => {
+            const termAType = termA.getType(),
+                  termBType = termB.getType(),
+                  termATypeEqualToOrSubTypeOfTermB = termAType.isEqualToOrSubTypeOf(termBType);
+
+            if (termATypeEqualToOrSubTypeOfTermB) {
+              let context,
+                  term;
+
+
+              context = generalContext; ///
+
+              term = termB; ///
+
+              const variable = variableFromTerm(term, context);
+
+              context = specificContext;  ///
+
+              term = termA; ///
+
+              const { TermSubstitution } = dom,
+                    termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
+                    substitution = termSubstitution;  ///
+
+              substitutions.addSubstitution(substitution, specificContext);
+
+              return true;
+            }
+          });
+
+    return matches;
+  }
+
+  matchSubstitutions(substitutions, context) {
+    let substitutionsMatch;
+
+    const signatureString = this.string,
+          substitutionsString = substitutions.asString();
+
+    context.trace(`Matching the '${substitutionsString}' substitutions against the ${signatureString} signature...`);
+
+    const array = substitutions.getArray(),
+          correlates = correlate(this.terms, array, (term, substitution) => {
+            const substitutionTerm = substitution.getTerm(),
+                  substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);
+
+            if (substitutionTermEqualToTerm) {
+              return true;
+            }
+          });
+
+    substitutionsMatch = correlates;  ///
+
+    if (substitutionsMatch) {
+      context.debug(`...matched the '${substitutionsString}' substitutions against the ${signatureString} signature.`);
+    }
+
+    return substitutionsMatch;
+  }
+
+  toJSON() {
+    const termsJSON = termsToTermsJSON(this.terms),
+          terms = termsJSON,  ///
+          json = {
+            terms
+          };
+
+    return json;
+  }
+
+  static name = "Signature";
+
+  static fromJSON(json, fileContext) {
+    const terms = termsFromJSON(json, fileContext),
+          string = stringFromTerms(terms),
+          signature = new Signature(string, terms);
+
+    return signature;
+  }
+
+  static fromSignatureNode(signatureNode, fileContext) {
+    const termNodes = signatureNode.getTermNodes(),
+          terms = termsFromTermNodes(termNodes, fileContext),
+          string = stringFromTerms(terms),
+          signature = new Signature(string, terms);
+
+    return signature;
+  }
+});

package/src/{substitution → dom/substitution}/frame.js

@@ -1,10 +1,12 @@
 "use strict";
 
-import dom from "../dom";
+import dom from "../../dom";
 import Substitution from "../substitution";
-import FrameSubstitutionPartialContext from "../context/partial/substitution/frame";
+import FrameSubstitutionPartialContext from "../../context/partial/substitution/frame";
 
-export default class FrameSubstitution extends Substitution {
+import { domAssigned } from "../../dom";
+
+export default domAssigned(class FrameSubstitution extends Substitution {
   constructor(string, node, tokens, frame, metavariable) {
     super(string, node, tokens);
 
@@ -71,7 +73,7 @@ export default class FrameSubstitution extends Substitution {
 
     return frameSubstitution;
   }
-}
+});
 
 function stringFromFrameAndMetavariable(frame, metavariable) {
   const frameString = frame.getString(),

package/src/{substitution → dom/substitution}/reference.js

@@ -1,10 +1,12 @@
 "use strict";
 
-import dom from "../dom";
+import dom from "../../dom";
 import Substitution from "../substitution";
-import ReferenceSubstitutionPartialContext from "../context/partial/substitution/reference";
+import ReferenceSubstitutionPartialContext from "../../context/partial/substitution/reference";
 
-export default class ReferenceSubstitution extends Substitution {
+import { domAssigned } from "../../dom";
+
+export default domAssigned(class ReferenceSubstitution extends Substitution {
   constructor(string, node, tokens, reference, metavariable) {
     super(string, node, tokens);
 
@@ -62,7 +64,7 @@ export default class ReferenceSubstitution extends Substitution {
 
     return referenceSubstitution;
   }
-}
+});
 
 function stringFromReferenceAndMetavariable(reference, metavariable) {
   const referenceString = reference.getString(),

package/src/{substitution → dom/substitution}/statement.js

@@ -1,14 +1,15 @@
 "use strict";
 
 import Substitution from "../substitution";
-import Substitutions from "../substitutions";
-import StatementSubstitutionPartialContext from "../context/partial/substitution/statement";
+import Substitutions from "../../substitutions";
+import StatementSubstitutionPartialContext from "../../context/partial/substitution/statement";
 
-import { unifySubstitution } from "../utilities/unification";
-import { stripBracketsFromStatement } from "../utilities/brackets";
-import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
+import { domAssigned } from "../../dom";
+import { unifySubstitution } from "../../utilities/unification";
+import { stripBracketsFromStatement } from "../../utilities/brackets";
+import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../../utilities/json";
 
-export default class StatementSubstitution extends Substitution {
+export default domAssigned(class StatementSubstitution extends Substitution {
   constructor(string, node, tokens, resolved, statement, metavariable, substitution) {
     super(string, node, tokens);
 
@@ -216,7 +217,7 @@ export default class StatementSubstitution extends Substitution {
 
     return statementSubstitution;
   }
-}
+});
 
 function stringFromStatementAndMetavariable(statement, metavariable) {
   const statementString = statement.getString(),

package/src/{substitution → dom/substitution}/term.js

@@ -1,13 +1,14 @@
 "use strict";
 
-import dom from "../dom";
+import dom from "../../dom";
 import Substitution from "../substitution";
-import TermSubstitutionPartialContext from "../context/partial/substitution/term";
+import TermSubstitutionPartialContext from "../../context/partial/substitution/term";
 
-import { stripBracketsFromTerm } from "../utilities/brackets";
-import { stripBracketsFromTermNode } from "../utilities/brackets";
+import { domAssigned } from "../../dom";
+import { stripBracketsFromTerm } from "../../utilities/brackets";
+import { stripBracketsFromTermNode } from "../../utilities/brackets";
 
-export default class TermSubstitution extends Substitution {
+export default domAssigned(class TermSubstitution extends Substitution {
   constructor(string, node, tokens, term, variable) {
     super(string, node, tokens);
 
@@ -106,7 +107,7 @@ export default class TermSubstitution extends Substitution {
 
     return termSubstitution;
   }
-}
+});
 
 function stringFromTermAndVariable(term, variable) {
   const termString = term.getString(),

package/src/dom/topLevelAssertion.js

@@ -8,23 +8,24 @@ import Substitutions from "../substitutions";
 
 import { labelsFromJSON,
          deductionFromJSON,
+         signatureFromJSON,
          labelsToLabelsJSON,
-         satisfiableFromJSON,
          suppositionsFromJSON,
          deductionToDeductionJSON,
+         signatureToSignatureJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 
 export default class TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, deduction, proof, satisfiable) {
+  constructor(fileContext, string, labels, suppositions, deduction, proof, signature) {
     this.fileContext = fileContext;
     this.string = string;
     this.labels = labels;
     this.suppositions = suppositions;
     this.deduction = deduction;
     this.proof = proof;
-    this.satisfiable = satisfiable;
+    this.signature = signature;
   }
 
   getFileContext() {
@@ -51,8 +52,8 @@ export default class TopLevelAssertion {
     return this.proof;
   }
 
-  isSatisfiable() {
-    return this.satisfiable;
+  getSignature() {
+    return this.signature;
   }
 
   getStatement() { return this.deduction.getStatement(); }
@@ -220,15 +221,16 @@ export default class TopLevelAssertion {
     const labelsJSON = labelsToLabelsJSON(this.labels),
           deductionJSON = deductionToDeductionJSON(this.deduction),
           suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
+          signatureJSON = signatureToSignatureJSON(this.signature),
           labels = labelsJSON,  ///
           deduction = deductionJSON,  ///
           suppositions = suppositionsJSON,  ///
-          satisfiable = this.satisfiable,
+          signature = signatureJSON,
           json = {
             labels,
             deduction,
             suppositions,
-            satisfiable
+            signature,
           };
 
     return json;
@@ -237,28 +239,29 @@ export default class TopLevelAssertion {
   static fromJSON(Class, json, fileContext) {
     const labels = labelsFromJSON(json, fileContext),
           deduction = deductionFromJSON(json, fileContext),
-          satisfiable = satisfiableFromJSON(json, fileContext),
           suppositions = suppositionsFromJSON(json, fileContext),
+          signature = signatureFromJSON(json, fileContext),
           proof = null,
           string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
+          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, signature);
 
     return topLevelAssertion;
   }
 
   static fromNode(Class, node, fileContext) {
     const topLevelAssertionNode = node, ///
-          satisfiable = topLevelAssertionNode.isSatisfiable(),
           proofNode = topLevelAssertionNode.getProofNode(),
           labelNodes = topLevelAssertionNode.getLabelNodes(),
           deductionNode = topLevelAssertionNode.getDeductionNode(),
           suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
+          signatureNode = topLevelAssertionNode.getSignatureNode(),
           proof = proofFromProofNode(proofNode, fileContext),
           labels = labelsFromLabelNodes(labelNodes, fileContext),
           deduction = deductionFromDeductionNode(deductionNode, fileContext),
           suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
+          signature = signatureFromSignatureNode(signatureNode, fileContext),
           string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
+          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, signature);
 
     return topLevelAssertion;
   }
@@ -282,6 +285,18 @@ export function labelsFromLabelNodes(labelNodes, fileContext) {
   return labels;
 }
 
+export function signatureFromSignatureNode(signatureNode, fileContext) {
+  let signature = null;
+
+  if (signatureNode !== null) {
+    const { Signature } = dom;
+
+    signature = Signature.fromSignatureNode(signatureNode, fileContext);
+  }
+
+  return signature;
+}
+
 export function deductionFromDeductionNode(deductionNode, fileContext) {
   const { Deduction } = dom,
         deduction = Deduction.fromDeductionNode(deductionNode, fileContext);

package/src/dom/topLevelMetaAssertion.js

@@ -65,7 +65,7 @@ export default class TopLevelMetaAssertion {
   verify() {
     let verified = false;
 
-    const labelVerified = this.verifyLabels();
+    const labelVerified = this.verifyLabel();
 
     if (labelVerified) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
@@ -96,7 +96,7 @@ export default class TopLevelMetaAssertion {
     return verified;
   }
 
-  verifyLabels() {
+  verifyLabel() {
     const nameOnly = false,
           labelVerified = this.label.verify(nameOnly);
 

package/src/dom/variable.js

@@ -2,7 +2,6 @@
 
 import dom from "../dom";
 import LocalContext from "../context/local";
-import TermSubstitution from "../substitution/term";
 
 import { domAssigned } from "../dom";
 import { EMPTY_STRING } from "../constants";
@@ -154,7 +153,8 @@ export default domAssigned(class Variable {
           termUnified = true;
         }
       } else {
-        const context = specificContext,  ///
+        const { TermSubstitution } = dom,
+              context = specificContext,  ///
               variable = this,  ///
               termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
               substitution = termSubstitution;  ///
@@ -211,7 +211,7 @@ export default domAssigned(class Variable {
       const variableNode = singularVariableNode,  ///
             type = null;
 
-      variable = variableFromVariableNodeAndType(variableNode, type, context);
+      variable = variableFromVariableNodeAndType(variableNode, type);
     }
 
     return variable;
@@ -223,22 +223,20 @@ export default domAssigned(class Variable {
     if (variableNode !== null) {
       const type = null;
 
-      variable = variableFromVariableNodeAndType(variableNode, type, context);
+      variable = variableFromVariableNodeAndType(variableNode, type);
     }
 
     return variable;
   }
 
   static fromVariableNodeAndType(variableNode, type, context) {
-    const variable = variableFromVariableNodeAndType(variableNode, type, context);
+    const variable = variableFromVariableNodeAndType(variableNode, type);
 
     return variable;
   }
 
   static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
     const { Variable } = dom,
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext,
           provisional = variableDeclarationNode.isProvisional(),
           typeNode = variableDeclarationNode.getTypeNode(),
           type = typeFromTypeNode(typeNode);
@@ -249,7 +247,7 @@ export default domAssigned(class Variable {
           variableName = variableDeclarationNode.getVariableName(),
           node = variableNode,  ///
           name = variableName,  ///
-          string = context.nodeAsString(node),
+          string = name,  ///
           propertyRelations = [],
           variable = new Variable(string, node, name, type, propertyRelations);
 
@@ -278,11 +276,11 @@ export default domAssigned(class Variable {
   }
 });
 
-function variableFromVariableNodeAndType(variableNode, type, context) {
+function variableFromVariableNodeAndType(variableNode, type) {
   const { Variable } = dom,
         node = variableNode,  ///
         variableName = variableNode.getVariableName(),
-        string = context.nodeAsString(node),
+        string = variableName,  ///,
         name = variableName,  ///
         propertyRelations = [],
         variable = new Variable(string, node, name, type, propertyRelations);

package/src/index.js

@@ -23,6 +23,7 @@ import Statement from "./dom/statement";
 import Judgement from "./dom/judgement";
 import MetaLemma from "./dom/metaLemma";
 import Deduction from "./dom/deduction";
+import Signature from "./dom/signature";
 import Conjecture from "./dom/conjecture";
 import Conclusion from "./dom/conclusion";
 import Derivation from "./dom/derivation";
@@ -38,6 +39,8 @@ import TypeAssertion from "./dom/assertion/type";
 import TypeDeclaration from "./dom/declaration/type";
 import DefinedAssertion from "./dom/assertion/defined";
 import PropertyRelation from "./dom/propertyRelation";
+import TermSubstitution from "./dom/substitution/term";
+import FrameSubstitution from "./dom/substitution/frame";
 import SubproofAssertion from "./dom/assertion/subproof";
 import PropertyAssertion from "./dom/assertion/property";
 import ContainedAssertion from "./dom/assertion/contained";
@@ -45,6 +48,8 @@ import SatisfiesAssertion from "./dom/assertion/satisfies";
 import VariableDeclaration from "./dom/declaration/variable";
 import BracketedCombinator from "./dom/combinator/bracketed";
 import BracketedConstructor from "./dom/constructor/bracketed";
+import ReferenceSubstitution from "./dom/substitution/reference";
+import StatementSubstitution from "./dom/substitution/statement";
 import CombinatorDeclaration from "./dom/declaration/combinator";
 import ConstructorDeclaration from "./dom/declaration/constructor";
 import ComplexTypeDeclaration from "./dom/declaration/complexType";