occam-verify-cli 1.0.871 → 1.0.873

package/src/context/mnemic.js

@@ -175,260 +175,110 @@ export default class MnemicContext extends Context {
 
   addTerm(term) {
     const context = this, ///
-          termA = term, ///
           termString = term.getString();
 
     context.trace(`Adding the '${termString}' term to the mnemic context...`);
 
-    const terms = this.getTerms(),
-          termB = terms.find((term) => {
-            const termB = term, ///
-                  termAComparesToTermB = termA.compareTerm(termB);
-      
-            if (termAComparesToTermB) {
-              return true;
-            }
-          }) || null;
-
-    if (termB !== null) {
-      context.trace(`The '${termString}' term has already been added to the mnemic context.`);
-    } else {
-      this.terms.push(term);
-    }
+    this.terms.push(term);
 
     context.debug(`...added the '${termString}' term to the mnemic context.`);
   }
 
   addFrame(frame) {
     const context = this, ///
-          frameA = frame, ///
           frameString = frame.getString();
 
     context.trace(`Adding the '${frameString}' frame to the mnemic context...`);
 
-    const frames = this.getFrames(),
-          frameB = frames.find((frame) => {
-            const frameB = frame, ///
-                  frameAEqualToFrameB = frameA.isEqualTo(frameB);
-      
-            if (frameAEqualToFrameB) {
-              return true;
-            }
-          }) || null;
-
-    if (frameB !== null) {
-      context.trace(`The '${frameString}' frame has already been added to the mnemic context.`);
-    } else {
-      this.frames.push(frame);
-    }
+    this.frames.push(frame);
 
     context.debug(`...added the '${frameString}' frame to the mnemic context.`);
   }
 
   addEquality(equality) {
     const context = this, ///
-          equalityA = equality, ///
           equalityString = equality.getString();
 
     context.trace(`Adding the '${equalityString}' equality to the mnemic context...`);
 
-    const equalities = this.getEqualities(),
-          equalityB = equalities.find((equality) => {
-            const equalityB = equality, ///
-                  equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
-      
-            if (equalityAEqualToEqualityB) {
-              return true;
-            }
-          }) || null;
-
-    if (equalityB !== null) {
-      context.trace(`The '${equalityString}' equality has already been added to the mnemic context.`);
-    } else {
-      this.equalities.push(equality);
-    }
+    this.equalities.push(equality);
 
     context.debug(`...added the '${equalityString}' equality to the mnemic context.`);
   }
 
   addJudgement(judgement) {
     const context = this, ///
-          judgementA = judgement, ///
           judgementString = judgement.getString();
 
     context.trace(`Adding the '${judgementString}' judgement to the mnemic context...`);
 
-    const judgements = this.getJudgements(),
-          judgementB = judgements.find((judgement) => {
-            const judgementB = judgement, ///
-                  judgementAEqualToEqualityB = judgementA.isEqualTo(judgementB);
-      
-            if (judgementAEqualToEqualityB) {
-              return true;
-            }
-          }) || null;
-
-    if (judgementB !== null) {
-      context.trace(`The '${judgementString}' judgement has already been added to the mnemic context.`);
-    } else {
-      this.judgements.push(judgement);
-    }
+    this.judgements.push(judgement);
 
     context.debug(`...added the '${judgementString}' judgement to the mnemic context.`);
   }
 
   addStatement(statement) {
     const context = this, ///
-          statementA = statement, ///
           statementString = statement.getString();
 
     context.trace(`Adding the '${statementString}' statement to the mnemic context...`);
 
-    const statements = this.getStatements(),
-          statementB = statements.find((statement) => {
-            const statementB = statement, ///
-                  statementAEqualToStatementB = statementA.isEqualTo(statementB);
-      
-            if (statementAEqualToStatementB) {
-              return true;
-            }
-          }) || null;
-
-    if (statementB !== null) {
-      context.trace(`The '${statementString}' statement has already been added to the mnemic context.`);
-    } else {
-      this.statements.push(statement);
-    }
+    this.statements.push(statement);
 
     context.debug(`...added the '${statementString}' statement to the mnemic context.`);
   }
 
   addAssertion(assertion) {
     const context = this, ///
-          assertionA = assertion, ///
           assertionString = assertion.getString();
 
     context.trace(`Adding the '${assertionString}' assertion to the mnemic context...`);
 
-    const assertions = this.getAssumptions(),
-          assertionB = assertions.find((assertion) => {
-            const assertionB = assertion, ///
-                  assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
-      
-            if (assertionAEqualToAssertionB) {
-              return true;
-            }
-          }) || null;
-
-    if (assertionB !== null) {
-      context.trace(`The '${assertionString}' assertion has already been added to the mnemic context.`);
-    } else {
-      this.assertions.push(assertion);
-    }
+    this.assertions.push(assertion);
 
     context.debug(`...added the '${assertionString}' assertion to the mnemic context.`);
   }
 
   addReference(reference) {
     const context = this, ///
-          referenceA = reference, ///
           referenceString = reference.getString();
 
     context.trace(`Adding the '${referenceString}' reference to the mnemic context...`);
 
-    const references = this.getReferences(),
-          referenceB = references.find((reference) => {
-            const referenceB = reference, ///
-                  referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
-      
-            if (referenceAEqualToReferenceB) {
-              return true;
-            }
-          }) || null;
-
-    if (referenceB !== null) {
-      context.trace(`The '${referenceString}' reference has already been added to the mnemic context.`);
-    } else {
-      this.references.push(reference);
-    }
+    this.references.push(reference);
 
     context.debug(`...added the '${referenceString}' reference to the mnemic context.`);
   }
 
   addAssumption(assumption) {
     const context = this, ///
-          assumptionA = assumption, ///
           assumptionString = assumption.getString();
 
     context.trace(`Adding the '${assumptionString}' assumption to the mnemic context...`);
 
-    const assumptions = this.getAssumptions(),
-          assumptionB = assumptions.find((assumption) => {
-            const assumptionB = assumption, ///
-                  assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
-      
-            if (assumptionAEqualToAssumptionB) {
-              return true;
-            }
-          }) || null;
-
-    if (assumptionB !== null) {
-      context.trace(`The '${assumptionString}' assumption has already been added to the mnemic context.`);
-    } else {
-      this.assumptions.push(assumption);
-    }
+    this.assumptions.push(assumption);
 
     context.debug(`...added the '${assumptionString}' assumption to the mnemic context.`);
   }
 
   addMetavariable(metavariable) {
     const context = this, ///
-          metavariableA = metavariable, ///
           metavariableString = metavariable.getString();
 
     context.trace(`Adding the '${metavariableString}' metavariable to the mnemic context...`);
 
-    const metavariables = this.getMetavariables(),
-          metavariableB = metavariables.find((metavariable) => {
-            const metavariableB = metavariable, ///
-                  metavariableAEqualToSubstitutionB = metavariableA.isEqualTo(metavariableB);
-      
-            if (metavariableAEqualToSubstitutionB) {
-              return true;
-            }
-          }) || null;
-
-    if (metavariableB !== null) {
-      context.trace(`The '${metavariableString}' metavariable has already been added to the mnemic context.`);
-    } else {
-      this.metavariables.push(metavariable);
-    }
+    this.metavariables.push(metavariable);
 
     context.debug(`...added the '${metavariableString}' metavariable to the mnemic context.`);
   }
 
   addSubstitution(substitution) {
     const context = this, ///
-          substitutionA = substitution, ///
           substitutionString = substitution.getString();
 
     context.trace(`Adding the '${substitutionString}' substitution to the mnemic context...`);
 
-    const substitutions = this.getSubstitutions(),
-          substitutionB = substitutions.find((substitution) => {
-            const substitutionB = substitution, ///
-                  substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
-
-            if (substitutionAEqualToSubstitutionB) {
-              return true;
-            }
-          }) || null;
-
-    if (substitutionB !== null) {
-      context.trace(`The '${substitutionString}' substitution has already been added to the mnemic context.`);
-    } else {
-      this.substitutions.push(substitution);
-    }
+    this.substitutions.push(substitution);
 
     context.debug(`...added the '${substitutionString}' substitution to the mnemic context.`);
   }

package/src/element/assumption.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
+import {instantiate, reconcile} from "../utilities/context";
 import { instantiateAssumption } from "../process/instantiate";
 
 export default define(class Assumption extends Element {
@@ -209,11 +209,13 @@ export default define(class Assumption extends Element {
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
 
-    topLevelMetaAssertionUnifies = this.reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+    reconcile((context) => {
+      topLevelMetaAssertionUnifies = this.reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-    if (topLevelMetaAssertionUnifies) {
-      topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
-    }
+      if (topLevelMetaAssertionUnifies) {
+        topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+      }
+    }, context);
 
     if (topLevelMetaAssertionUnifies) {
       context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);

package/src/element/metavariable.js

@@ -514,18 +514,6 @@ export default define(class Metavariable extends Element {
 
       if (metavariableNodeMatches) {
         frameMetavariableUnifies = true;
-      } else {
-        const frameSingular = frame.isSingular();
-
-        if (frameSingular) {
-          const frameMetavariableName = frame.getMetavariableName(),
-                frameDeclaredMetavariable = context.findDeclaredMetavariableByMetavariableName(frameMetavariableName),
-                frameMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(frameDeclaredMetavariable, generalContext, specificContext);
-
-          if (frameMetavariableUnifiesIntrinsically) {
-            frameMetavariableUnifies = true;
-          }
-        }
       }
     }
 
@@ -549,18 +537,11 @@ export default define(class Metavariable extends Element {
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
-      const metavariable = this,  ///
-            referenceMetavariableComparesToMetvariable = reference.compareMetavariable(metavariable);
+      const metavariableNode = this.getMetavariableNode(),
+            metavariableNodeMatches = reference.matchMetavariableNode(metavariableNode);
 
-      if (referenceMetavariableComparesToMetvariable) {
+      if (metavariableNodeMatches) {
         referenceMetavariableUnifies = true;
-      } else {
-        const referenceMetavariable = reference.getMetavariable(),
-              referenceMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(referenceMetavariable, generalContext, specificContext);
-
-        if (referenceMetavariableUnifiesIntrinsically) {
-          referenceMetavariableUnifies = true;
-        }
       }
     }
 
@@ -585,22 +566,10 @@ export default define(class Metavariable extends Element {
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariableNode = this.getMetavariableNode(),
-            statementMetavariableComparesToMetvariable = statement.matchMetavariableNode(metavariableNode);
+            metavariableNodeMatches = statement.matchMetavariableNode(metavariableNode);
 
-      if (statementMetavariableComparesToMetvariable) {
+      if (metavariableNodeMatches) {
         statementMetavariableUnifies = true;
-      } else {
-        const statementSingular = statement.isSingular();
-
-        if (statementSingular) {
-          const statementMetavariableName = statement.getMetavariableName(),
-                statementDeclaredMetavariable = context.findDeclaredMetavariableByMetavariableName(statementMetavariableName),
-                statementMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(statementDeclaredMetavariable, generalContext, specificContext);
-
-          if (statementMetavariableUnifiesIntrinsically) {
-            statementMetavariableUnifies = true;
-          }
-        }
       }
     }
 

package/src/element/reference.js

@@ -76,26 +76,6 @@ export default define(class Reference extends Element {
     return comparesToParamter;
   }
 
-  compareMetavariable(metavariable) {
-    let comparesToMetavariable = false;
-
-    let metavariableName;
-
-    metavariableName = this.metavariable.getName();
-
-    const metavariableNameA = metavariableName ///
-
-    metavariableName = metavariable.getName();
-
-    const metavariableNameB = metavariableName; ///
-
-    if (metavariableNameA === metavariableNameB) {
-      comparesToMetavariable = true;
-    }
-
-    return comparesToMetavariable;
-  }
-
   compareTopLevelMetaAssertion(topLevelMetaAssertion) {
     let topLevelMetaAssertionCompares = false;
 
@@ -274,18 +254,13 @@ export default define(class Reference extends Element {
     const label = topLevelMetaAssertion.getLabel(),
           labelContext = label.getContext(),
           referenceString = this.getString(), ///
-          temporaryContext = context, ///
+          referenceContext = this.getContext(), ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
 
-    const specificContext = labelContext; ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = temporaryContext; ///
+    const generalContext = referenceContext, ///
+          specificContext = labelContext; ///
 
     join((specificContext) => {
       reconcile((specificContext) => {

package/src/element/statement.js

@@ -6,7 +6,7 @@ import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
 import { instantiateStatement } from "../process/instantiate";
-import { join, reconcile, instantiate } from "../utilities/context";
+import { reconcile, instantiate } from "../utilities/context";
 
 export default define(class Statement extends Element {
   getStatementNode() {
@@ -257,17 +257,15 @@ export default define(class Statement extends Element {
     const generalContext = context, ///
           specificContext = deductionContext;  ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const deductionStatementUnifies = this.unifyStatement(deductionStatement, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const deductionStatementUnifies = this.unifyStatement(deductionStatement, generalContext, specificContext);
 
-        if (deductionStatementUnifies) {
-          specificContext.commit(context);
+      if (deductionStatementUnifies) {
+        specificContext.commit(context);
 
-          deductionUnifies = true;
-        }
-      }, specificContext);
-    }, specificContext, context);
+        deductionUnifies = true;
+      }
+    }, specificContext);
 
     if (deductionUnifies) {
       context.debug(`...unified the '${deductionString}' deduction with the '${statementString}' statement.`);

package/src/element/substitution/frame.js

@@ -208,15 +208,18 @@ export default define(class FrameSubstitution extends Substitution {
     return frameSubstitutionn;
   }
 
-  static fromStatement(statement, generalContext, specificContext) {
+  static fromStatement(statement, context) {
     let frameSubstitution = null;
 
     const frameSubstitutionNode = statement.getFrameSubstitutionNode();
 
     if (frameSubstitutionNode !== null) {
-      ablates((generalContext, specificContext) => {
+      ablate((context) => {
+        const generalContext = context, ///
+              specificContext = context;  ///
+
         frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, generalContext, specificContext);
-      }, generalContext, specificContext);
+      }, context);
     }
 
     return frameSubstitution;
@@ -225,9 +228,9 @@ export default define(class FrameSubstitution extends Substitution {
   static fromFrameAndMetavariable(frame, metavariable, generalContext, specificContext) {
     let frameSubstitution
 
-    const context = specificContext;  ///
+    ablates((generalContext, specificContext) => {
+      const context = specificContext;  ///
 
-    ablate((context) => {
       instantiate((context) => {
         const specificContext = context,  ///
               frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
@@ -236,7 +239,7 @@ export default define(class FrameSubstitution extends Substitution {
 
         frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, generalContext, specificContext);
       }, context);
-    }, context);
+    }, generalContext, specificContext);
 
     return frameSubstitution;
   }

package/src/element/substitution/reference.js

@@ -5,7 +5,7 @@ import Substitution from "../substitution";
 import { define } from "../../elements";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
-import { ablate, attempts, descend, instantiate, unserialises } from "../../utilities/context";
+import { ablates, attempts, descend, instantiate, unserialises } from "../../utilities/context";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
 
 export default define(class ReferenceSubstitution extends Substitution {
@@ -216,9 +216,9 @@ export default define(class ReferenceSubstitution extends Substitution {
   static fromReferenceAndMetavariable(reference, metavariable, generalContext, specificContext) {
     let referenceSubstitution;
 
-    const context = specificContext;  ///
+    ablates((generalContext, specificContext) => {
+      const context = specificContext;  ///
 
-    ablate((context) => {
       instantiate((context) => {
         const specificContext = context,  ///
               referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
@@ -227,7 +227,7 @@ export default define(class ReferenceSubstitution extends Substitution {
 
         referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, generalContext, specificContext);
       }, context);
-    }, context);
+    }, generalContext, specificContext);
 
     return referenceSubstitution;
   }
@@ -235,9 +235,9 @@ export default define(class ReferenceSubstitution extends Substitution {
   static fromAssumptionAndMetaLevelAssumption(assumption, metaLevelAssumption, generalContext, specificContext) {
     let referenceSubstitution;
 
-    const context = specificContext;  ///
+    ablates((generalContext, specificContext) => {
+      const context = specificContext;  ///
 
-    ablate((context) => {
       instantiate((context) => {
         const specificContext = context,  ///
               metavariable = assumption.getMetavariable(),
@@ -248,7 +248,7 @@ export default define(class ReferenceSubstitution extends Substitution {
 
         referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, generalContext, specificContext);
       }, context);
-    }, context);
+    }, generalContext, specificContext);
 
     return referenceSubstitution;
   }

package/src/element/substitution/statement.js

@@ -7,7 +7,7 @@ import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
-import { join, ablate, attempts, descend, reconcile, instantiate, unserialises } from "../../utilities/context";
+import { join, ablate, ablates, attempts, descend, reconcile, instantiate, unserialises } from "../../utilities/context";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
@@ -380,16 +380,20 @@ export default define(class StatementSubstitution extends Substitution {
 
     let statementSubstitution;
 
-    ablate((context) => {
+    ablates((generalContext, specificContext) => {
+      const context = specificContext;  ///
+
       instantiate((context) => {
         const specificContext = context,  ///
               statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable),
               string = statementSubstitutionString, ///
               statementSubstitutionNode = instantiateStatementSubstitution(string, context);
 
+        generalContext.gainTokens(specificContext);
+
         statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, generalContext, specificContext);
       }, context);
-    }, context);
+    }, generalContext, specificContext);
 
     return statementSubstitution;
   }

package/src/element/substitution/term.js

@@ -219,15 +219,18 @@ export default define(class TermSubstitution extends Substitution {
     return termSubstitutionn;
   }
 
-  static fromStatement(statement, generalContext, specificContext) {
+  static fromStatement(statement, context) {
     let termSubstitution = null;
 
     const termSubstitutionNode = statement.getTermSubstitutionNode();
 
     if (termSubstitutionNode !== null) {
-      ablates((generalContext, specificContext) => {
+      ablate((context) => {
+        const generalContext = context, ///
+              specificContext = context;  ///
+
         termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, generalContext, specificContext);
-      }, generalContext, specificContext);
+      }, context);
     }
 
     return termSubstitution;
@@ -240,7 +243,9 @@ export default define(class TermSubstitution extends Substitution {
 
     let termSubstitution;
 
-    ablate((context) => {
+    ablates((generalContext, specificContext) => {
+      const context = specificContext;  ///
+
       instantiate((context) => {
         const specificContext = context, ///
               termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
@@ -249,7 +254,7 @@ export default define(class TermSubstitution extends Substitution {
 
         termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, generalContext, specificContext);
       }, context);
-    }, context);
+    }, generalContext, specificContext);
 
     return termSubstitution;
   }