occam-verify-cli 0.0.700 → 0.0.704

package/src/verifier/nodes/metastatementForMetavariable.js

@@ -8,7 +8,7 @@ import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
-export default class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
+class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
@@ -68,16 +68,12 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
 
       metavariableNodeVerified = metastatementNodeMatches;  ///
     } else {
-      const { createSubstitutions } = this.constructor;
+      const metavariableNode = metavariableNodeA, ///
+            metastatementNode = metastatementNodeB, ///
+            metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
+            substitution = metastatementForMetavariableSubstitution;  ///
 
-      if (createSubstitutions) {
-        const metavariableNode = metavariableNodeA, ///
-              metastatementNode = metastatementNodeB, ///
-              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
-              substitution = metastatementForMetavariableSubstitution;  ///
-
-        substitutions.push(substitution);
-      }
+      substitutions.push(substitution);
 
       metavariableNodeVerified = true;
     }
@@ -85,3 +81,7 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
     return metavariableNodeVerified;
   }
 }
+
+const metastatementForMetavariableNodesVerifier = new MetastatementForMetavariableNodesVerifier();
+
+export default metastatementForMetavariableNodesVerifier;

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/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

@@ -68,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);
@@ -89,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),
@@ -100,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

@@ -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();
+                }
               }
             }
 
@@ -104,7 +113,7 @@ function verifyGivenEquality(equalityNode, assignments, derived, context, verify
                   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),

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/metastatement.js

@@ -9,17 +9,14 @@ function verifyMetastatement(metastatementNode, derived, localMetaContext) {
 
   localMetaContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
 
-  const verifyMetastatementFunctions = [
-    verifyStandaloneMetastatement
-  ];
+  const nonTerminalNode = metastatementNode, ///
+        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localMetaContext, () => {
+          const verifiedAhead = true;
 
-  metastatementVerified = verifyMetastatementFunctions.some((verifyMetastatementFunction) => {
-    const metastatementVerified = verifyMetastatementFunction(metastatementNode, derived, localMetaContext);
+          return verifiedAhead;
+        });
 
-    if (metastatementVerified) {
-      return true;
-    }
-  });
+  metastatementVerified = nonTerminalNodeVerified;  ///
 
   if (metastatementVerified) {
     localMetaContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
@@ -28,32 +25,8 @@ function verifyMetastatement(metastatementNode, derived, localMetaContext) {
   return metastatementVerified;
 }
 
-Object.assign(verifyMetastatement, {
-  metastatementNodeVerifier
+Object.assign(metastatementNodeVerifier, {
+  verifyMetastatement
 });
 
 export default verifyMetastatement;
-
-function verifyStandaloneMetastatement(metastatementNode, derived, localMetaContext) {
-  let standaloneMetastatementVerified;
-
-  const metastatementString = localMetaContext.nodeAsString(metastatementNode);
-
-  localMetaContext.trace(`Verifying the '${metastatementString}' standalone metastatement...`, metastatementNode);
-
-  const nonTerminalNode = metastatementNode, ///
-        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localMetaContext, () => {
-          const verifiedAhead = true;
-
-          return verifiedAhead;
-        });
-
-  standaloneMetastatementVerified = nonTerminalNodeVerified;  ///
-
-  if (standaloneMetastatementVerified) {
-    localMetaContext.debug(`...verified the '${metastatementString}' standalone metastatement.`, metastatementNode);
-  }
-
-  return standaloneMetastatementVerified;
-
-}