occam-verify-cli 0.0.968 → 0.0.971

package/src/proofStep.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import Substitutions from "./substitutions";
-import intrinsicLevelUnifier from "./unifier/intrinsicLevel";
+import unifyStatementWithStatementGivenEquivalences from "./unify/statementWithSttaemetnGivenEquivalences";
 
 export default class ProofStep {
   constructor(subproofNode, statementNode) {
@@ -21,26 +20,8 @@ export default class ProofStep {
     let statementUnified = false;
 
     if (this.statementNode !== null) {
-      let statementUnifiedWithStatement = false;
-
-      if (!statementUnifiedWithStatement) {
-        const statementNodeA = this.statementNode;  ///
-
-        statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
-      }
-
-      if (!statementUnifiedWithStatement) {
-        const statementNodeA = statementNodeB,  ///
-              localContext = localContextA; ///
-
-        statementNodeB = this.statementNode;  ///
-
-        localContextA = localContextB;  ///
-
-        localContextB = localContext; ///
-
-        statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
-      }
+      const statementNodeA = this.statementNode,  ///
+            statementUnifiedWithStatement = unifyStatementWithStatementGivenEquivalences(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
 
       statementUnified = statementUnifiedWithStatement;  ///
     }
@@ -62,29 +43,3 @@ export default class ProofStep {
     return proofStep;
   }
 }
-
-function unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
-  let statementUnifiedWithStatement = false;
-
-  const statementStringA = localContextA.nodeAsString(statementNodeA),
-        statementStringB = localContextB.nodeAsString(statementNodeB);
-
-  localContextB.trace(`Unifying the '${statementStringB}' statement with the '${statementStringA}' statement...`, statementNodeB);
-
-  const substitutions = Substitutions.fromNothing(),
-        nodeA = statementNodeA,  ///
-        nodeB = statementNodeB,  ///
-        unified = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-  if (unified) {
-    const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
-
-    statementUnifiedWithStatement = substitutionsUnifiedWithEquivalences;  ///
-  }
-
-  if (statementUnifiedWithStatement) {
-    localContextB.debug(`...unified the '${statementStringB}' statement with the '${statementStringA}' statement.`, statementNodeB);
-  }
-
-  return statementUnifiedWithStatement;
-}

package/src/releaseContext/initialise.js

@@ -1,6 +1,6 @@
 "use strict";
 
-export default function initialiseReleaseContext(dependency, dependentName, dependentReleased, context) {
+export default function initialiseReleaseContext(dependency, context) {
   let releaseContextInitialised = false;
 
   const { releaseContextMap } = context,
@@ -16,27 +16,19 @@ export default function initialiseReleaseContext(dependency, dependentName, depe
     releaseContextInitialised = releaseContext.isInitialised();
 
     if (!releaseContextInitialised) {
-      const released = releaseContext.isReleased();
+      const dependencyReleaseContextsInitialised = initialiseDependencyReleaseContexts(dependency, releaseContext, context);
 
-      if (!released && dependentReleased) {
-        const { log } = context;
+      if (dependencyReleaseContextsInitialised) {
+        const { log } = context,
+              releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
 
-        log.warning(`Unable to initialise the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
-      } else {
-        const dependencyReleaseContextsInitialised = initialiseDependencyReleaseContexts(dependency, releaseContext, released, context);
+        log.debug(`Initialising the '${dependencyName}' context...`);
 
-        if (dependencyReleaseContextsInitialised) {
-          const { log } = context,
-                releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
+        releaseContextInitialised = releaseContext.initialise(releaseContexts);
 
-          log.debug(`Initialising the '${dependencyName}' context...`);
-
-          releaseContextInitialised = releaseContext.initialise(releaseContexts);
-
-          releaseContextInitialised ?
-            log.info(`...initialised the '${dependencyName}' context.`) :
-              log.warning(`...unable to initialise the '${dependencyName}' context.`);
-        }
+        releaseContextInitialised ?
+          log.info(`...initialised the '${dependencyName}' context.`) :
+            log.warning(`...unable to initialise the '${dependencyName}' context.`);
       }
     }
   }
@@ -81,13 +73,10 @@ function retrieveReleaseContexts(releaseContext, releaseContextMap) {
   return releaseContexts;
 }
 
-function initialiseDependencyReleaseContexts(dependency, releaseContext, released, context) {
-  const dependencyName = dependency.getName(),
-        dependentName = dependencyName,  ///
-        dependencies = releaseContext.getDependencies(),
-        dependentReleased = released,  ///
+function initialiseDependencyReleaseContexts(dependency, releaseContext, context) {
+  const dependencies = releaseContext.getDependencies(),
         dependencyReleaseContextsInitialised = dependencies.everyDependency((dependency) => {  ///
-          const releaseContextInitialised = initialiseReleaseContext(dependency, dependentName, dependentReleased, context);
+          const releaseContextInitialised = initialiseReleaseContext(dependency, context);
 
           if (releaseContextInitialised) {
             return true;

package/src/resolve/substitutions.js

@@ -0,0 +1,134 @@
+"use strict";
+
+import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
+import metaLevelUnifier from "../unifier/metaLevel";
+
+export default function resolveSubstitutions(substitutions, fileContextA, localContextB) {
+  let substitutionsResolved = substitutions.areResolved();
+
+  if (!substitutionsResolved) {
+    const localContextA = LocalContext.fromFileContext(fileContextA),
+          metavariableNodes = substitutions.getMetavariableNodes();
+
+    substitutionsResolved = metavariableNodes.every((metavariableNode) => {
+      const complexSubstitutions = substitutions.findComplexSubstitutionsByMetavariableNode(metavariableNode),
+            complexSubstitutionsResolved = resolveComplexSubstitutions(complexSubstitutions, substitutions, localContextA, localContextB);
+
+      if (complexSubstitutionsResolved) {
+        return true;
+      }
+    });
+  }
+
+  return substitutionsResolved;
+}
+
+function resolveComplexSubstitution(complexSubstitution, substitutions, localContextA, localContextB) {
+  let complexSubstitutionResolved = false;
+
+  const metavariableNode = complexSubstitution.getMetavariableNode(),
+        simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
+
+  if (simpleSubstitution !== null) {
+    const complexSubstitutionResolvedAgainstSimpleSubstitution = resolveComplexSubstitutionAgainstSimpleSubstitution(complexSubstitution, simpleSubstitution, substitutions, localContextA, localContextB);
+
+    complexSubstitutionResolved = complexSubstitutionResolvedAgainstSimpleSubstitution; ///
+  }
+
+  return complexSubstitutionResolved;
+}
+
+function resolveComplexSubstitutions(complexSubstitutions, substitutions, localContextA, localContextB) {
+  const complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
+    const complexSubstitutionResolved = resolveComplexSubstitution(complexSubstitution, substitutions, localContextA, localContextB);
+
+    if (complexSubstitutionResolved) {
+      return true;
+    }
+  });
+
+  return complexSubstitutionsResolved;
+}
+
+function resolveComplexSubstitutionAgainstSimpleSubstitution(complexSubstitution, simpleSubstitution, substitutions, localContextA, localContextB) {
+  let complexSubstitutionResolvedAgainstSimpleSubstitution = false;
+
+  const statementNode = complexSubstitution.getStatementNode(),
+        simpleSubstitutionString = simpleSubstitution.asString(localContextA, localContextB),
+        complexSubstitutionString = complexSubstitution.asString(localContextA, localContextB);
+
+  localContextB.trace(`Resolving the complex ${complexSubstitutionString} substitution against the simple ${simpleSubstitutionString} substitution...`, statementNode);
+
+  const transformedSubstitution = transformedSubstitutionFromComplexSubstitutionSimpleSubstitutionAndSubstitutions(complexSubstitution, simpleSubstitution, substitutions, localContextA, localContextB);
+
+  if (transformedSubstitution !== null) {
+    const variableNode = transformedSubstitution.getVariableNode(),
+          substitution = substitutions.findSubstitutionByVariableNode(variableNode);
+
+    if (substitution === null) {
+      simpleSubstitution = transformedSubstitution; ///
+
+      substitutions.addSubstitution(simpleSubstitution, localContextA, localContextB);
+
+      substitutions.removeSubstitution(complexSubstitution, localContextA, localContextB);
+
+      complexSubstitutionResolvedAgainstSimpleSubstitution = true;
+    } else {
+      const termNode = transformedSubstitution.getTermNode(),
+            termNodeMatches = substitution.matchTermNode(termNode);
+
+      if (termNodeMatches) {
+        substitutions.removeSubstitution(complexSubstitution, localContextA, localContextB);
+
+        complexSubstitutionResolvedAgainstSimpleSubstitution = true;
+      }
+    }
+  }
+
+  if (complexSubstitutionResolvedAgainstSimpleSubstitution) {
+    localContextB.debug(`...resolved the complex ${complexSubstitutionString} substitution against the simple ${simpleSubstitutionString} substitution.`, statementNode);
+  }
+
+  return complexSubstitutionResolvedAgainstSimpleSubstitution;
+}
+
+function unifyComplexSubstitutionStatementWithSimpleSubstitutionStatement(complexSubstitutionStatementNode, simpleSubstitutionStatementNode, substitutions, localContextA, localContextB) {
+  let complexSubstitutionStatementWithSimpleSubstitutionStatement;
+
+  const nodeA = complexSubstitutionStatementNode,  ///
+        nodeB = simpleSubstitutionStatementNode;  ///
+
+  localContextA = localContextB;  ///
+
+  const unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+  complexSubstitutionStatementWithSimpleSubstitutionStatement = unified;  ///
+
+  return complexSubstitutionStatementWithSimpleSubstitutionStatement;
+}
+
+function transformedSubstitutionFromComplexSubstitutionSimpleSubstitutionAndSubstitutions(complexSubstitution, simpleSubstitution, substitutions, localContextA, localContextB) {
+  let transformedSubstitution;
+
+  const substitution = complexSubstitution.getSubstitution();
+
+  transformedSubstitution = substitution.transformed(substitutions);
+
+  if (transformedSubstitution !== null) {
+    const simpleSubstitutionStatementNode = simpleSubstitution.getStatementNode(),
+          complexSubstitutionStatementNode = complexSubstitution.getStatementNode();
+
+    substitutions = Substitutions.fromNothing();  ///
+
+    const complexSubstitutionStatementWithSimpleSubstitutionStatement = unifyComplexSubstitutionStatementWithSimpleSubstitutionStatement(complexSubstitutionStatementNode, simpleSubstitutionStatementNode, substitutions, localContextA, localContextB);
+
+    if (complexSubstitutionStatementWithSimpleSubstitutionStatement) {
+      const substitution = transformedSubstitution; ///
+
+      transformedSubstitution = substitution.transformed(substitutions);
+    }
+  }
+
+  return transformedSubstitution;
+}

package/src/rule.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import Substitutions from "./substitutions";
+import resolveSubstitutions from "./resolve/substitutions";
 import unifyPremisesWithProofSteps from "./unify/premisesWithProofSteps";
 import unifyConclusionWithStatement from "./unify/conclusionWithStatement";
 
@@ -43,22 +44,26 @@ export default class Rule {
       const conclusionA = this.conclusion,  ///
             conclusionUnified = unifyConclusionWithStatement(conclusionA, statementNode, substitutions, fileContextA, localContextB);
 
-      statementUnified = conclusionUnified;  ///
+      if (conclusionUnified) {
+        const substitutionsResolved = resolveSubstitutions(substitutions, fileContextA, localContextB);
+
+        statementUnified = substitutionsResolved; ///
+      }
     }
 
     return statementUnified;
   }
 
   matchMetavariableNode(metavariableNode) {
-    const matchesMetavariableNode = this.labels.some((label) => {
-      const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
+    const metavariableNodeMatches = this.labels.some((label) => {
+      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
 
-      if (labelMatchesMetavariableNode) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
 
-    return matchesMetavariableNode;
+    return metavariableNodeMatches;
   }
 
   static fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext) {

package/src/substitution/statementForMetavariable.js

@@ -1,32 +1,31 @@
 "use strict";
 
-import shim from "../shim";
 import Substitution from "../substitution";
-import TermForVariableSubstitution from "./termForVariable";
-import unifyStatementWithStatement from "../unify/statementAtainstStatement";
+import TermForVariableSubstitution from "../substitution/termForVariable";
 
 import { nodeQuery } from "../utilities/query";
-import { matchStatementModuloBrackets, bracketedStatementChildNodeFromStatementNode } from "../utilities/match";
+import { stripBracketsFromStatement } from "../utilities/brackets";
 
-const metavariableNodeQuery = nodeQuery("/statement/metavariable!");
+const statementNodeQuery = nodeQuery("/substitution/statement!"),
+      metavariableNodeQuery = nodeQuery("/*/metavariable!");
 
 export default class StatementForMetavariableSubstitution extends Substitution {
-  constructor(metavariableNode, statementNode, substitution) {
+  constructor(statementNode, metavariableNode, substitution) {
     super();
 
-    this.metavariableNode = metavariableNode;
     this.statementNode = statementNode;
+    this.metavariableNode = metavariableNode;
     this.substitution = substitution;
   }
 
-  getMetavariableNode() {
-    return this.metavariableNode;
-  }
-
   getStatementNode() {
     return this.statementNode;
   }
 
+  getMetavariableNode() {
+    return this.metavariableNode;
+  }
+
   getSubstitution() {
     return this.substitution;
   }
@@ -37,129 +36,144 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return node;
   }
 
-  matchStatementNode(statementNode) {
-    const statementNodeA = statementNode, ///
-          statementNodeB = this.statementNode,  ///
-          statementNodesMatch = matchStatementModuloBrackets(statementNodeA, statementNodeB),
-          statementNodeMatches = statementNodesMatch; ///
+  isSimple() {
+    const simple = (this.substitution === null);
 
-    return statementNodeMatches;
+    return simple;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
-
-    return metavariableNodeMatches;
-  }
+  transformed(substitutions) {
+    let transformedSubstitution = null;
 
-  unifyStatement(statementNode, substitutions, localContextA, localContextB) {
-    let statementNodeMatches;
+    const transformedStatementNode = transformStatementNode(this.statementNode, substitutions);
 
-    const substitution = this.substitution, ///
-          statementNodeA = statementNode,  ///
-          statementNodeB = this.statementNode; ///
+    if (transformedStatementNode !== null) {
+      const substitution = null,
+            statementNode = transformedStatementNode, ///
+            metavariableNode = this.metavariableNode, ///
+            statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
 
-    statementNodeMatches = unifyStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+      transformedSubstitution = statementForMetavariableSubstitution;  ///
+    }
 
-    if (!statementNodeMatches) {
-      const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
+    return transformedSubstitution;
+  }
 
-      if (bracketedStatementChildNode !== null) {
-        const statementNodeA = bracketedStatementChildNode; ///
+  matchStatementNode(statementNode) {
+    statementNode = stripBracketsFromStatement(statementNode); ///
 
-        statementNodeMatches = unifyStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
-      }
-    }
+    const statementNodeMatches = this.statementNode.match(statementNode);
 
     return statementNodeMatches;
   }
 
-  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
-    let unifiedWithEquivalence = false;  ///
-
-    const metavariableNode = metavariableNodeQuery(this.statementNode);
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
 
-    if (metavariableNode !== null) {
-      substitutions = [ ///
-        ...substitutions
-      ];
+    return metavariableNodeMatches;
+  }
 
-      const { metaLevelUnifier } = shim,
-            nodeA = this.metavariableNode, ///
-            nodeB = metavariableNode, ///
-            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeAndSubstitutionNodeMatches = false;
 
-      unifiedWithEquivalence = unified; ///
-    }
-
-    return unifiedWithEquivalence;
+    return metavariableNodeAndSubstitutionNodeMatches;
   }
 
   asString(localContextA, localContextB) {
+    let string;
+
     const statementNodeB = this.statementNode,  ///
           statementStringB = localContextB.nodeAsString(statementNodeB),
           metavariableNodeA = this.metavariableNode,  ///
-          metavariableStringA = localContextA.nodeAsString(metavariableNodeA),
-          string = `[${statementStringB} for ${metavariableStringA}]`;
+          metavariableStringA = localContextA.nodeAsString(metavariableNodeA);
+
+    if (this.substitution === null) {
+      string = `[${statementStringB} for ${metavariableStringA}]`;
+    } else {
+      const substitutionString = this.substitution.asString(localContextA, localContextA);
+
+      string = `[${statementStringB} for ${metavariableStringA}${substitutionString}]`;
+    }
 
     return string;
   }
 
-  static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
-    let statementForMetavariableSubstitution;
-
-    const substitution = null;
+  static fromSubstitutionNode(substitutionNode) {
+    let statementForMetavariableSubstitution = null;
 
-    statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
+    let statementNode = statementNodeQuery(substitutionNode),
+        metavariableNode = metavariableNodeQuery(substitutionNode);
 
-    const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
+    if (statementNode !== null) {
+      statementNode = stripBracketsFromStatement(statementNode); ///
 
-    if (bracketedStatementChildNode !== null) {
-      const statementNode = bracketedStatementChildNode; ///
+      const substitution = null;
 
-      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
+      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
     }
 
     return statementForMetavariableSubstitution;
   }
 
-  static fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode) {
-    let statementForMetavariableSubstitution;
+  static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode) {
+    statementNode = stripBracketsFromStatement(statementNode); ///
 
-    let substitution = null;
+    const substitution = null,
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
 
-    if (substitutionNode !== null) {
-      const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode);
+    return statementForMetavariableSubstitution;
+  }
 
-      substitution = termForVariableSubstitution; ///
-    }
+  static fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode) {
+    statementNode = stripBracketsFromStatement(statementNode); ///
 
-    statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
+    const substitution = substitutionFromSubstitutionNode(substitutionNode),
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
 
-    const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
+    return statementForMetavariableSubstitution;
+  }
+}
 
-    if (bracketedStatementChildNode !== null) {
-      const statementNode = bracketedStatementChildNode; ///
+function substitutionFromSubstitutionNode(substitutionNode) {
+  let substitution = null;
 
-      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
+  if (substitution === null) {
+    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode);
+
+    if (termForVariableSubstitution !== null) {
+      substitution = termForVariableSubstitution; ///
     }
+  }
 
-    return statementForMetavariableSubstitution;
+  if (substitution === null) {
+    const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromSubstitutionNode(substitutionNode);
+
+    if (statementForMetavariableSubstitution !== null) {
+      substitution = statementForMetavariableSubstitution;  ///
+    }
   }
+
+  return substitution;
 }
 
-function unifyStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
-  let statementUnified;
+function transformStatementNode(statementNode, substitutions) {
+  let transformedStatementNode = null;
 
-  if (substitution === null) {
-    const statementNodeAMatchesStatementNodeB = statementNodeB.match(statementNodeA);
+  const metavariableNode = metavariableNodeQuery(statementNode);
+
+  if (metavariableNode !== null) {
+    substitutions.someSubstitution((substitution) => {
+      const substitutionMatchesVariableNode = substitution.matchVariableNode(metavariableNode);
 
-    statementUnified = statementNodeAMatchesStatementNodeB; ///
-  } else {
-    const statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+      if (substitutionMatchesVariableNode) {
+        const statementNode = substitution.getStatementNode();
 
-    statementUnified = statementUnifiedWithStatement; ///
+        transformedStatementNode = statementNode; ////
+
+        return true;
+      }
+    });
   }
 
-  return statementUnified;
-}
+  return transformedStatementNode;
+}