occam-verify-cli 0.0.972 → 0.0.974

package/src/type.js

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

package/src/unify/complexSubstitutionStatementWithSimpleSubstitutionStatement.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import metaLevelUnifier from "../unifier/metaLevel";
+
+export default function unifyComplexSubstitutionStatementWithSimpleSubstitutionStatement(complexSubstitutionStatementNode, simpleSubstitutionStatementNode, substitutions, localContextA, localContextB) {
+  let complexSubstitutionStatementWithSimpleSubstitutionStatement;
+
+  const nodeA = complexSubstitutionStatementNode,  ///
+        nodeB = simpleSubstitutionStatementNode;  ///
+
+  localContextA = localContextB;  ///
+
+  const unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+  complexSubstitutionStatementWithSimpleSubstitutionStatement = unified;  ///
+
+  return complexSubstitutionStatementWithSimpleSubstitutionStatement;
+}

package/src/unify/{statement/qualified.js → qualifiedStatement.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-import { nodeQuery } from "../../utilities/query";
+import { nodeQuery } from "../utilities/query";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");

package/src/unify/statementWithCombinator.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
+
+export default function unifyStatementWithCombinator(statementNode, combinator, assignments, stated, localContext) {
+  let statementUnifiedWithCombinator;
+
+  const statementString = localContext.nodeAsString(statementNode),
+        combinatorString = combinator.getString();
+
+  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`, statementNode);
+
+  const combinatorStatementNode = combinator.getStatementNode();
+
+  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
+
+  if (statementUnifiedWithCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
+  }
+
+  return statementUnifiedWithCombinator;
+}

package/src/unify/statementWithCombinators.js

@@ -1,12 +1,14 @@
 "use strict";
 
-import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
+import unifyStatementWithCombinator from "../unify/statementWithCombinator";
 
 export default function unifyStatementWithCombinators(statementNode, assignments, stated, localContext) {
   let statementUnifiedWithCombinators;
 
   const combinators = localContext.getCombinators();
 
+  assignments = null; ///
+
   statementUnifiedWithCombinators = combinators.some((combinator) => {
     const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, assignments, stated, localContext);
 
@@ -17,22 +19,3 @@ export default function unifyStatementWithCombinators(statementNode, assignments
 
   return statementUnifiedWithCombinators;
 }
-
-function unifyStatementWithCombinator(statementNode, combinator, assignments, stated, localContext) {
-  let statementUnifiedWithCombinator;
-
-  const statementString = localContext.nodeAsString(statementNode),
-        combinatorString = combinator.getString();
-
-  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`, statementNode);
-
-  const combinatorStatementNode = combinator.getStatementNode();
-
-  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
-
-  if (statementUnifiedWithCombinator) {
-    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
-  }
-
-  return statementUnifiedWithCombinator;
-}

package/src/unify/termWithBracketedConstructor.js

@@ -2,9 +2,9 @@
 
 import shim from "../shim";
 import bracketedConstructor from "../constructor/bracketed";
+import unifyTermWithConstructor from "../unify/termWithConstructor";
 
 import { nodeQuery } from "../utilities/query";
-import { unifyTermWithConstructor } from "../unify/termWithConstructors";
 
 const termNodeQuery = nodeQuery("/term/argument/term");
 

package/src/unify/termWithConstructor.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import Term from "../term";
+import termWithConstructorUnifier from "../unifier/termWithConstructor";
+
+export default function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
+  let termUnifiedWithConstructor = false;
+
+  const termString = localContext.nodeAsString(termNode),
+        constructorString = constructor.getString(),
+        constructorTermNode = constructor.getTermNode();
+
+  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);
+
+  const termNodeA = termNode,  ///
+        constructorTermNodeB = constructorTermNode,  ///
+        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
+
+  if (unified) {
+    let verifiedAhead;
+
+    const type = constructor.getType(),
+          term = Term.fromTermNodeAndType(termNode, type);
+
+    terms.push(term);
+
+    verifiedAhead = verifyAhead();
+
+    terms.pop();
+
+    termUnifiedWithConstructor = verifiedAhead;  ///
+  }
+
+  if (termUnifiedWithConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);
+  }
+
+  return termUnifiedWithConstructor;
+}

package/src/unify/termWithConstructors.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import Term from "../term";
-import termWithConstructorUnifier from "../unifier/termWithConstructor";
+import unifyTermWithConstructor from "../unify/termWithConstructor";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -26,38 +25,3 @@ export default function unifyTermWithConstructors(termNode, terms, localContext,
 
   return termUnifiedWithConstructors;
 }
