occam-verify-cli 0.0.1111 → 0.0.1112

package/src/unifier/equality.js

@@ -3,7 +3,6 @@
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
-import { findEquivalenceByTermNodes } from "../utilities/equivalences";
 
 const termNodeQuery = nodeQuery("/term");
 
@@ -37,7 +36,7 @@ class EqualityUnifier extends Unifier {
                   leftTermNode,
                   rightTermNode
                 ],
-                equivalence = findEquivalenceByTermNodes(equivalences, termNodes);
+                equivalence = equivalences.findEquivalenceByTermNodes(termNodes);
 
           termUnifiedWithTerm = (equivalence !== null);
         }

package/src/unifier/label.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
@@ -28,7 +28,7 @@ class LabelUnifier extends Unifier {
       unify: (generalTermNode, specificTermVariableNode, substitutions, generalContext, specificContext) => {
         let termUnified;
 
-        const { Term, Variable } = shim,
+        const { Term, Variable } = dom,
               termNode = generalTermNode, ///
               variableNode = specificTermVariableNode; ///
 

package/src/unifier/metaLevel.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import Unifier from "../unifier";
 import TermSubstitution from "../substitution/term";
 import FrameSubstitution from "../substitution/frame";
@@ -38,7 +38,7 @@ class MetaLevelUnifier extends Unifier {
               statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
         if (statementMetavariableNode !== null) {
-          const { Metavariable, Statement } = shim; ///
+          const { Metavariable, Statement } = dom; ///
 
           let context,
               statementNode;
@@ -60,7 +60,9 @@ class MetaLevelUnifier extends Unifier {
 
           statementUnified = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
         } else {
-          statementUnified = unifyChildNodes(generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext);
+          const childNodesUnified = unifyChildNodes(generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext);
+
+          statementUnified = childNodesUnified; ///
         }
 
         return statementUnified;
@@ -72,7 +74,7 @@ class MetaLevelUnifier extends Unifier {
       unify: (generalFrameMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
         let frameUnified;
 
-        const { Frame, Metavariable } = shim,
+        const { Frame, Metavariable } = dom,
               frameNode = specificFrameNode, ///
               metavariableNode = generalFrameMetavariableNode;  ///
 
@@ -97,7 +99,7 @@ class MetaLevelUnifier extends Unifier {
       unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
         let termUnified;
 
-        const { Term, Variable } = shim,
+        const { Term, Variable } = dom,
               termNode = specificTermNode, ///
               variableNode = generalTermVariableNode; ///
 
@@ -131,7 +133,7 @@ function unifyChildNodes(generalStatementNode, specificStatementNode, substituti
         generalChildNodes = generalNonTerminalNodeChildNodes, ///
         specificChildNodes = specificNonTerminalNodeChildNodes, ///
         childNodesVerified = metaLevelUnifier.unifyChildNodes(generalChildNodes, specificChildNodes, substitutions, generalContext, specificContext),
-        statementUnified = childNodesVerified; ///
+        childNodesUnified = childNodesVerified; ///
 
-  return statementUnified;
+  return childNodesUnified;
 }

package/src/unifier/metavariable.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
@@ -29,7 +29,7 @@ class MetavariableUnifier extends Unifier {
       unify: (generalTypeNode, specificTermNode, generalContext, specificContext) => {
         let termUnified;
 
-        const { Term } = shim,
+        const { Term } = dom,
               typeNode = generalTypeNode, ///
               termNode = specificTermNode, ///
               typeName = typeNameFromTypeNode(typeNode),

package/src/unifier/statementWithCombinator.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
@@ -32,7 +32,7 @@ class StatementWithCombinatorUnifier extends Unifier {
       unify: (generalMetaTypeNode, specificStatementNode, assignments, stated, generalContext, specificContext) => {
         let unified;
 
-        const { Statement, MetaType } = shim,
+        const { Statement, MetaType } = dom,
               metaTypeNode = generalMetaTypeNode, ///
               statementNode = specificStatementNode; ///
 
@@ -58,7 +58,7 @@ class StatementWithCombinatorUnifier extends Unifier {
       unify: (generalMetaTypeNode, specificFrameNode, assignments, stated, generalContext, specificContext) => {
         let unified;
 
-        const { Frame, MetaType } = shim,
+        const { Frame, MetaType } = dom,
               metaTypeNode = generalMetaTypeNode, ///
               frameNode = specificFrameNode; ///
 
@@ -84,7 +84,7 @@ class StatementWithCombinatorUnifier extends Unifier {
       unify: (generalTypeNode, specificTermNode, assignments, stated, generalContext, specificContext) => {
         let unified = false;
 
-        const { Term } = shim,
+        const { Term } = dom,
               typeNode = generalTypeNode, ///
               termNode = specificTermNode, ///
               typeName = typeNameFromTypeNode(typeNode);

package/src/unifier/termWithConstructor.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
@@ -29,7 +29,7 @@ class TermWithConstructorUnifier extends Unifier {
       unify: (generalTypeNode, specificTermNode, context) => {
         let unified = false;
 
-        const { Term } = shim,
+        const { Term } = dom,
               typeNode = generalTypeNode, ///
               typeName = typeNameFromTypeNode(typeNode),
               type = context.findTypeByTypeName(typeName);

package/src/utilities/json.js

@@ -1,6 +1,9 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
+import Combinator from "../combinator";
+import Constructor from "../constructor";
+import StatementSubstitution from "../substitution/statement";
 
 export function termFromJSON(json, fileContext) {
   let { term } = json;
@@ -9,7 +12,7 @@ export function termFromJSON(json, fileContext) {
 
   json = termJSON;  ///
 
-  const { Term } = shim;
+  const { Term } = dom;
 
   term = Term.fromJSON(json, fileContext);
 
@@ -61,7 +64,7 @@ export function superTypeFromJSON(json, fileContext) {
 export function statementFromJSON(json, fileContext) {
   let { statement } = json;
 
-  const { Statement } = shim,
+  const { Statement } = dom,
         statementJSON = statement;  ///
 
   json = statementJSON; ///
@@ -74,7 +77,7 @@ export function statementFromJSON(json, fileContext) {
 export function conclusionFromJSON(json, fileContext) {
   let { conclusion } = json;
 
-  const { Conclusion } = shim,
+  const { Conclusion } = dom,
         conclusionJSON = conclusion;  ///
 
   json = conclusionJSON;  ///
@@ -87,7 +90,7 @@ export function conclusionFromJSON(json, fileContext) {
 export function consequentFromJSON(json, fileContext) {
   let { consequent } = json;
 
-  const { Consequent } = shim,
+  const { Consequent } = dom,
         consequentJSON = consequent;  ///
 
   json = consequentJSON;  ///
@@ -100,7 +103,7 @@ export function consequentFromJSON(json, fileContext) {
 export function metavariableFromJSON(json, fileContext) {
   let { metavariable } = json;
 
-  const { Metavariable } = shim,
+  const { Metavariable } = dom,
         metavariableJSON = metavariable;  ///
 
   json = metavariableJSON; ///
@@ -110,23 +113,10 @@ export function metavariableFromJSON(json, fileContext) {
   return metavariable;
 }
 
-export function unqualifiedStatementFromJSON(json, fileContext) {
-  let { unqualifiedStatement } = json;
-
-  const { UnqualifiedStatement } = shim,
-        unqualifiedStatementJSON = unqualifiedStatement;  ///
-
-  json = unqualifiedStatementJSON; ///
-
-  unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
-
-  return unqualifiedStatement;
-}
-
 export function typesFromJSON(json, types, fileContext) {
   const { types: typesJSON } = json;
 
-  const { Type } = shim;
+  const { Type } = dom;
 
   typesJSON.forEach((typeJSON) => {
     const json = typeJSON,  ///
@@ -139,7 +129,7 @@ export function typesFromJSON(json, types, fileContext) {
 export function rulesFromJSON(json, fileContext) {
   let { rules } = json;
 
-  const { Rule } = shim,
+  const { Rule } = dom,
         rulesJSON = rules; ///
 
   rules = rulesJSON.map((ruleJSON) => {
@@ -155,7 +145,7 @@ export function rulesFromJSON(json, fileContext) {
 export function labelsFromJSON(json, fileContext) {
   let { labels } = json;
 
-  const { Label } = shim,
+  const { Label } = dom,
         labelsJSON = labels;  ///
 
   labels = labelsJSON.map((labelJSON) => {
@@ -171,7 +161,7 @@ export function labelsFromJSON(json, fileContext) {
 export function axiomsFromJSON(json, fileContext) {
   let { axioms } = json;
 
-  const { Axiom } = shim,
+  const { Axiom } = dom,
         axiomsJSON = axioms; ///
 
   axioms = axiomsJSON.map((axiomJSON) => {
@@ -187,7 +177,7 @@ export function axiomsFromJSON(json, fileContext) {
 export function premisesFromJSON(json, fileContext) {
   let { premises } = json;
 
-  const { Premise } = shim,
+  const { Premise } = dom,
         premisesJSON = premises;  ///
 
   premises = premisesJSON.map((premiseJSON) => {
@@ -203,7 +193,7 @@ export function premisesFromJSON(json, fileContext) {
 export function theoremsFromJSON(json, fileContext) {
   let { theorems } = json;
 
-  const { Theorem } = shim,
+  const { Theorem } = dom,
         theoremsJSON = theorems; ///
 
   theorems = theoremsJSON.map((theoremJSON) => {
@@ -219,7 +209,7 @@ export function theoremsFromJSON(json, fileContext) {
 export function variablesFromJSON(json, fileContext) {
   let { variables } = json;
 
-  const { Variable } = shim,
+  const { Variable } = dom,
         variablesJSON = variables; ///
 
   variables = variablesJSON.map((variableJSON) => {
@@ -235,7 +225,7 @@ export function variablesFromJSON(json, fileContext) {
 export function conjecturesFromJSON(json, fileContext) {
   let { conjectures } = json;
 
-  const { Conjecture } = shim,
+  const { Conjecture } = dom,
         conjecturesJSON = conjectures; ///
 
   conjectures = conjecturesJSON.map((conjectureJSON) => {
@@ -251,8 +241,7 @@ export function conjecturesFromJSON(json, fileContext) {
 export function combinatorsFromJSON(json, fileContext) {
   let { combinators } = json;
 
-  const { Combinator } = shim,
-        combinatorsJSON = combinators; ///
+  const combinatorsJSON = combinators; ///
 
   combinators = combinatorsJSON.map((combinatorJSON) => {
     const json = combinatorJSON,  ///
@@ -267,8 +256,7 @@ export function combinatorsFromJSON(json, fileContext) {
 export function constructorsFromJSON(json, fileContext) {
   let { constructors } = json;
 
-  const { Constructor } = shim,
-        constructorsJSON = constructors; ///
+  const constructorsJSON = constructors; ///
 
   constructors = constructorsJSON.map((constructorJSON) => {
     const json = constructorJSON,  ///
@@ -283,7 +271,7 @@ export function constructorsFromJSON(json, fileContext) {
 export function metatheoremsFromJSON(json, fileContext) {
   let { metatheorems } = json;
 
-  const { Metatheorem } = shim,
+  const { Metatheorem } = dom,
         metatheoremsJSON = metatheorems; ///
 
   metatheorems = metatheoremsJSON.map((metatheoremJSON) => {
@@ -299,7 +287,7 @@ export function metatheoremsFromJSON(json, fileContext) {
 export function suppositionsFromJSON(json, fileContext) {
   let { suppositions } = json;
 
-  const { Supposition } = shim,
+  const { Supposition } = dom,
         suppositionsJSON = suppositions;  ///
 
   suppositions = suppositionsJSON.map((suppositionJSON) => {
@@ -315,8 +303,7 @@ export function suppositionsFromJSON(json, fileContext) {
 export function substitutionsFromJSON(json, fileContext) {
   let { substitutions = [] } = json;  ///
 
-  const { StatementSubstitution } = shim,
-        substitutionsJSON = substitutions,  ///
+  const substitutionsJSON = substitutions,  ///
         Substitution = StatementSubstitution; ///
 
   substitutions = substitutionsJSON.map((substitutionJSON) => {
@@ -332,7 +319,7 @@ export function substitutionsFromJSON(json, fileContext) {
 export function metavariablesFromJSON(json, fileContext) {
   let { metavariables } = json;
 
-  const { Metavariable } = shim,
+  const { Metavariable } = dom,
         metavariablesJSON = metavariables; ///
 
   metavariables = metavariablesJSON.map((metavariableJSON) => {
@@ -408,12 +395,6 @@ export function metavariableToMetavariableJSON(metavariable) {
   return metavariableJSON;
 }
 
-export function unqualifiedStatementToUnqualifiedStatementJSON(unqualifiedStatement) {
-  const unqualifiedStatementJSON = unqualifiedStatement.toJSON();
-
-  return unqualifiedStatementJSON;
-}
-
 export function typesToTypesJSON(types) {
   const typesJSON = types.map((type) => {
     const typeJSON = type.toJSON();

package/src/utilities/string.js

@@ -2,12 +2,6 @@
 
 import { COMMA, EMPTY_STRING } from "../constants";
 
-export function trim(string) {
-  string = string.replace(/\s+$/, EMPTY_STRING);  ///
-
-  return string;
-}
-
 export function nodeAsString(node, tokens) {
   let string;
 
@@ -15,6 +9,8 @@ export function nodeAsString(node, tokens) {
 
   string = tokensAsString(tokens);
 
+  string = trimString(string);  ///
+
   return string;
 }
 
@@ -60,6 +56,12 @@ export function nodeAsTokens(node, tokens) {
   return tokens;
 }
 
+function trimString(string) {
+  string = string.replace(/\s+$/, EMPTY_STRING);  ///
+
+  return string;
+}
+
 function terminalNodeAsTokens(terminalNode, tokens) {
   const significantToken = terminalNode.getSignificantToken(),
         token = significantToken; ///

package/src/utilities/subproof.js

@@ -3,8 +3,8 @@
 import { nodeQuery, nodesQuery } from "./query";
 import { nodeAsString, nodesAsString } from "./string";
 
-const suppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement"),
-      lastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement");
+const suppositionStatementNodesQuery = nodesQuery("/subproof/supposition/statement"),
+      lastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/statement");
 
 export function subproofStringFromSubproofNode(subproofNode, fileContext) {
   let subproofString = null;

package/src/utilities/substitutions.js

@@ -1,12 +1,12 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import TermSubstitution from "../substitution/term";
 import FrameSubstitution from "../substitution/frame";
 
 export function termFromTermAndSubstitutions(term, substitutions, context) {
   if (term !== null) {
-    const { Variable } = shim,
+    const { Variable } = dom,
           termNode = term.getNode(),
           variable = Variable.fromTermNode(termNode, context);
 
@@ -24,12 +24,14 @@ export function termFromTermAndSubstitutions(term, substitutions, context) {
 
 export function frameFromFrameAndSubstitutions(frame, substitutions, context) {
   if (frame !== null) {
-    const { Metavariable } = shim,
+    const { Metavariable } = dom,
           frameNode = frame.getNode(),
           metavariable = Metavariable.fromFrameNode(frameNode, context);
 
     if (metavariable !== null) {
-      const substitution = substitutions.findSubstitutionByMetavariable(metavariable);
+      let substitution = null;
+
+      substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution);
 
       if (substitution !== null) {
         frame = substitution.getFrame();
@@ -42,7 +44,7 @@ export function frameFromFrameAndSubstitutions(frame, substitutions, context) {
 
 export function statementFromStatementAndSubstitutions(statement, substitutions, context) {
   if (statement !== null) {
-    const { Metavariable } = shim,
+    const { Metavariable } = dom,
           statementNode = statement.getNode(),
           metavariable = Metavariable.fromStatementNode(statementNode, context);
 

package/src/utilities/verification.js

@@ -1,14 +1,26 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import LocalContext from "../context/local";
-import TypeAssertion from "../assertion/type";
-import DefinedAssertion from "../assertion/defined";
-import SubproofAssertion from "../assertion/subproof";
-import ContainedAssertion from "../assertion/contained";
 
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/brackets";
 
+export function stripBracketsFromTerm(term, context) {
+  const termNode = term.getNode(),
+        bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
+
+  if (bracketedTermChildNode !== null) {
+    context = contextFromTerm(term, context); ///
+
+    const { Term } = dom,
+          termNode = bracketedTermChildNode;  ///
+
+    term = Term.fromStatementNode(termNode, context);
+  }
+
+  return term;
+}
+
 export function stripBracketsFromStatement(statement, context) {
   const statementNode = statement.getNode(),
         bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
@@ -16,7 +28,7 @@ export function stripBracketsFromStatement(statement, context) {
   if (bracketedStatementChildNode !== null) {
     context = contextFromStatement(statement, context); ///
 
-    const { Statement } = shim,
+    const { Statement } = dom,
           statementNode = bracketedStatementChildNode;  ///
 
     statement = Statement.fromStatementNode(statementNode, context);
@@ -28,7 +40,7 @@ export function stripBracketsFromStatement(statement, context) {
 export function equalityFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///
 
-  const { Equality } = shim,
+  const { Equality } = dom,
         statementNode = statement.getNode(),
         equality = Equality.fromStatementNode(statementNode, context);
 
@@ -38,7 +50,7 @@ export function equalityFromStatement(statement, context) {
 export function judgementFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///
 
-  const { Judgement } = shim,
+  const { Judgement } = dom,
         statementNode = statement.getNode(),
         judgement = Judgement.fromStatementNode(statementNode, context);
 
@@ -48,7 +60,7 @@ export function judgementFromStatement(statement, context) {
 export function metavariableFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///
 
-  const { Metavariable } = shim,
+  const { Metavariable } = dom,
         statementNode = statement.getNode(),
         metavariable = Metavariable.fromStatementNode(statementNode, context);
 
@@ -58,7 +70,8 @@ export function metavariableFromStatement(statement, context) {
 export function typeAssertionFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///
 
-  const statementNode = statement.getNode(),
+  const { TypeAssertion } = dom,
+        statementNode = statement.getNode(),
         typeAssertion = TypeAssertion.fromStatementNode(statementNode, context);
 
   return typeAssertion;
@@ -67,7 +80,8 @@ export function typeAssertionFromStatement(statement, context) {
 export function definedAssertionFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///
 
-  const statementNode = statement.getNode(),
+  const { DefinedAssertion } = dom,
+        statementNode = statement.getNode(),
         definedAssertion = DefinedAssertion.fromStatementNode(statementNode, context);
 
   return definedAssertion;
@@ -76,7 +90,8 @@ export function definedAssertionFromStatement(statement, context) {
 export function subproofAssertionFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///
 
-  const statementNode = statement.getNode(),
+  const { SubproofAssertion } = dom,
+        statementNode = statement.getNode(),
         subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);
 
   return subproofAssertion;
@@ -85,7 +100,8 @@ export function subproofAssertionFromStatement(statement, context) {
 export function containedAssertionFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///
 
-  const statementNode = statement.getNode(),
+  const { ContainedAssertion } = dom,
+        statementNode = statement.getNode(),
         containedAssertion = ContainedAssertion.fromStatementNode(statementNode, context);
 
   return containedAssertion;

package/src/verifier/combinator.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import Verifier from "../verifier";
 import LocalContext from "../context/local";
 
@@ -28,7 +28,7 @@ class CombinatorVerifier extends Verifier {
     {
       nodeQuery: statementNodeQuery,
       verify: (statementNode, fileContext) => {
-        const { Statement } = shim,
+        const { Statement } = dom,
               localContext = LocalContext.fromFileContext(fileContext),
               context = localContext, ///
               statement = Statement.fromStatementNode(statementNode, context),
@@ -42,7 +42,7 @@ class CombinatorVerifier extends Verifier {
     {
       nodeQuery: termNodeQuery,
       verify: (termNode, fileContext) => {
-        const { Term } = shim,
+        const { Term } = dom,
               localContext = LocalContext.fromFileContext(fileContext),
               context = localContext, ///
               term = Term.fromTermNode(termNode, context),

package/src/verifier/constructor.js

@@ -1,11 +1,11 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import Verifier from "../verifier";
 import LocalContext from "../context/local";
 
 import { nodeQuery } from "../utilities/query";
-import {typeNameFromTypeNode} from "../utilities/name";
+import { typeNameFromTypeNode } from "../utilities/name";
 
 const termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type");
@@ -31,7 +31,7 @@ class ConstructorVerifier extends Verifier {
     {
       nodeQuery: termNodeQuery,
       verify: (termNode, fileContext, verifyAhead) => {
-        const { Term } = shim,
+        const { Term } = dom,
               localContext = LocalContext.fromFileContext(fileContext),
               context = localContext, ///
               term = Term.fromTermNode(termNode, context),