occam-verify-cli 1.0.609 → 1.0.612

package/src/element/judgement.js

@@ -31,7 +31,7 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
-  compareMetavariable(metavariable) { return this.frame.compareMetavariable(metavariable); }
+  matchMetavariableName(metavariableName) { return this.frame.matchMetavariableName(metavariableName); }
 
   validate(assignments, stated, context) {
     let validates = false;

package/src/element/metavariable.js

@@ -39,6 +39,20 @@ export default define(class Metavariable extends Element {
     this.metaType = metaType;
   }
 
+  getMetavariableNode() {
+    const node = this.getNode(),
+          metavarialbeNode = node;  ///
+
+    return metavarialbeNode;
+  }
+
+  getMetavariableName() {
+    const metavarialbeNode = this.getMetavariableNode(),
+          metavariableName = metavarialbeNode.getMetavariableName();
+
+    return metavariableName;
+  }
+
   compare(metavariable) {
     const name = metavariable.getName(),
           comparesToMetavariable = (this.name === name);
@@ -112,13 +126,13 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
-    const metavariable = this, ///
-          frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
+    const frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
 
     if (frameMetavariableUnifies) {
       frameUnifies = true;
     } else {
-      const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
+      const metavariableName = this.getMetavariableName(),
+            simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
       if (simpleSubstitution !== null) {
         const substitution = simpleSubstitution,  ///
@@ -129,6 +143,7 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { FrameSubstitution } = elements,
+              metavariable = this, ///
               frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
               framesubstitutionValidates = frameSubstitution.validate(generalContext, specificContext);
 
@@ -169,10 +184,11 @@ export default define(class Metavariable extends Element {
     if (statementMetavariableUnifies) {
       statementUnifies = true;
     } else {
-      const substitutionPresent = context.isSubstitutionPresentByMetavariableAndSubstitution(metavariable, substitution);
+      const metavariableName = metavariable.getName(),
+            substitutionPresent = context.isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution);
 
       if (substitutionPresent) {
-        substitution = context.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution, generalContet, specificContext); ///
+        substitution = context.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution); ///
 
         const substitutionComparesToStatement = substitution.compareStatement(statement, context);
 
@@ -221,16 +237,16 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
-    const metavariable = this, ///
-          referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
+    const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
 
     if (referenceMetavariableUnifies) {
       referenceUnifies = true;
     } else {
-      const simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariable(metavariable);
+      const metavariableName = this.getMetavariableName(),
+            simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
 
       if (simpleSubstitutionPresent) {
-        const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable),
+        const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName),
               substitution = simpleSubstitution,  ///
               substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference);
 
@@ -239,6 +255,7 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { ReferenceSubstitution } = elements,
+              metavariable = this, ///
               referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
               substitution = referenceSubstitution; ///
 
@@ -295,8 +312,8 @@ export default define(class Metavariable extends Element {
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
-      const metavariable = this,  ///
-            frameMetavariableComparesToMetvariable = frame.compareMetavariable(metavariable);
+      const metavariableName = this.getMetavariableName(),  ///
+            frameMetavariableComparesToMetvariable = frame.matchMetavariableName(metavariableName);
 
       if (frameMetavariableComparesToMetvariable) {
         frameMetavariableUnifies = true;

package/src/element/proofAssertion/premise.js

@@ -17,6 +17,13 @@ export default define(class Premise extends ProofAssertion {
     return this.procedureCall;
   }
 
+  getPremiseNode() {
+    const node = this.getNode(),
+          premiseNode = node; ///
+
+    return premiseNode;
+  }
+
   isStated() {
     const stated = true; ///
 

package/src/element/proofAssertion/step.js

@@ -27,6 +27,13 @@ export default define(class Step extends ProofAssertion {
     return this.satisfiesAssertion;
   }
 
+  getStepNode() {
+    const node = this.getNode(),
+          stepNode = node;  ///
+
+    return stepNode;
+  }
+
   isSatisfied() {
     const satisfied = (this.satisfiesAssertion !== null);
 

package/src/element/proofAssertion/supposition.js

@@ -17,6 +17,13 @@ export default define(class Supposition extends ProofAssertion {
     return this.procedureCall;
   }
 
+  getSuppositionNode() {
+    const node = this.getNode(),
+          suppositionNode = node; ///
+
+    return suppositionNode;
+  }
+
   isStated() {
     const stated = true; ///
 

package/src/element/reference.js

@@ -53,6 +53,20 @@ export default define(class Reference extends Element {
     return equalTo;
   }
 
+  matchMetavariableName(metavariableName) {
+    let metavariableNameMatches = false;
+
+    const metavariableNameA = metavariableName ///
+
+    metavariableName = this.getMetavariableName();
+
+    const metavariableNameB = metavariableName; ///
+
+    metavariableNameMatches = (metavariableNameA === metavariableNameB);
+
+    return metavariableNameMatches;
+  }
+
   isValid(context) {
     const assertionNode = this.getReferenceNode(),
           assertionPresent = context.isReferencePresentByReferenceNode(assertionNode),

package/src/element/statement.js

@@ -49,6 +49,24 @@ export default define(class Statement extends Element {
     return equalTo;
   }
 
+  matchMetavariableName(metavariableName) {
+    let metavariableNameMatches = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const metavariableNameA = metavariableName ///
+
+      metavariableName = this.getMetavariableName();
+
+      const metavariableNameB = metavariableName; ///
+
+      metavariableNameMatches = (metavariableNameA === metavariableNameB);
+    }
+
+    return metavariableNameMatches;
+  }
+
   isValid(context) {
     const statementNode = this.getStatementNode(),
           statementPresent = context.isStatementPresentByStatementNode(statementNode),

package/src/element/substitution/frame.js

@@ -24,6 +24,13 @@ export default define(class FrameSubstitution extends Substitution {
     return this.replacementFrame;
   }
 
+  getFrameSubstitutionNode() {
+    const node = this.getNode(),
+          frameSubstitutionNode = node; ///
+
+    return frameSubstitutionNode;
+  }
+
   getTargetNode() {
     const targetFrameNode = this.targetFrame.getNode(),
           tergetNode = targetFrameNode; ///
@@ -38,20 +45,9 @@ export default define(class FrameSubstitution extends Substitution {
     return replacementNode;
   }
 
-  getMetavariable(generalContext, specificContext) {
-    let metavariable = null;
-
-    const targetFrameNode = this.targetFrame.getNode(),
-          metavariableName = targetFrameNode.getMetavariableName();
+  matchMetavariableName(metavariableName) { return this.targetFrame.matchMetavariableName(metavariableName); }
 
-    if (metavariableName !== null) {
-      const context = generalContext; ///
-
-      metavariable = context.findMetavariableByMetavariableName(metavariableName);
-    }
-
-    return metavariable;
-  }
+  getMetavariableName() { return this.targetFrame.getMetavariableName(); }
 
   isTrivial() {
     const targetFrameEqualToReplacementFrame = this.targetFrame.isEqualTo(this.replacementFrame),
@@ -156,7 +152,7 @@ export default define(class FrameSubstitution extends Substitution {
     replacementFrameValidates = this.replacementFrame.validate(assignments, stated, context);
 
     if (replacementFrameValidates) {
-      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);
+      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame.`);
     }
 
     return replacementFrameValidates;

package/src/element/substitution/reference.js

@@ -24,6 +24,13 @@ export default define(class ReferenceSubstitution extends Substitution {
     return this.replacementReference;
   }
 
+  getReferenceSubstitutionNode() {
+    const node = this.getNode(),
+          referenceSubstitution = node; ///
+
+    return referenceSubstitution;
+  }
+
   getTargetNode() {
     const targetReferenceNode = this.targetReference.getNode(),
           tergetNode = targetReferenceNode; ///
@@ -38,20 +45,9 @@ export default define(class ReferenceSubstitution extends Substitution {
     return replacementNode;
   }
 
-  getMetavariable(generalContext, specificContext) {
-    let metavariable = null;
-
-    const targetReferenceNode = this.targetReference.getNode(),
-          metavariableName = targetReferenceNode.getMetavariableName();
+  getMetavariableName() { return this.targetReference.getMetavariableName(); }
 
-    if (metavariableName !== null) {
-      const context = generalContext; ///
-
-      metavariable = context.findMetavariableByMetavariableName(metavariableName);
-    }
-
-    return metavariable;
-  }
+  matchMetavariableName(metavariableName) { return this.targetReference.matchMetavariableName(metavariableName); }
 
   isTrivial() {
     const targetReferenceEqualToReplacementReference = this.targetReference.isEqualTo(this.replacementReference),
@@ -150,7 +146,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     replacementReferenceValidates = this.replacementReference.validate(context);
 
     if (replacementReferenceValidates) {
-      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);
+      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference.`);
     }
 
     return replacementReferenceValidates;

package/src/element/substitution/statement.js

@@ -37,21 +37,15 @@ export default define(class StatementSubstitution extends Substitution {
     return this.replacementStatement;
   }
 
-  getMetavariable(generalContext, specificContext) {
-    let metavariable = null;
+  getStatementSubstitutionNode() {
+    const node = this.getNode(),
+          statementSubstitutionNode = node; ///
 
-    const targetStatementNode = this.targetStatement.getNode(),
-          metavariableName = targetStatementNode.getMetavariableName();
-
-    if (metavariableName !== null) {
-      const context = generalContext; ///
-
-      metavariable = context.findMetavariableByMetavariableName(metavariableName);
-    }
-
-    return metavariable;
+    return statementSubstitutionNode;
   }
 
+  getMtavariableName() { return this.targetStatement.getMtavariableName(); }
+
   getTargetNode() {
     const targetStatementNode = this.targetStatement.getNode(),
           targetNode = targetStatementNode; ///
@@ -72,6 +66,10 @@ export default define(class StatementSubstitution extends Substitution {
     return simple;
   }
 
+  getMetavariableName() { return this.targetStatement.getMetavariableName(); }
+
+  matchMetavariableName(metavariableName) { return this.targetStatement.matchMetavariableName(metavariableName); }
+
   compareStatement(statement, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
@@ -190,7 +188,7 @@ export default define(class StatementSubstitution extends Substitution {
     replacementStatementValidates = this.replacementStatement.validate(assignments, stated, context);
 
     if (replacementStatementValidates) {
-      context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement...`);
+      context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement.`);
     }
 
     return replacementStatementValidates;
@@ -248,11 +246,11 @@ export default define(class StatementSubstitution extends Substitution {
 
     context = generalContext; ///
 
-    const metavariable = this.getMetavariable(generalContext, specificContext);
+    const metavariableName = this.getMetavariableName();
 
     context = specificContext;  ///
 
-    const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
+    const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
     context = this.getContext();
 

package/src/element/substitution/term.js

@@ -25,6 +25,13 @@ export default define(class TermSubstitution extends Substitution {
     return this.replacementTerm;
   }
 
+  getTermSubstitutionNode() {
+    const node = this.getNode(),
+          termSubstitutionNode = node;  ///
+
+    return termSubstitutionNode;
+  }
+
   getTargetNode() {
     const targetTermNode = this.targetTerm.getNode(),
           tergetNode = targetTermNode; ///
@@ -39,19 +46,7 @@ export default define(class TermSubstitution extends Substitution {
     return replacementNode;
   }
 
-  getVariable(generalContext, specificContext) {
-    let variable = null;
-
-    const targetTermNode = this.targetTerm.getNode(),
-          variableIdentifier = targetTermNode.getVariableIdentifier();
-
-    if (variableIdentifier !== null) {
-      const context = specificContext;  ///
-      variable = context.findVariableByVariableIdentifier(variableIdentifier);
-    }
-
-    return variable;
-  }
+  getVariableIdentifier() { return this.targetTerm.getVariableIdentifier(); }
 
   isTrivial() {
     const targetTermEqualToReplacementTerm = this.targetTerm.isEqualTo(this.replacementTerm),

package/src/element/substitution.js

@@ -25,12 +25,6 @@ export default class Substitution extends Element {
     return primitive;
   }
 
-  getMetavariable(context) {
-    const metavariable = null;
-
-    return metavariable;
-  }
-
   getSubstitutionNode() {
     const node = this.getNode(),
           substitutionNode = node; ///
@@ -38,6 +32,18 @@ export default class Substitution extends Element {
     return substitutionNode;
   }
 
+  getNetavariableName() {
+    const metavariableName = null;
+
+    return metavariableName;
+  }
+
+  getVariableIdentifier() {
+    const variableIdentifier = null;
+
+    return variableIdentifier;
+  }
+
   matchSubstitutionNode(substitutionNode) {
     const substitutionNodeA = substitutionNode; ///
 

package/src/element/variable.js

@@ -113,7 +113,7 @@ export default define(class Variable extends Element {
     return typeValidates;
   }
 
-  unifyTerm(term, substitutions, generalContext, specificContext) {
+  unifyTerm(term, generalContext, specificContext) {
     let termUnifies = false;
 
     const context = specificContext,  ///
@@ -127,7 +127,9 @@ export default define(class Variable extends Element {
 
     variable = this; ///
 
-    substitution = substitutions.findSubstitutionByVariable(variable, generalContext, specificContext);
+    const variableIdentifier = variable.getIdentifier();
+
+    substitution = context.findSubstitutionByVariableIdentifier(variableIdentifier);
 
     if (substitution !== null) {
       const substitutionComparesToTerm = substitution.compareTerm(term, context);

package/src/process/unify.js

@@ -69,7 +69,7 @@ class MetaLevelPass extends ZipPass {
 
         const substitutionNode = statementNode.getSubstitutionNode(),
               substitution = (substitutionNode !== null) ?
-                               context.findSubstitutionBySubstitutionNode(substitutionNode, generalContext, specificContext) :
+                               context.findSubstitutionBySubstitutionNode(substitutionNode) :
                                  null;
 
         context = specificContext; ///

package/src/utilities/element.js

@@ -621,7 +621,7 @@ export function variableDeclarationFromVariableDeclarationNode(variableDeclarati
         variableNode = variableDeclarationNode.getVariableNode(),
         type = typeFromTypeNode(typeNode, context),
         variable = variableFromVariableNode(variableNode, context),
-        variableDeclaration = new VariableDeclaration(context, string, node, variable, type, provisional);
+        variableDeclaration = new VariableDeclaration(context, string, node, type, variable, provisional);
 
   return variableDeclaration;
 }
@@ -708,7 +708,7 @@ export function metavariableDeclarationFromMetavariableDeclarationNode(metavaria
         string = context.nodeAsString(node),
         metaType = metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
         metavariable = metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
-        metavariableDeclaration = new MetavariableDeclaration(context, string, node, metavariable, metaType);
+        metavariableDeclaration = new MetavariableDeclaration(context, string, node, metaType, metavariable);
 
   return metavariableDeclaration;
 }

package/src/utilities/substitutions.js

@@ -16,7 +16,7 @@ export function termFromTermAndSubstitutions(term, generalContext, specificConte
             variable = generalContext.findVariableByVariableIdentifier(variableIdentifier);
 
       if (variable !== null) {
-        const substitution = specificContext.findSubstitutionByVariable(variable, generalContext, specificContext);
+        const substitution = specificContext.findSubstitutionByVariableIdentifier(variableIdentifier);
 
         if (substitution !== null) {
           const termSubstitution = substitution,  ///
@@ -43,7 +43,7 @@ export function frameFromFrameAndSubstitutions(frame, generalContext, specificCo
             metavariable = generalContext.findMetavariableByMetavariableName(metavariableName);
 
       if (metavariable !== null) {
-        const substitution = specificContext.findSubstitutionByMetavariable(metavariable, generalContext, specificContext);
+        const substitution = specificContext.findSubstitutionByMetavariableName(metavariableName);
 
         if (substitution !== null) {
           const frameSubstitution = substitution, ///
@@ -77,7 +77,7 @@ export function statementFromStatementAndSubstitutions(statement, generalContext
 
         specificContext = context;  ///
 
-        substitution = specificContext.findSubstitutionBySubstitutionNode(substitutionNode, generalContext, specificContext);
+        substitution = specificContext.findSubstitutionBySubstitutionNode(substitutionNode);
 
         context = generalContext; ///
 
@@ -91,8 +91,8 @@ export function statementFromStatementAndSubstitutions(statement, generalContext
 
       if (metavariable !== null) {
         substitution = (substitution !== null) ?
-                         specificContext.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution, generalContext, specificContext) :
-                           specificContext.findSubstitutionByMetavariable(metavariable, generalContext, specificContext);
+                         specificContext.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) :
+                           specificContext.findSubstitutionByMetavariableName(metavariableName);
 
         if (substitution !== null) {
           const statementSubstitution = substitution, ///
@@ -107,25 +107,22 @@ export function statementFromStatementAndSubstitutions(statement, generalContext
   return statement;
 }
 
-export function metavariablesFromSubstitutions(substitutions, generalContext, specificContext) {
-  const metavariables = [];
+export function metavariableNamesFromSubstitutions(substitutions) {
+  const metavariableNames = [];
 
   substitutions.forEach((substitution) => {
-    const context = generalContext, ///
-          metavariable = substitution.getMetavariable(generalContext, specificContext);
+    const metavariableName = substitution.getMetavariableName();
 
-    if (metavariable !== null) {
-      metavariables.push(metavariable);
+    if (metavariableName !== null) {
+      metavariableNames.push(metavariableName);
     }
   });
 
-  compress(metavariables, (metavariableA, metavariableB) => {
-    const metavariableComparesToMetavariableB = metavariableB.compare(metavariableA);
-
-    if (!metavariableComparesToMetavariableB) {
+  compress(metavariableNames, (metavariableNameA, metavariableNameB) => {
+    if (metavariableNameB !== metavariableNameB) {
       return true;
     }
   });
 
-  return metavariables;
+  return metavariableNames;
 }

package/src/utilities/unification.js

@@ -144,9 +144,7 @@ async function unifyStatementWithTopLevelAssertion(statement, reference, satisfi
   let statementUnifiesWithTopLevelAssertion = false;
 
   if (reference !== null) {
-    const { Substitutions } = elements,
-          topLevelAssertion = context.findTopLevelAssertionByReference(reference),
-          generalSubstitutions = substitutions; ///
+    const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
     if (topLevelAssertion !== null) {
       const statementString = statement.getString(),
@@ -155,7 +153,7 @@ async function unifyStatementWithTopLevelAssertion(statement, reference, satisfi
       context.trace(`Unifying the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion...`);
 
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
-            statementAndSubproofOrProofAssertionsUnify = topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
+            statementAndSubproofOrProofAssertionsUnify = await topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
 
       if (statementAndSubproofOrProofAssertionsUnify) {
         const metavariable = reference.getMetavariable();