occam-verify-cli 0.0.698 → 0.0.702

package/src/verifier/nodes/statement.js

@@ -60,7 +60,7 @@ const statementNodesVerifier = new StatementNodesVerifier();
 
 export default statementNodesVerifier;
 
-function verifyMetaargument(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {
+export function verifyMetaargument(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {
   let metaArgumentVerified = false;
 
   const metaArgumentString = context.nodeAsString(metaArgumentNode);

package/src/verifier/nodes/statementForMetavariable.js

@@ -9,7 +9,7 @@ import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME }
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
       metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
 
-export default class StatementForMetavariableNodesVerifier extends NodesVerifier {
+class StatementForMetavariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext) {
     let nonTerminalNodeVerified = false;
 
@@ -84,16 +84,12 @@ export default class StatementForMetavariableNodesVerifier extends NodesVerifier
 
       metavariableNodeVerified = statementNodeMatches;  ///
     } else {
-      const { createSubstitutions } = this.constructor;
+      const metavariableNode = metavariableNodeA, ///
+            statementNode = statementNodeB, ///
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
+            substitution = statementForMetavariableSubstitution;  ///
 
-      if (createSubstitutions) {
-        const metavariableNode = metavariableNodeA, ///
-              statementNode = statementNodeB, ///
-              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
-              substitution = statementForMetavariableSubstitution;  ///
-
-        substitutions.push(substitution);
-      }
+      substitutions.push(substitution);
 
       metavariableNodeVerified = true;
     }
@@ -101,3 +97,7 @@ export default class StatementForMetavariableNodesVerifier extends NodesVerifier
     return metavariableNodeVerified;
   }
 }
+
+const statementForMetavariableNodesVerifier = new StatementForMetavariableNodesVerifier();
+
+export default statementForMetavariableNodesVerifier;

package/src/verifier/nodes/termForVariable.js

@@ -10,7 +10,7 @@ import { TERM_RULE_NAME } from "../../ruleNames";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
-export default class TermForVariableNodesVerifier extends NodesVerifier {
+class TermForVariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
@@ -74,47 +74,47 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
         variableVerified = verifiedAhead;  ///
       }
     } else {
-      const { createSubstitutions } = this.constructor;
+      const variableNode = variableNodeA, ///
+            localContext = localContextA, ///
+            variable = localContext.findVariableByVariableNode(variableNode);
 
-      if (createSubstitutions) {
-        const variableNode = variableNodeA, ///
-              localContext = localContextA, ///
-              variable = localContext.findVariableByVariableNode(variableNode);
+      if (variable !== null) {
+        const terms = [],
+              context = localContextB, ///
+              termNode = termNodeB, ///
+              termVerified = verifyTerm(termNode, terms, context, () => {
+                let verifiedAhead = false;
 
-        if (variable !== null) {
-          const terms = [],
-                context = localContextB, ///
-                termNode = termNodeB, ///
-                termVerified = verifyTerm(termNode, terms, context, () => {
-                  let verifiedAhead = false;
+                const firstTerm = first(terms),
+                      term = firstTerm, ///
+                      termType = term.getType(),
+                      variableType = variable.getType(),
+                      variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
 
-                  const firstTerm = first(terms),
-                        term = firstTerm, ///
-                        termType = term.getType(),
-                        variableType = variable.getType(),
-                        variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+                if (variableTypeEqualToOrSuperTypeOfTermType) {
+                  const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
+                        substitution = termForVariableSubstitution;  ///
 
-                  if (variableTypeEqualToOrSuperTypeOfTermType) {
-                    const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
-                          substitution = termForVariableSubstitution;  ///
+                  substitutions.push(substitution);
 
-                    substitutions.push(substitution);
+                  verifiedAhead = verifyAhead();
 
-                    verifiedAhead = verifyAhead();
-
-                    if (!verifiedAhead) {
-                      substitutions.pop();
-                    }
+                  if (!verifiedAhead) {
+                    substitutions.pop();
                   }
+                }
 
-                  return verifiedAhead;
-                });
+                return verifiedAhead;
+              });
 
-          variableVerified = termVerified;  ///
-        }
+        variableVerified = termVerified;  ///
       }
     }
 
     return variableVerified;
   }
 }
+
+const termForVariableNodesVerifier = new TermForVariableNodesVerifier();
+
+export default termForVariableNodesVerifier;

package/src/verify/axiom.js

@@ -4,7 +4,7 @@ import Axiom from "../axiom";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "../verify/consequent";
-import verifySupposition from "../verify/supposition";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -28,13 +28,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(axiomNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],

package/src/verify/conclusion.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Conclusion from "../conclusion";
-import verifyUnqualifiedMetastatement from "./metastatement/unqualified";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 

package/src/verify/conjecture.js

@@ -4,8 +4,8 @@ import Conjecture from "../conjecture";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyConsequent from "./consequent";
-import verifySupposition from "./supposition";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -30,13 +30,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(conjectureNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],

package/src/verify/consequent.js

