occam-verify-cli 0.0.910 → 0.0.911

package/src/substitution.js

@@ -2,32 +2,32 @@
 
 export default class Substitution {
   matchTermNode(termNode) {
-    const termNodeMatches = false;
+    const matchesTermNode = false;
 
-    return termNodeMatches;
+    return matchesTermNode;
   }
 
   matchVariableNode(variableNode) {
-    const variableNodeMatches = false;
+    const matchesMetavariableNode = false;
 
-    return variableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   matchStatementNode(statementNode) {
-    const statementNodeMatches = false;
+    const matchesStatementNode = false;
 
-    return statementNodeMatches;
+    return matchesStatementNode;
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = false;
+    const matchesMetavariableNode = false;
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   matchMetastatementNode(metastatementNode) {
-    const metastatementNodeMatches = false;
+    const matchesMetastatementNode = false;
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 }

package/src/supposition.js

@@ -24,9 +24,9 @@ export default class Supposition {
 
             return verifiedAhead;
           }),
-          statementNodeMatches = nonTerminalNodeVerified; ///
+          matchesStatementNode = nonTerminalNodeVerified; ///
 
-    return statementNodeMatches;
+    return matchesStatementNode;
   }
 
   toJSON(tokens) {

package/src/type.js

@@ -92,23 +92,23 @@ export default class Type {
   }
 
   matchName(name) {
-    const nameMatches = (this.name === name);
+    const matchesName = (this.name === name);
 
-    return nameMatches;
+    return matchesName;
   }
 
   matchTypeName(typeName) {
-    const typeNameMatches = (this.name === typeName);
+    const matchesTypeName = (this.name === typeName);
 
-    return typeNameMatches;
+    return matchesTypeName;
   }
 
   matchTypeNode(typeNode) {
     const typeName = typeNameFromTypeNode(typeNode),
-          typeNameMatches = this.matchTypeName(typeName),
-          typeNodeMatches = typeNameMatches;  ///
+          matchesTypeName = this.matchTypeName(typeName),
+          matchesTypeNode = matchesTypeName;  ///
 
-    return typeNodeMatches;
+    return matchesTypeNode;
   }
 
   asString(tokens, noSuperType = false) {

package/src/utilities/match.js

@@ -13,9 +13,9 @@ export function matchStatementModuloBrackets(statementNodeA, statementNodeB) {
   let statementMatchesModuloBrackets = false;
 
   if (!statementMatchesModuloBrackets) {
-    const statementNodeMatches = statementNodeA.match(statementNodeB);
+    const statementNodeAMatchesStatementNodeB = statementNodeA.match(statementNodeB);
 
-    statementMatchesModuloBrackets = statementNodeMatches;  ///
+    statementMatchesModuloBrackets = statementNodeAMatchesStatementNodeB;  ///
   }
 
   if (!statementMatchesModuloBrackets) {

package/src/variable.js

@@ -21,31 +21,31 @@ export default class Variable {
   match(variable) {
     const type = variable.getType(),
           node = variable.getNode(),
-          typeMatches = this.matchType(type),
-          nodeMatches = this.matchNode(node),
-          matches = nodeMatches && typeMatches;
+          matchesType = this.matchType(type),
+          matchesNode = this.matchNode(node),
+          matches = matchesNode && matchesType;
 
     return matches;
   }
 
   matchNode(node) {
-    const nodeMatches = this.node.match(node);
+    const matchesNode = this.node.match(node);
 
-    return nodeMatches;
+    return matchesNode;
   }
 
   matchType(type) {
-    const typeMatches = this.type.match(type);
+    const matchesType = this.type.match(type);
 
-    return typeMatches;
+    return matchesType;
   }
 
   matchNodeAndType(node, type) {
-    const nodeMatches = this.matchNode(node),
-          typeMatches = this.matchType(type),
-          nodeAndTypeMatch = nodeMatches && typeMatches;
+    const matchesNode = this.matchNode(node),
+          matchesType = this.matchType(type),
+          matchesNodeAndType = matchesNode && matchesType;
 
-    return nodeAndTypeMatch;
+    return matchesNodeAndType;
   }
 
   asString(tokens) {

package/src/verify/containedAssertion.js

@@ -6,37 +6,86 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 const variableNodeQuery = nodeQuery("/containedAssertion/term/variable!"),
       metastatementVariableNodesQuery = nodesQuery("/containedAssertion/statement//variable");
 
-export default function verifyContainedAssertion(containedAssertionNode) {
-  let containedAssertionVerified = false;
-
-  const containedAssertionNegated = isAssertionNegated(containedAssertionNode),
-        variableNode = variableNodeQuery(containedAssertionNode),
-        negated = containedAssertionNegated;  ///
-
-  if (false) {
-    ///
-  } else if (variableNode !== null) {
-    const metastatementVariableNodes = metastatementVariableNodesQuery(containedAssertionNode),
-          variableNodeMatchesMetaArgumentVariableNode = metastatementVariableNodes.some((metastatementVariableNode) => {
-            const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metastatementVariableNode);
-
-            if (variableNodeMatchesMetaArgumentVariableNode) {
-              return true;
-            }
-          });
-
-    if (!negated) {
-      if (variableNodeMatchesMetaArgumentVariableNode) {
-        containedAssertionVerified = true;
-      }
+export default function verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+  let containedAssertionVerified;
+
+  const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+
+  localContext.trace(`Verifying the '${containedAssertionString}' contained assertion...`, containedAssertionNode);
+
+  const containedAssertionFunctions = [
+    verifyDerivedContainedAssertion,
+    verifyStatedContainedAssertion
+  ];
+
+  containedAssertionVerified = containedAssertionFunctions.some((containedAssertionFunction) => {
+    const containedAssertionVerified = containedAssertionFunction(containedAssertionNode, assignments, derived, localContext);
+
+    if (containedAssertionVerified) {
+      return true;
     }
+  });
+
+  if (containedAssertionVerified) {
+    localContext.debug(`...verified the '${containedAssertionString}' contained assertion.`, containedAssertionNode);
+  }
+
+  return containedAssertionVerified;
+}
+
+function verifyDerivedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+  let derivedContainedAssertionVerified = false;
+
+  if (derived) {
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+
+    localContext.trace(`Verifying the derived '${containedAssertionString}' contained assertion...`, containedAssertionNode);
 
-    if (negated) {
-      if (!variableNodeMatchesMetaArgumentVariableNode) {
-        containedAssertionVerified = true;
+    const containedAssertionNegated = isAssertionNegated(containedAssertionNode),
+          variableNode = variableNodeQuery(containedAssertionNode),
+          negated = containedAssertionNegated;  ///
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const metastatementVariableNodes = metastatementVariableNodesQuery(containedAssertionNode),
+            variableNodeMatchesMetaArgumentVariableNode = metastatementVariableNodes.some((metastatementVariableNode) => {
+              const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metastatementVariableNode);
+
+              if (variableNodeMatchesMetaArgumentVariableNode) {
+                return true;
+              }
+            });
+
+      if (!negated) {
+        if (variableNodeMatchesMetaArgumentVariableNode) {
+          derivedContainedAssertionVerified = true;
+        }
       }
+
+      if (negated) {
+        if (!variableNodeMatchesMetaArgumentVariableNode) {
+          derivedContainedAssertionVerified = true;
+        }
+      }
+    }
+
+    if (derivedContainedAssertionVerified) {
+      localContext.debug(`...verified the derived '${containedAssertionString}' contained assertion.`, containedAssertionNode);
     }
   }
 
-  return containedAssertionVerified;
+  return derivedContainedAssertionVerified;
+}
+
+function verifyStatedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+  let derivedStatedAssertionVerified = false;
+
+  if (!derived) {
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+
+    localContext.debug(`The stated '${containedAssertionString}' contained assertion cannot be verified.`, containedAssertionNode);
+  }
+
+  return derivedStatedAssertionVerified;
 }

package/src/verify/definedAssertion.js

@@ -9,60 +9,109 @@ import { isAssertionNegated } from "../utilities/verify";
 const termNodeQuery = nodeQuery("/definedAssertion/term!"),
       variableNodeQuery = nodeQuery("/definedAssertion/term/variable!");
 
-export default function verifyDefinedAssertion(definedAssertionNode, localContext) {
-  let definedAssertionVerified = false;
+export default function verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+  let definedAssertionVerified;
 
-  const definedAssertionNegated = isAssertionNegated(definedAssertionNode),
-        variableNode = variableNodeQuery(definedAssertionNode),
-        termNode = termNodeQuery(definedAssertionNode),
-        negated = definedAssertionNegated;  ///
+  const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-  if (false) {
-    ///
-  } else if (variableNode !== null) {
-    const variable = localContext.findVariableByVariableNode(variableNode);
+  localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`, definedAssertionNode);
 
-    if (variable !== null) {
-      const variableDefined = localContext.isVariableDefined(variable);
+  const definedAssertionFunctions = [
+    verifyDerivedDefinedAssertion,
+    verifyStatedDefinedAssertion
+  ];
 
-      if (!negated) {
-        if (variableDefined) {
-          definedAssertionVerified = true;
+  definedAssertionVerified = definedAssertionFunctions.some((definedAssertionFunction) => {
+    const definedAssertionVerified = definedAssertionFunction(definedAssertionNode, assignments, derived, localContext);
+
+    if (definedAssertionVerified) {
+      return true;
+    }
+  });
+
+  if (definedAssertionVerified) {
+    localContext.debug(`...verified the '${definedAssertionString}' defined assertion.`, definedAssertionNode);
+  }
+
+  return definedAssertionVerified;
+}
+
+function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+  let derivedDefinedAssertionVerified = false;
+
+  if (derived) {
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+
+    localContext.trace(`Verifying the derived '${definedAssertionString}' defined assertion...`, definedAssertionNode);
+
+    const definedAssertionNegated = isAssertionNegated(definedAssertionNode),
+          variableNode = variableNodeQuery(definedAssertionNode),
+          termNode = termNodeQuery(definedAssertionNode),
+          negated = definedAssertionNegated;  ///
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const variable = localContext.findVariableByVariableNode(variableNode);
+
+      if (variable !== null) {
+        const variableDefined = localContext.isVariableDefined(variable);
+
+        if (!negated) {
+          if (variableDefined) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!variableDefined) {
-          definedAssertionVerified = true;
+        if (negated) {
+          if (!variableDefined) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
       }
-    }
-  } else if (termNode !== null) {
-    const terms = [],
-          termVerified = verifyTerm(termNode, terms, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
-
-    if (termVerified) {
-      const firstTerm = first(terms),
-            term = firstTerm, ///
-            termGrounded = localContext.isTermGrounded(term);
-
-      if (!negated) {
-        if (termGrounded) {
-          definedAssertionVerified = true;
+    } else if (termNode !== null) {
+      const terms = [],
+            termVerified = verifyTerm(termNode, terms, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      if (termVerified) {
+        const firstTerm = first(terms),
+              term = firstTerm, ///
+              termGrounded = localContext.isTermGrounded(term);
+
+        if (!negated) {
+          if (termGrounded) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!termGrounded) {
-          definedAssertionVerified = true;
+        if (negated) {
+          if (!termGrounded) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
       }
     }
+
+    if (derivedDefinedAssertionVerified) {
+      localContext.debug(`...verified the derived '${definedAssertionString}' defined assertion.`, definedAssertionNode);
+    }
   }
 
-  return definedAssertionVerified;
+  return derivedDefinedAssertionVerified;
+}
+
+function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+  let derivedStatedAssertionVerified = false;
+
+  if (!derived) {
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+
+    localContext.debug(`The stated '${definedAssertionString}' defined assertion cannot be verified.`, definedAssertionNode);
+  }
+
+  return derivedStatedAssertionVerified;
 }

package/src/verify/frame.js

@@ -10,7 +10,7 @@ import { nodesQuery } from "../utilities/query";
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable");
 
-export default function verifyFrame(frameNode, frames, derived, localMetaContext) {
+export default function verifyFrame(frameNode, frames, assignments, derived, localMetaContext) {
   let frameVerified;
 
   const frameString = localMetaContext.nodeAsString(frameNode);

package/src/verify/frameAssertion.js

@@ -55,7 +55,7 @@ function verifyDerivedFrameAssertion(frameAssertionNode, assignments, derived, l
       if (frameAssertion !== null) {
         const frames = [],
               frameNode = frameNodeQuery(frameAssertionNode),
-              frameVerified = verifyFrame(frameNode, frames, derived, localMetaContext);
+              frameVerified = verifyFrame(frameNode, frames, assignments, derived, localMetaContext);
 
         if (frameVerified) {
           const firstFrame = first(frames),
@@ -114,7 +114,7 @@ function verifyStatedFrameAssertion(frameAssertionNode, assignments, derived, lo
     if (metavariableVerified) {
       const frames = [],
             frameNode = frameNodeQuery(frameAssertionNode),
-            frameVerified = verifyFrame(frameNode, frames, derived, localMetaContext);
+            frameVerified = verifyFrame(frameNode, frames, assignments, derived, localMetaContext);
 
       if (frameVerified) {
         const firstFrame = first(frames),

package/src/verify/metaproofStep.js

@@ -42,9 +42,50 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
       metaproofStepVerified = true;
     }
   } else if (qualifiedStatementNode !== null) {
-    debugger
+    let qualifiedStatementVerified;
+
+    const assignments = [],
+          localContext = localMetaContext;  ///
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
+
+    if (qualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      qualifiedStatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      metaproofStepVerified = true;
+    }
   } else if (unqualifiedStatementNode !== null) {
-    debugger
+    let qualifiedStatementVerified;
+
+    const assignments = [],
+          localContext = localMetaContext,  ///
+          substitutions = null;
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext);
+
+    if (qualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      qualifiedStatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      metaproofStepVerified = qualifiedStatementVerified; ///
+    }
   } else if (qualifiedMetastatementNode !== null) {
     let qualifiedMetastatementVerified;
 

package/src/verify/metastatement/unqualified.js

@@ -15,9 +15,9 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
   localMetaContext.trace(`Verifying the '${unqualifiedMetastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
   if (derived) {
-    const metastatementMatches = localMetaContext.matchMetastatement(metastatementNode);
+    const matchesMetastatementNode = localMetaContext.matchMetastatementNode(metastatementNode);
 
-    unqualifiedMetastatementVerified = metastatementMatches;  ///
+    unqualifiedMetastatementVerified = matchesMetastatementNode;  ///
   }
 
   if (!unqualifiedMetastatementVerified) {

package/src/verify/metastatement.js

@@ -63,7 +63,7 @@ function verifyMetastatementAsFrameAssertion(metastatementNode, assignments, der
 }
 
 function verifyMetastatementAsIs(metastatementNode, assignments, derived, localMetaContext) {
-  let metastatementVerifiedAsIs = false;
+  let metastatementVerifiedAsIs;
 
   const frameAssertionNode = frameAssertionNodeQuery(metastatementNode);
 
@@ -72,6 +72,47 @@ function verifyMetastatementAsIs(metastatementNode, assignments, derived, localM
 
     localMetaContext.trace(`Verifying the '${metastatementString}' metastatement as is...`, metastatementNode);
 
+    const verifyMetastatementAsIsFunctions = [
+      verifyDerivedMetastatementAsIs,
+      verifyStatedMetastatementAsIs
+    ];
+
+    metastatementVerifiedAsIs = verifyMetastatementAsIsFunctions.some((verifyMetastatementAsIsFunction) => {
+      const metastatementVerifiedAsIs = verifyMetastatementAsIsFunction(metastatementNode, assignments, derived, localMetaContext);
+
+      if (metastatementVerifiedAsIs) {
+        return true;
+      }
+    });
+
+    if (metastatementVerifiedAsIs) {
+      localMetaContext.debug(`...verified the '${metastatementString}' metastatement as is.`, metastatementNode);
+    }
+  }
+
+  return metastatementVerifiedAsIs;
+}
+
+function verifyDerivedMetastatementAsIs(metastatementNode, assignments, derived, localMetaContext) {
+  let derivedMetastatementVerifiedAsIs = false;
+
+  if (derived) {
+    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+
+    localMetaContext.debug(`Cannot verify the derived '${metastatementString}' metastatement as is.`, metastatementNode);
+  }
+
+  return derivedMetastatementVerifiedAsIs;
+}
+
+function verifyStatedMetastatementAsIs(metastatementNode, assignments, derived, localMetaContext) {
+  let statedMetastatementVerifiedAsIs = false;
+
+  if (!derived) {
+    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+
+    localMetaContext.trace(`Verifying the stated '${metastatementString}' metastatement as is...`, metastatementNode);
+
     const nonTerminalNode = metastatementNode, ///
           nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localMetaContext, () => {
             const verifiedAhead = true;
@@ -79,12 +120,12 @@ function verifyMetastatementAsIs(metastatementNode, assignments, derived, localM
             return verifiedAhead;
           });
 
-    metastatementVerifiedAsIs = nonTerminalNodeVerified;  ///
+    statedMetastatementVerifiedAsIs = nonTerminalNodeVerified;  ///
 
-    if (metastatementVerifiedAsIs) {
-      localMetaContext.debug(`...verified the '${metastatementString}' metastatement as is.`, metastatementNode);
+    if (statedMetastatementVerifiedAsIs) {
+      localMetaContext.debug(`...verified the stated '${metastatementString}' metastatement as is.`, metastatementNode);
     }
   }
 
-  return metastatementVerifiedAsIs;
+  return statedMetastatementVerifiedAsIs;
 }

package/src/verify/ruleProofStep.js

@@ -64,7 +64,28 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
       ruleProofStepVerified = true;
     }
   } else if (unqualifiedStatementNode !== null) {
-    debugger
+    let qualifiedStatementVerified;
+
+    const assignments = [],
+          localContext = localMetaContext,  ///
+          substitutions = null;
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext);
+
+    if (qualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      qualifiedStatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      ruleProofStepVerified = qualifiedStatementVerified; ///
+    }
   } else if (qualifiedMetastatementNode !== null) {
     let qualifiedMetastatementVerified;
 

package/src/verify/statement/unqualified.js

@@ -15,9 +15,9 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
 
   if (derived) {
-    const statementMatches = localContext.matchStatement(statementNode);
+    const matchesStatementNode = localContext.matchStatementNode(statementNode);
 
-    unqualifiedStatementVerified = statementMatches;  ///
+    unqualifiedStatementVerified = matchesStatementNode;  ///
   }
 
   if (!unqualifiedStatementVerified) {

package/src/verify/statement.js

@@ -137,11 +137,7 @@ function verifyStatementAsDefinedAssertion(statementNode, assignments, derived,
 
     localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, definedAssertionNode);
 
-    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, localContext, () => {
-      const verifiedAhead = true;
-
-      return verifiedAhead;
-    });
+    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext);
 
     statementVerifiedAsDefinedAssertion = definedAssertionVerified; ///
 
@@ -163,7 +159,7 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, derived
 
     localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, containedAssertionNode);
 
-    const containedVerified = verifyContainedAssertion(containedAssertionNode);
+    const containedVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext);
 
     if (containedVerified) {
       statementNode = statementNodeQuery(containedAssertionNode); ///