-
-export function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
-  let termUnifiedWithConstructor = false;
-
-  const termString = localContext.nodeAsString(termNode),
-        constructorString = constructor.getString(),
-        constructorTermNode = constructor.getTermNode();
-
-  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);
-
-  const termNodeA = termNode,  ///
-        constructorTermNodeB = constructorTermNode,  ///
-        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
-
-  if (unified) {
-    let verifiedAhead;
-
-    const type = constructor.getType(),
-          term = Term.fromTermNodeAndType(termNode, type);
-
-    terms.push(term);
-
-    verifiedAhead = verifyAhead();
-
-    terms.pop();
-
-    termUnifiedWithConstructor = verifiedAhead;  ///
-  }
-
-  if (termUnifiedWithConstructor) {
-    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);
-  }
-
-  return termUnifiedWithConstructor;
-}

package/src/unify/{statement/unqualified.js → unqualifiedStatement.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-import { nodeQuery } from "../../utilities/query";
+import { nodeQuery } from "../utilities/query";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 

package/src/verifier/statementAsCombinator.js

@@ -29,8 +29,8 @@ class StatementAsCombinatorVerifier extends Verifier {
       nodeQuery: statementNodeQuery,
       verify: (statementNode, fileContext) => {
         const { verifyStatement } = shim,
-              stated = false, ///
-              assignments = [],
+              stated = false,
+              assignments = null,
               localContext = LocalContext.fromFileContext(fileContext),
               statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 

package/src/verify/assertion/contained.js

@@ -23,7 +23,7 @@ export default function verifyContainedAssertion(containedAssertionNode, assignm
 
   localContext.trace(`Verifying the '${containedAssertionString}' contained assertion...`, containedAssertionNode);
 
-  assignments = []; ///
+  assignments = null; ///
 
   stated = true;  ///
 

package/src/verify/assertion/defined.js

@@ -18,14 +18,19 @@ const verifyDefinedAssertionFunctions = [
 export default function verifyDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
   let definedAssertionVerified;
 
-  const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+  const definedAssertionString = localContext.nodeAsString(definedAssertionNode),
+        savedStated = stated; ///;
 
   localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`, definedAssertionNode);
 
-  assignments = []; ///
+  assignments = null; ///
+
+  stated = true;  ///
 
   const verified = metaLevelVerifier.verify(definedAssertionNode, assignments, stated, localContext);
 
+  stated = savedStated; ///
+
   if (verified) {
     definedAssertionVerified = verifyDefinedAssertionFunctions.some((verifyDefinedAssertionFunction) => {
       const definedAssertionVerified = verifyDefinedAssertionFunction(definedAssertionNode, assignments, stated, localContext);

package/src/verify/assertion/type.js

@@ -112,11 +112,13 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, stated, local
                 const variableNode = variableNodeQuery(termNode);
 
                 if (variableNode !== null) {
-                  const variable = Variable.fromVariableNodeAndType(variableNode, type),
-                        variableAssignment = VariableAssignment.fromVariable(variable),
-                        assignment = variableAssignment;  ///
+                  if (assignments !== null) {
+                    const variable = Variable.fromVariableNodeAndType(variableNode, type),
+                          variableAssignment = VariableAssignment.fromVariable(variable),
+                          assignment = variableAssignment;  ///
 
-                  assignments.push(assignment);
+                    assignments.push(assignment);
+                  }
                 }
 
                 verifiedAhead = true;

package/src/verify/conclusion.js

@@ -19,7 +19,7 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
 
   if (unqualifiedStatementNode !== null) {
     const stated = true,
-          assignments = [],
+          assignments = null,
           statementNode = statementNodeQuery(unqualifiedStatementNode),
           statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 

package/src/verify/consequent.js

@@ -19,7 +19,7 @@ export default function verifyConsequent(consequentNode, consequents, localConte
 
   if (unqualifiedStatementNode !== null) {
     const stated = true,
-          assignments = [],
+          assignments = null,
           statementNode = statementNodeQuery(unqualifiedStatementNode),
           statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 

package/src/verify/declaration.js

@@ -44,7 +44,7 @@ function verifyDerivedDeclaration(declarationNode, declarations, stated, localCo
 
     localContext.trace(`Verifying the '${declarationString}' derived declaration...`, declarationNode);
 
-    debugger
+    derivedDeclarationVerified = false; ///
 
     if (derivedDeclarationVerified) {
       localContext.debug(`...verified the '${declarationString}' derived declaration.`, declarationNode);
@@ -68,7 +68,7 @@ function verifyStatedDeclaration(declarationNode, declarations, stated, localCon
     if (metavariableVerified) {
       const { verifyStatement } = shim,
             stated = true,
-            assignments = [],
+            assignments = null,
             statementNode = statementNodeQuery(declarationNode),
             statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 

package/src/verify/equality.js

@@ -41,7 +41,7 @@ function verifyDerivedEquality(equalityNode, assignments, stated, localContext)
   if (!stated) {
     const equalityString = localContext.nodeAsString(equalityNode);
 
-    localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);
+    localContext.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);
 
     const terms = [],
           termNodes = termNodesQuery(equalityNode),
@@ -54,10 +54,12 @@ function verifyDerivedEquality(equalityNode, assignments, stated, localContext)
               const equalityEqual = equality.isEqual(localContext);
 
               if (equalityEqual) {
-                const equalityAssignment = EqualityAssignment.fromEquality(equality),
-                      assignment = equalityAssignment; ///
+                if (assignments !== null) {
+                  const equalityAssignment = EqualityAssignment.fromEquality(equality),
+                        assignment = equalityAssignment; ///
 
-                assignments.push(assignment);
+                  assignments.push(assignment);
+                }
 
                 verifiedAhead = true;
               }
@@ -69,7 +71,7 @@ function verifyDerivedEquality(equalityNode, assignments, stated, localContext)
     derivedEqualityVerified = termsVerified; ///
 
     if (derivedEqualityVerified) {
-      localContext.debug(`...verified the '${equalityString}' stated equality.`, equalityNode);
+      localContext.debug(`...verified the '${equalityString}' derived equality.`, equalityNode);
     }
   }
 
@@ -92,10 +94,12 @@ function verifyStatedEquality(equalityNode, assignments, stated, localContext) {
             const equality = Equality.fromTermsAndEqualityNode(terms, equalityNode);
 
             if (equality !== null) {
-              const equalityAssignment = EqualityAssignment.fromEquality(equality),
-                    assignment = equalityAssignment; ///
+              if (assignments !== null) {
+                const equalityAssignment = EqualityAssignment.fromEquality(equality),
+                      assignment = equalityAssignment; ///
 
-              assignments.push(assignment);
+                assignments.push(assignment);
+              }
 
               verifiedAhead = true;
             }

package/src/verify/frame.js

@@ -45,7 +45,7 @@ function verifyDerivedFrame(frameNode, frames, stated, localContext) {
 
     localContext.trace(`Verifying the '${frameString}' derived frame...`, frameNode);
 
-    debugger
+    derivedFrameVerified = false; ///
 
     if (derivedFrameVerified) {
       localContext.debug(`...verified the '${frameString}' derived frame.`, frameNode);

package/src/verify/judgement.js

@@ -46,49 +46,52 @@ function verifyDerivedJudgement(judgementNode, assignments, stated, localContext
 
     localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
 
-    const metavariableNode = metavariableNodeQuery(judgementNode),
-          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+    const metavariableNode = metavariableNodeQuery(judgementNode);
 
-    if (metavariableVerified) {
-      const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
+    if (metavariableNode !== null) {
+      const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
-      if (judgement !== null) {
-        const frames = [],
-              frameNode = frameNodeQuery(judgementNode),
-              frameVerified = verifyFrame(frameNode, frames, assignments, stated, localContext);
+      if (metavariableVerified) {
+        const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
 
-        if (frameVerified) {
-          const firstFrame = first(frames),
-                frame = firstFrame, ///
-                frameSingular = frame.isSingular();
-
-          if (frameSingular) {
-            const declaration = frame.getDeclaration(),
-                  metavariableNode = declaration.getMetavariableNode(),
-                  metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
-                  metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
-                  metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
-
-            if (metaLemmaMetatheorem !== null) {
-              const metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
-                    metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
-
-              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithDeclaration && metaLemmaMetatheoremUnifiedWithJudgement);
+        if (judgement !== null) {
+          const frames = [],
+                frameNode = frameNodeQuery(judgementNode),
+                frameVerified = verifyFrame(frameNode, frames, stated, localContext);
+
+          if (frameVerified) {
+            const firstFrame = first(frames),
+                  frame = firstFrame, ///
+                  frameSingular = frame.isSingular();
+
+            if (frameSingular) {
+              const declaration = frame.getDeclaration(),
+                    metavariableNode = declaration.getMetavariableNode(),
+                    metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
+                    metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
+                    metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+
+              if (metaLemmaMetatheorem !== null) {
+                const metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
+                      metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
+
+                derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithDeclaration && metaLemmaMetatheoremUnifiedWithJudgement);
+              } else {
+                const metavariableString = localContext.nodeAsString(metavariableNode);
+
+                localContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, judgementNode);
+              }
             } else {
-              const metavariableString = localContext.nodeAsString(metavariableNode);
+              const frameString = localContext.nodeAsString(frameNode);
 
-              localContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, judgementNode);
+              localContext.debug(`The '${frameString}' is not singular.`, judgementNode);
             }
-          } else {
-            const frameString = localContext.nodeAsString(frameNode);
-
-            localContext.debug(`The '${frameString}' is not singular.`, judgementNode);
           }
-        }
-      } else {
-        const metavariableString = localContext.nodeAsString(metavariableNode);
+        } else {
+          const metavariableString = localContext.nodeAsString(metavariableNode);
 
-        localContext.debug(`There is no judgement present for the '${metavariableString}' metavariable.`, judgementNode);
+          localContext.debug(`There is no judgement present for the '${metavariableString}' metavariable.`, judgementNode);
+        }
       }
     }
 
@@ -108,24 +111,29 @@ function verifyStatedJudgement(judgementNode, assignments, stated, localContext)
 
     localContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
 
-    const metavariableNode = metavariableNodeQuery(judgementNode),
-          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+    const metavariableNode = metavariableNodeQuery(judgementNode);
 
-    if (metavariableVerified) {
-      const frames = [],
-            frameNode = frameNodeQuery(judgementNode),
-            frameVerified = verifyFrame(frameNode, frames, stated, localContext);
+    if (metavariableNode !== null) {
+      const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
-      if (frameVerified) {
-        const firstFrame = first(frames),
-              frame = firstFrame, ///
-              judgement = Judgement.fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode),
-              judgementAssignment = JudgementAssignment.fromJudgement(judgement),
-              assignment = judgementAssignment;
+      if (metavariableVerified) {
+        const frames = [],
+              frameNode = frameNodeQuery(judgementNode),
+              frameVerified = verifyFrame(frameNode, frames, stated, localContext);
 
-        assignments.push(assignment);
+        if (frameVerified) {
+          if (assignments !== null) {
+            const firstFrame = first(frames),
+                  frame = firstFrame, ///
+                  judgement = Judgement.fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode),
+                  judgementAssignment = JudgementAssignment.fromJudgement(judgement),
+                  assignment = judgementAssignment;
+
+            assignments.push(assignment);
+          }
 
-        statedJudgementVerified = true;
+          statedJudgementVerified = true;
+        }
       }
     }
 

package/src/verify/premise.js

@@ -29,12 +29,12 @@ export default function verifyPremise(premiseNode, premises, localContext) {
       const assignmentsAssigned = assignAssignments(assignments, localContext);
 
       if (assignmentsAssigned) {
-        const metaproofStep = ProofStep.fromStatementNode(statementNode),
-              premise = Premise.fromStatementNode(statementNode);
+        const premise = Premise.fromStatementNode(statementNode),
+              proofStep = ProofStep.fromStatementNode(statementNode);
 
         premises.push(premise);
 
-        localContext.addProofStep(metaproofStep);
+        localContext.addProofStep(proofStep);
 
         premiseVerified = true;
       }

package/src/verify/statement/qualified.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import verifyStatement from "../../verify/statement";
-import unifyQualifiedStatement from "../../unify/statement/qualified";
+import unifyQualifiedStatement from "../../unify/qualifiedStatement";
 
 import { nodeQuery } from "../../utilities/query";
 import { assignAssignments } from "../../utilities/assignments";

package/src/verify/statement/unqualified.js

@@ -1,11 +1,10 @@
 "use strict";
 
 import verifyStatement from "../../verify/statement";
-import unifyUnqualifiedStatement from "../../unify/statement/unqualified";
+import unifyUnqualifiedStatement from "../../unify/unqualifiedStatement";
 
 import { nodeQuery } from "../../utilities/query";
 import { assignAssignments } from "../../utilities/assignments";
-import { verifyStatementTrivially } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
@@ -17,32 +16,28 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, loc
   localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
 
   if (!unqualifiedStatementVerified) {
-    const stated = true,
+    const stated = false,
           assignments = [],
           statementNode = statementNodeQuery(unqualifiedStatementNode),
           statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
     if (statementVerified) {
-      const unqualifiedStatementUnified = unifyUnqualifiedStatement(unqualifiedStatementNode, localContext);
+      const assignmentsAssigned = assignAssignments(assignments, localContext);
 
-      unqualifiedStatementVerified = unqualifiedStatementUnified; ///
+      unqualifiedStatementVerified = assignmentsAssigned;  ///
     }
   }
 
   if (!unqualifiedStatementVerified) {
-    const stated = false,
-          assignments = [],
+    const stated = true,
+          assignments = null,
           statementNode = statementNodeQuery(unqualifiedStatementNode),
           statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
     if (statementVerified) {
-      const statementVerifiedTrivially = verifyStatementTrivially(statementNode, localContext);
-
-      if (statementVerifiedTrivially) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
+      const unqualifiedStatementUnified = unifyUnqualifiedStatement(unqualifiedStatementNode, localContext);
 
-        unqualifiedStatementVerified = assignmentsAssigned;  ///
-      }
+      unqualifiedStatementVerified = unqualifiedStatementUnified; ///
     }
   }