occam-verify-cli 0.0.1089 → 0.0.1091

package/src/reference.js

@@ -29,40 +29,40 @@ export default class Reference {
     return metavariableNode;
   }
 
-  verify(localContext) {
+  verify(context) {
     let verified = false;
 
     const referenceString = this.getString(); ///
 
-    localContext.trace(`Verifying the '${referenceString}' reference...`);
+    context.trace(`Verifying the '${referenceString}' reference...`);
 
     if (!verified) {
       const metaType = referenceMetaType, ///
-            metavariableVerifiedGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, localContext);
+            metavariableVerifiedGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, context);
 
       verified = metavariableVerifiedGivenMetaType; ///
     }
 
     if (!verified) {
       const reference = this, ///
-            metaLemmaPresent = localContext.isMetaLemmaPresentByReference(reference),
-            metatheoremPresent = localContext.isMetatheoremPresentByReference(reference);
+            metaLemmaPresent = context.isMetaLemmaPresentByReference(reference),
+            metatheoremPresent = context.isMetatheoremPresentByReference(reference);
 
       verified = (metaLemmaPresent || metatheoremPresent);
     }
 
     if (!verified) {
       const reference = this, ///
-            axiomPresent = localContext.isAxiomPresentByReference(reference),
-            lemmaPresent = localContext.isLemmaPresentByReference(reference),
-            theoremPresent = localContext.isTheoremPresentByReference(reference),
-            conjecturePresent = localContext.isConjecturePresentByReference(reference);
+            axiomPresent = context.isAxiomPresentByReference(reference),
+            lemmaPresent = context.isLemmaPresentByReference(reference),
+            theoremPresent = context.isTheoremPresentByReference(reference),
+            conjecturePresent = context.isConjecturePresentByReference(reference);
 
       verified = (axiomPresent || lemmaPresent || theoremPresent || conjecturePresent);
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${referenceString}' reference.`);
+      context.debug(`...verified the '${referenceString}' reference.`);
     }
 
     return verified;
