occam-verify-cli 1.0.206 → 1.0.211

package/src/dom/assertion/satisfies.js

@@ -4,14 +4,16 @@ import dom from "../../dom";
 
 import { domAssigned } from "../../dom";
 
+import LocalContext from "../../context/local";
 import Substitutions from "../../substitutions";
+import {statementFromJSON} from "../../utilities/json";
 
 export default domAssigned(class SatisfiesAssertion {
-  constructor(string, node, tokens, terms, reference) {
+  constructor(string, node, tokens, signature, reference) {
     this.string = string;
     this.node = node;
     this.tokens = tokens;
-    this.terms = terms;
+    this.signature = signature;
     this.reference = reference;
   }
 
@@ -27,8 +29,8 @@ export default domAssigned(class SatisfiesAssertion {
     return this.tokens;
   }
 
-  getTerms() {
-    return this.terms;
+  getSignature() {
+    return this.signature;
   }
 
   getReference() {
@@ -36,20 +38,7 @@ export default domAssigned(class SatisfiesAssertion {
   }
 
   matchSubstitutions(substitutions, context) {
-    let substitutionsMatch;
-
-    const termsString = termsStringFromTerms(this.terms),
-          substitutionsString = substitutions.asString();
-
-    context.trace(`Matching the '${substitutionsString}' substitutions against the ${termsString} terms...`);
-
-    const termsMatch = substitutions.matchTerms(this.terms);
-
-    substitutionsMatch = termsMatch;  ///
-
-    if (substitutionsMatch) {
-      context.debug(`...matched the '${substitutionsString}' substitutions against the ${termsString} terms.`);
-    }
+    const substitutionsMatch = this.signature.matchSubstitutions(substitutions, context);
 
     return substitutionsMatch;
   }
@@ -61,9 +50,9 @@ export default domAssigned(class SatisfiesAssertion {
 
     context.trace(`Verifying the '${satisfiesAssertionString}' satisfies assertion...`);
 
-    const termsVerified = this.verifyTerms(assignments, stated, context);
+    const signatureVerified = this.verifySignature(assignments, stated, context);
 
-    if (termsVerified) {
+    if (signatureVerified) {
       const referenceVerified = this.verifyReference(assignments, stated, context);
 
       verified = referenceVerified; ///
@@ -76,28 +65,10 @@ export default domAssigned(class SatisfiesAssertion {
     return verified;
   }
 
-  verifyTerms(assignments, stated, context) {
-    let termsVerified;
-
-    const termsString = termsStringFromTerms(this.terms);
+  verifySignature(assignments, stated, context) {
+    const signatureVerified = this.signature.verify(context);
 
-    context.trace(`Verifying the ${termsString} terms...`);
-
-    termsVerified = this.terms.every((term) => {
-      const termVerified = term.verify(context, () => {
-        const verifiedAhead = true;
-
-        return verifiedAhead;
-      });
-
-      return termVerified;
-    });
-
-    if (termsVerified) {
-      context.debug(`...verified the ${termsString} terms.`);
-    }
-
-    return termsVerified;
+    return signatureVerified;
   }
 
   verifyReference(assignments, stated, context) {
@@ -125,22 +96,42 @@ export default domAssigned(class SatisfiesAssertion {
   }
 
   unifyStatement(statement, context) {
-    let statementUnified;
+    let statementUnified = false;
 
     const statementString = statement.getString(),
           satisfiesAssertionString = this.string;
 
     context.trace(`Unifying the '${statementString}' statement with the '${satisfiesAssertionString}' satisfies assertion...`);
 
+    this.signature.verify(context);
+
+    let substitutions;
+
     const axiom = context.findAxiomByReference(this.reference),
-          substitutions = Substitutions.fromNothing();
+          fileContext = axiom.getFileContext(),
+          localContext = LocalContext.fromFileContext(fileContext);
 
-    statementUnified = axiom.unifyStatement(statement, substitutions, context);
+    substitutions = Substitutions.fromNothing();
 
-    if (statementUnified) {
-      const substitutionsMatch = this.matchSubstitutions(substitutions, context);
+    const generalContext = localContext,  ///
+          specificContext = context,  ///
+          signatureMatches = axiom.matchSignature(this.signature, substitutions, generalContext, specificContext);
+
+    if (signatureMatches) {
+      const substitutionsB = substitutions; ///
+
+      substitutions = Substitutions.fromNothing();
 
-      statementUnified = substitutionsMatch;  ///
+      statementUnified = axiom.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+      if (statementUnified) {
+        const substitutionsA = substitutions, ///
+              substitutionsMatch = substitutionsB.matchSubstitutions(substitutionsA);
+
+        if (!substitutionsMatch) {
+          statementUnified = false;
+        }
+      }
     }
 
     if (statementUnified) {
@@ -162,38 +153,20 @@ export default domAssigned(class SatisfiesAssertion {
             node = satisfiesAssertionNode,  ///
             string = context.nodeAsString(node),
             tokens = context.nodeAsTokens(node),
-            terms = termsFromSatisfiesAssertionNode(satisfiesAssertionNode, context),
+            signature = signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context),
             reference = Reference.fromSatisfiesAssertionNode(satisfiesAssertionNode, context);
 
-      satisfiesAssertion = new SatisfiesAssertion(string, node, tokens, terms, reference);
+      satisfiesAssertion = new SatisfiesAssertion(string, node, tokens, signature, reference);
     }
 
     return satisfiesAssertion;
   }
 });
 
-function termsStringFromTerms(terms) {
-  const termsString = terms.reduce((termsString, term) => {
-    const termString = term.getString();
-
-    termsString = (termsString === null) ?
-                   `'${termString}'` :  ///
-                     `${termsString}, '${termString}'`;
-
-    return termsString;
-  }, null);
-
-  return termsString;
-}
-
-function termsFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-  const termNodes = satisfiesAssertionNode.getTermNodes(),
-        terms = termNodes.map((termNode) => {
-          const { Term } = dom,
-                term = Term.fromTermNode(termNode, context);
-
-          return term;
-        });
+function signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
+  const { Signature } = dom,
+        signatureNode = satisfiesAssertionNode.getSignatureNode(),
+        signature = Signature.fromSignatureNode(signatureNode, context);
 
-  return terms;
+  return signature;
 }

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(),