@@ -21,15 +21,15 @@ export default function verifyConsequent(consequentNode, consequents, localConte
         unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
   if (unqualifiedStatementVerified) {
+    consequentVerified = true;
+  }
+
+  if (consequentVerified) {
     const statementNode = statementNodeQuery(unqualifiedStatementNode),
           consequent = Consequent.fromStatementNode(statementNode);
 
     consequents.push(consequent);
 
-    consequentVerified = true;
-  }
-
-  if (consequentVerified) {
     localContext.debug(`...verified the '${consequentString}' consequent.`, consequentNode);
   }
 

package/src/verify/derivation.js

@@ -2,7 +2,7 @@
 
 import ProofStep from "../step/proof";
 import LocalContext from "../context/local";
-import verifySupposition from "../verify/supposition";
+import verifySuppositions from "../verify/suppositions";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
@@ -53,13 +53,7 @@ function verifySubproof(subproofNode, localContext) {
 
   const suppositions = [],
         suppositionNodes = suppositionNodesQuery(subproofNode),
-        suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-          const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-          if (suppositionVerified) {
-            return true;
-          }
-        });
+        suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
   if (suppositionsVerified) {
     const subDerivationNode = subDerivationNodeQuery(subproofNode),
@@ -74,14 +68,17 @@ function verifySubproof(subproofNode, localContext) {
 }
 
 function verifyChild(childNode, localContext) {
-  let childVerified;
+  let childVerified = false;
 
   const childNodeRuleName = childNode.getRuleName();
 
   switch (childNodeRuleName) {
     case SUBPROOF_RULE_NAME: {
-      const subproofNode = childNode,  ///
-            subproofVerified = verifySubproof(subproofNode, localContext);
+      let subproofVerified;
+
+      const subproofNode = childNode;  ///
+
+      subproofVerified = verifySubproof(subproofNode, localContext);
 
       if (subproofVerified) {
         const proofStep = ProofStep.fromSubproofNode(subproofNode);
@@ -95,10 +92,23 @@ function verifyChild(childNode, localContext) {
     }
 
     case QUALIFIED_STATEMENT_RULE_NAME: {
+      let qualifiedStatementVerified;
+
       const derived = true,
             assignments = [],
-            qualifiedStatementNode = childNode,  ///
-            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext);
+            qualifiedStatementNode = childNode;  ///
+
+      qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext);
+
+      if (qualifiedStatementVerified) {
+        qualifiedStatementVerified = assignments.every((assignment) => {  ///
+          const assigned = assignment.assign(localContext);
+
+          if (assigned) {
+            return true;
+          }
+        });
+      }
 
       if (qualifiedStatementVerified) {
         const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -106,17 +116,30 @@ function verifyChild(childNode, localContext) {
 
         localContext.addProofStep(proofStep);
 
-        childVerified = qualifiedStatementVerified; ///
+        childVerified = true; ///
       }
 
       break;
     }
 
     case UNQUALIFIED_STATEMENT_RULE_NAME: {
+      let unqualifiedStatementVerified;
+
       const derived = true,
             assignments = [],
-            unqualifiedStatementNode = childNode,  ///
-            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+            unqualifiedStatementNode = childNode;  ///
+
+      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+
+      if (unqualifiedStatementVerified) {
+        unqualifiedStatementVerified = assignments.every((assignment) => {  ///
+          const assigned = assignment.assign(localContext);
+
+          if (assigned) {
+            return true;
+          }
+        });
+      }
 
       if (unqualifiedStatementVerified) {
         const statementNode = statementNodeQuery(unqualifiedStatementNode),

package/src/verify/equality.js

@@ -19,7 +19,7 @@ export default function verifyEquality(equalityNode, assignments, derived, conte
 
   const verifyEqualityFunctions = [
     verifyDerivedEquality,
-    verifyStandaloneEquality
+    verifyGivenEquality
   ];
 
   equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
@@ -59,13 +59,22 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
                   secondTerm = second(terms),
                   leftTerm = firstTerm, ///
                   rightTerm = secondTerm, ///
-                  equality = Equality.fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm);
+                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);
 
             if (equality !== null) {
-              const equalityEqual = context.isEqualityEqual(equality);
+              const equalityEqual = equality.isEqual(context);
 
               if (equalityEqual) {
+                const equalityAssignment = EqualityAssignment.fromEquality(equality),
+                      assignment = equalityAssignment; ///
+
+                assignments.push(assignment);
+
                 verifiedAhead = verifyAhead();
+
+                if (!verifiedAhead) {
+                  assignments.pop();
+                }
               }
             }
 
@@ -82,13 +91,13 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
   return derivedEqualityVerified;
 }
 
-function verifyStandaloneEquality(equalityNode, assignments, derived, context, verifyAhead) {
-  let standaloneEqualityVerified = false;
+function verifyGivenEquality(equalityNode, assignments, derived, context, verifyAhead) {
+  let givenEqualityVerified = false;
 
   if (!derived) {
     const equalityString = context.nodeAsString(equalityNode);
 
-    context.trace(`Verifying the '${equalityString}' standalone equality...`, equalityNode);
+    context.trace(`Verifying the '${equalityString}' given equality...`, equalityNode);
 
     const terms = [],
           leftTermNode = leftTermNodeQuery(equalityNode),
@@ -104,7 +113,7 @@ function verifyStandaloneEquality(equalityNode, assignments, derived, context, v
                   secondTerm = second(terms),
                   leftTerm = firstTerm, ///
                   rightTerm = secondTerm, ///
-                  equality = Equality.fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm);
+                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);
 
             if (equality !== null) {
               const equalityAssignment = EqualityAssignment.fromEquality(equality),
@@ -122,12 +131,12 @@ function verifyStandaloneEquality(equalityNode, assignments, derived, context, v
             return verifiedAhead;
           });
 
-    standaloneEqualityVerified = termsVerified; ///
+    givenEqualityVerified = termsVerified; ///
 
-    if (standaloneEqualityVerified) {
-      context.trace(`...verified the '${equalityString}' standalone equality.`, equalityNode);
+    if (givenEqualityVerified) {
+      context.trace(`...verified the '${equalityString}' given equality.`, equalityNode);
     }
   }
 
-  return standaloneEqualityVerified;
+  return givenEqualityVerified;
 }

package/src/verify/{standaloneType.js → givenType.js}

@@ -2,12 +2,12 @@
 
 import { typeNameFromTypeNode } from "../utilities/query";
 
-export default function verifyStandaloneType(typeNode, types, context, verifyAhead) {
-  let standaloneTypeVerified = false;
+export default function verifyGivenType(typeNode, types, context, verifyAhead) {
+  let givenTypeVerified = false;
 
   const typeString = context.nodeAsString(typeNode);
 
-  context.trace(`Verifying the standalone '${typeString}' type...`, typeNode);
+  context.trace(`Verifying the given '${typeString}' type...`, typeNode);
 
   const typeName = typeNameFromTypeNode(typeNode),
         type = context.findTypeByTypeName(typeName);
@@ -23,12 +23,12 @@ export default function verifyStandaloneType(typeNode, types, context, verifyAhe
       types.pop();
     }
 
-    standaloneTypeVerified = verifiedAhead; ///
+    givenTypeVerified = verifiedAhead; ///
   }
 
-  if (standaloneTypeVerified) {
-    context.debug(`...verified the standalone '${typeString}' type.`, typeNode);
+  if (givenTypeVerified) {
+    context.debug(`...verified the given '${typeString}' type.`, typeNode);
   }
 
-  return standaloneTypeVerified;
+  return givenTypeVerified;
 }

package/src/verify/lemma.js

@@ -4,8 +4,8 @@ import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyConsequent from "./consequent";
-import verifySupposition from "./supposition";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
@@ -33,13 +33,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(lemmaNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],

package/src/verify/metastatement.js

@@ -28,8 +28,8 @@ function verifyMetastatement(metastatementNode, derived, localMetaContext) {
   return metastatementVerified;
 }
 
-Object.assign(verifyMetastatement, {
-  metastatementNodeVerifier
+Object.assign(metastatementNodeVerifier, {
+  verifyMetastatement
 });
 
 export default verifyMetastatement;

package/src/verify/premises.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import verifyPremise from "../verify/premise";
+
+export default function verifyPremises(premiseNodes, premises, localMetaContext) {
+  let premisesVerified;
+
+  premisesVerified = premiseNodes.every((premiseNode) => {
+    const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
+
+    if (premiseVerified) {
+      return true;
+    }
+  });
+
+  return premisesVerified;
+}

package/src/verify/rule.js

@@ -2,7 +2,7 @@
 
 import Rule from "../rule";
 import verifyLabels from "../verify/labels";
-import verifyPremise from "../verify/premise";
+import verifyPremises from "../verify/premises";
 import verifyRuleProof from "../verify/ruleProof";
 import LocalMetaContext from "../context/localMeta";
 import verifyConclusion from "../verify/conclusion";
@@ -30,13 +30,7 @@ export default function verifyRule(ruleNode, fileContext) {
   if (labelsVerified) {
     const premises = [],
           premiseNodes = premisesNodeQuery(ruleNode),
-          premisesVerified = premiseNodes.every((premiseNode) => {
-            const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
-
-            if (premiseVerified) {
-              return true;
-            }
-          });
+          premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
 
     if (premisesVerified) {
       const conclusions = [],

package/src/verify/ruleDerivation.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import MetaproofStep from "../step/metaproof";
-import verifyPremise from "../verify/premise";
+import verifyPremises from "../verify/premises";
 import LocalMetaContext from "../context/localMeta";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
@@ -53,13 +53,11 @@ function verifyRuleSubproof(ruleSubproofNode, localMetaContext) {
 
   const premises = [],
         premiseNodes = premiseNodesQuery(ruleSubproofNode),
-        premisesVerified = premiseNodes.every((premiseNode) => {
-          const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
+        premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
 
-          if (premiseVerified) {
-            return true;
-          }
-        });
+        if (premiseVerified) {
+          return true;
+        }
 
   if (premisesVerified) {
     const ruleSubDerivationNode = ruleSubDerivationNodeQuery(ruleSubproofNode),