@@ -91,7 +91,8 @@ export default class Reference {
     const { Metavariable } = shim,
           metavariableNode = metavariableNodeQuery(referenceNode),
           localContext = LocalContext.fromFileContext(fileContext),
-          metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+          context = localContext, ///
+          metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
           reference = new Reference(metavariable);
 
     return reference;

package/src/rule.js

@@ -67,15 +67,15 @@ class Rule {
     return metavariableNodeMatches;
   }
 
-  unifyStatement(statement, localContext) {
+  unifyStatement(statement, context) {
     let statementUnified;
 
     const { Substitutions } = shim,
           substitutions = Substitutions.fromNothing(),
-          conclusionUnified = this.unifyConclusion(statement, substitutions, localContext);
+          conclusionUnified = this.unifyConclusion(statement, substitutions, context);
 
     if (conclusionUnified) {
-      const premisesUnified = this.unifyPremises(substitutions, localContext);
+      const premisesUnified = this.unifyPremises(substitutions, context);
 
       if (premisesUnified) {
         const substitutionsResolved = substitutions.areResolved();
@@ -87,31 +87,31 @@ class Rule {
     return statementUnified;
   }
 
-  unifyConclusion(statement, substitutions, localContext) {
+  unifyConclusion(statement, substitutions, context) {
     let conclusionUnified;
 
     const conclusionString = this.conclusion.getString();
 
-    localContext.trace(`Unifying the '${conclusionString}' conclusion...`);
+    context.trace(`Unifying the '${conclusionString}' conclusion...`);
 
-    const statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
+    const statementUnified = this.conclusion.unifyStatement(statement, substitutions, context);  ///
 
     conclusionUnified = statementUnified; ///
 
     if (conclusionUnified) {
-      localContext.debug(`...unified the '${conclusionString}' conclusion`);
+      context.debug(`...unified the '${conclusionString}' conclusion`);
     }
 
     return conclusionUnified;
   }
 
-  unifyPremises(substitutions, localContext) {
-    let proofSteps = localContext.getProofSteps();
+  unifyPremises(substitutions, context) {
+    let proofSteps = context.getProofSteps();
 
     proofSteps = reverse(proofSteps); ///
 
     const premisesUnified = backwardsEvery(this.premises, (premise) => {
-      const premiseUnified = this.unifyPremise(premise, proofSteps, substitutions, localContext);
+      const premiseUnified = this.unifyPremise(premise, proofSteps, substitutions, context);
 
       if (premiseUnified) {
         return true;
@@ -121,25 +121,25 @@ class Rule {
     return premisesUnified;
   }
 
-  unifyPremise(premise, proofSteps, substitutions, localContext) {
+  unifyPremise(premise, proofSteps, substitutions, context) {
     let premiseUnified  =false;
 
     const premiseString = premise.getString();
 
-    localContext.trace(`Unifying the '${premiseString}' premise...`);
+    context.trace(`Unifying the '${premiseString}' premise...`);
 
-    const premiseResolvedIndependently = premise.resolveIndependently(substitutions, localContext);
+    const premiseResolvedIndependently = premise.resolveIndependently(substitutions, context);
 
     if (premiseResolvedIndependently) {
       premiseUnified = true;
     } else {
       const proofStep = extract(proofSteps, (proofStep) => {
-        const proofStepUnified = premise.unifyProofStep(proofStep, substitutions, localContext);
+        const proofStepUnified = premise.unifyProofStep(proofStep, substitutions, context);
 
         if (proofStepUnified) {
           return true;
         }
-      });
+      }) || null;
 
       if (proofStep !== null) {
         premiseUnified = true;
@@ -147,7 +147,7 @@ class Rule {
     }
 
     if (premiseUnified) {
-      localContext.debug(`...unified the '${premiseString}' premise.`);
+      context.debug(`...unified the '${premiseString}' premise.`);
     }
 
     return premiseUnified;
@@ -169,9 +169,9 @@ class Rule {
     });
 
     if (labelsVerifiedWhenDeclared) {
-      const localContext = LocalContext.fromFileContext(this.fileContext),
+      const context = LocalContext.fromFileContext(this.fileContext),
             premisesVerified = this.premises.every((premise) => {
-              const premiseVerified = premise.verify(localContext);
+              const premiseVerified = premise.verify(context);
 
               if (premiseVerified) {
                 return true;
@@ -179,7 +179,7 @@ class Rule {
             });
 
       if (premisesVerified) {
-        const conclusionVerified = this.conclusion.verify(localContext);
+        const conclusionVerified = this.conclusion.verify(context);
 
         if (conclusionVerified) {
           let proofVerified = true; ///
@@ -188,7 +188,7 @@ class Rule {
             const { Substitutions } = shim,
                   substitutions = Substitutions.fromNothing();
 
-            proofVerified = this.proof.verify(substitutions, this.conclusion, localContext);
+            proofVerified = this.proof.verify(substitutions, this.conclusion, context);
           }
 
           if (proofVerified) {

package/src/statement/qualified.js

@@ -33,69 +33,69 @@ class QualifiedStatement {
 
   getMetavariableNode() { return this.reference.getMetavariableNode(); }
 
-  unify(substitutions, localContext) {
+  unify(substitutions, context) {
     let unified;
 
     const qualifiedStatement = this,  ///
           qualifiedStatementString = this.string; ///
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`);
+    context.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`);
 
     unified = unifyMixins.some((unifyMixin) => {
-      const unified = unifyMixin(qualifiedStatement, substitutions, localContext);
+      const unified = unifyMixin(qualifiedStatement, substitutions, context);
 
       return unified;
     });
 
     if (unified) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement.`);
+      context.debug(`...unified the '${qualifiedStatementString}' qualified statement.`);
     }
 
     return unified;
   }
 
-  unifyStatement(statement, substitutions, localContextA, localContextB) {
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnified;
 
     const statementString = statement.getString(),
           unqualifiedStatementString = this.getString();  ///
 
-    localContextB.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' qualified statement...`);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' qualified statement...`);
 
-    statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
+    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
-      localContextB.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' qualified statement.`);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' qualified statement.`);
     }
 
     return statementUnified;
   }
 
-  verify(substitutions, assignments, stated, localContext) {
+  verify(substitutions, assignments, stated, context) {
     let verified;
 
     const qualifiedStatementString = this.string; ///
 
     if (this.statement !== null) {
-      localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`);
+      context.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`);
 
-      const statementVerified = this.statement.verify(assignments, stated, localContext);
+      const statementVerified = this.statement.verify(assignments, stated, context);
 
       if (statementVerified) {
-        const unified = this.unify(substitutions, localContext);
+        const unified = this.unify(substitutions, context);
 
         if (unified) {
-          const assignmentsAssigned = assignAssignments(assignments, localContext);
+          const assignmentsAssigned = assignAssignments(assignments, context);
 
           verified = assignmentsAssigned; ///
         }
       }
 
       if (verified) {
-        localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`);
+        context.debug(`...verified the '${qualifiedStatementString}' qualified statement.`);
       }
     } else {
-      localContext.debug(`Cannot verify the '${qualifiedStatementString}' qualified statement because it is nonsense.`);
+      context.debug(`Cannot verify the '${qualifiedStatementString}' qualified statement because it is nonsense.`);
     }
 
     return verified;
@@ -111,8 +111,9 @@ class QualifiedStatement {
             statementNode = statementNodeQuery(qualifiedStatementNode),
             referenceNode = referenceNodeQuery(qualifiedStatementNode),
             localContext = LocalContext.fromFileContext(fileContext),
-            statement = Statement.fromStatementNode(statementNode, localContext),
-            reference = Reference.fromReferenceNode(referenceNode, fileContext),
+            context = localContext, ///
+            statement = Statement.fromStatementNode(statementNode, context),
+            reference = Reference.fromReferenceNode(referenceNode, context),
             node = qualifiedStatementNode;  ///
 
       string = fileContext.nodeAsString(node);

package/src/statement/unqualified.js

@@ -27,20 +27,20 @@ class UnqualifiedStatement {
     return this.statement;
   }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified;
 
     const unqualifiedStatementString = this.getString(); ///
 
     if (this.statement !== null) {
-      localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`);
+      context.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`);
 
-      const statementVerified = this.statement.verify(assignments, stated, localContext);
+      const statementVerified = this.statement.verify(assignments, stated, context);
 
       if (statementVerified) {
         verified = true;
       } else {
-        const statementUnifiedWithProofSteps = this.unifyStatementWithProofSteps(this.statement, assignments, stated, localContext);
+        const statementUnifiedWithProofSteps = this.unifyStatementWithProofSteps(this.statement, assignments, stated, context);
 
         if (statementUnifiedWithProofSteps) {
           verified = true;
@@ -48,59 +48,59 @@ class UnqualifiedStatement {
       }
 
       if (verified) {
-        localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
+        context.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
       }
     } else {
-      localContext.debug(`Cannot verify the '${unqualifiedStatementString}' unqualified statement because it is nonsense.`);
+      context.debug(`Cannot verify the '${unqualifiedStatementString}' unqualified statement because it is nonsense.`);
     }
 
     return verified;
   }
 
-  unifyStatement(statement, substitutions, localContextA, localContextB) {
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnified;
 
     const statementString = statement.getString(),
           unqualifiedStatementString = this.getString();  ///
 
-    localContextB.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement...`);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement...`);
 
-    statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
+    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
-      localContextB.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement.`);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement.`);
     }
 
     return statementUnified;
   }
 
-  resolveIndependently(substitutions, localContextA, localContextB) {
+  resolveIndependently(substitutions, generalContext, specificContext) {
     let resolveIndependently;
 
     const unqualifiedStatementString = this.getString();  ///
 
-    localContextB.trace(`Resolving the '${unqualifiedStatementString}' unqualified statement independently...`);
+    specificContext.trace(`Resolving the '${unqualifiedStatementString}' unqualified statement independently...`);
 
-    const statementResolvedIndependently = this.statement.resolveIndependently(substitutions, localContextA, localContextB);
+    const statementResolvedIndependently = this.statement.resolveIndependently(substitutions, generalContext, specificContext);
 
     resolveIndependently = statementResolvedIndependently;  ///
 
     if (resolveIndependently) {
-      localContextB.debug(`...resolved the '${unqualifiedStatementString}' unqualified statement independently.`);
+      specificContext.debug(`...resolved the '${unqualifiedStatementString}' unqualified statement independently.`);
     }
 
     return resolveIndependently;
   }
 
-  unifyStatementWithProofSteps(statement, assignments, stated, localContext) {
+  unifyStatementWithProofSteps(statement, assignments, stated, context) {
     let statementUnifiedWithProofSteps;
 
-    let proofSteps = localContext.getProofSteps();
+    let proofSteps = context.getProofSteps();
 
     proofSteps = reverse(proofSteps); ///
 
     statementUnifiedWithProofSteps = proofSteps.some((proofStep) => {
-      const statementUnified = proofStep.unifyStatement(statement, localContext);
+      const statementUnified = proofStep.unifyStatement(statement, context);
 
       if (statementUnified) {
         return true;
@@ -139,7 +139,8 @@ class UnqualifiedStatement {
       const { Statement } = shim,
             statementNode = statementNodeQuery(unqualifiedStatementNode),
             localContext = LocalContext.fromFileContext(fileContext),
-            statement = Statement.fromStatementNode(statementNode, localContext),
+            context = localContext, ///
+            statement = Statement.fromStatementNode(statementNode, context),
             node = unqualifiedStatementNode;  ///
 
       string = fileContext.nodeAsString(node);