occam-verify-cli 1.0.448 → 1.0.457

package/src/element/{step.js → proofAssertion/step.js}

@@ -1,12 +1,12 @@
 "use strict";
 
-import elements from "../elements";
-import ProofAssertion from "./proofAssertion";
-import TemporaryContext from "../context/temporary";
+import elements from "../../elements";
+import ProofAssertion from "../proofAssertion";
+import TransientContext from "../../context/transient";
 
-import { define } from "../elements";
-import { unifyStatements } from "../utilities/unification";
-import { propertyAssertionFromStatement } from "../utilities/statement";
+import { define } from "../../elements";
+import { unifyStatements } from "../../utilities/unification";
+import { propertyAssertionFromStatement } from "../../utilities/statement";
 
 export default define(class Step extends ProofAssertion {
   constructor(context, string, node, statement, reference, satisfiesAssertion) {
@@ -59,9 +59,9 @@ export default define(class Step extends ProofAssertion {
   verify(substitutions, assignments, context) {
     let verifies = false;
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    const transientContext = TransientContext.fromNothing(context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const node = this.getNode(),
           stepString = this.getString(); ///
@@ -73,9 +73,9 @@ export default define(class Step extends ProofAssertion {
     if (statement === null) {
       context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`, node);
     } else {
-      const referenceVerifies = this.verifyReference(context);
+      const referenceValidates = this.validateReference(context);
 
-      if (referenceVerifies) {
+      if (referenceValidates) {
         const satisfiesAssertioVeriries = this.verifySatisfiesAssertion(context);
 
         if (satisfiesAssertioVeriries) {
@@ -92,12 +92,6 @@ export default define(class Step extends ProofAssertion {
             });
 
             if (statementUnifies) {
-              const subproofOrProofAssertion = this;  ///
-
-              context.addSubproofOrProofAssertion(subproofOrProofAssertion);
-
-              this.setContext(context);
-
               verifies = true;
             }
           }
@@ -106,52 +100,50 @@ export default define(class Step extends ProofAssertion {
     }
 
     if (verifies) {
+      this.setContext(context);
+
       context.debug(`...verified the '${stepString}' step.`, node);
     }
 
     return verifies;
   }
 
-  verifyReference(context) {
-    let referenceVeriries;
+  validateReference(context) {
+    let referenceValidates = true;
 
-    const node = this.getNode(),
-          stepString = this.getString();  ///
+    if (this.reference !== null) {
+      const node = this.getNode(),
+            stepString = this.getString();
 
-    context.trace(`Verifying the '${stepString}' step's reference... `, node);
+      context.trace(`Validating the '${stepString}' step's reference... `, node);
 
-    if (this.reference !== null) {
-      referenceVeriries = this.reference.verify(context);
-    } else {
-      referenceVeriries = true;
-    }
+      referenceValidates = this.reference.validate(context);
 
-    if (referenceVeriries) {
-      context.debug(`...verified the '${stepString}' step's reference. `, node);
+      if (referenceValidates) {
+        context.debug(`...validating the '${stepString}' step's reference. `, node);
+      }
     }
 
-    return referenceVeriries;
+    return referenceValidates;
   }
 
   verifySatisfiesAssertion(context) {
-    let satisfiesAssertionVerifies;
+    let satisfiesAssertionVerifies = true;  ///
 
-    const node = this.getNode(),
-          stepString = this.getString();  ///
+    if (this.satisfiesAssertion !== null) {
+      const node = this.getNode(),
+            stepString = this.getString();  ///
 
-    context.trace(`Verifying the '${stepString}' step's satisfies assertion... `, node);
+      context.trace(`Verifying the '${stepString}' step's satisfies assertion... `, node);
 
-    if (this.satisfiesAssertion !== null) {
       const stated = true,
             assignments = null;
 
       satisfiesAssertionVerifies = this.satisfiesAssertion.validate(assignments, stated, context);
-    } else {
-      satisfiesAssertionVerifies = true;
-    }
 
-    if (satisfiesAssertionVerifies) {
-      context.debug(`...verified the '${stepString}' step's satisfies assertion. `, node);
+      if (satisfiesAssertionVerifies) {
+        context.debug(`...verified the '${stepString}' step's satisfies assertion. `, node);
+      }
     }
 
     return satisfiesAssertionVerifies;
@@ -160,7 +152,7 @@ export default define(class Step extends ProofAssertion {
   unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
     let unifiesWithSatisfiesAssertion = false;
 
-    const stepString = this.string, ///
+    const stepString = this.getString(), ///
           satisfiesAssertionString = satisfiesAssertion.getString();
 
     context.trace(`Unifying the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion...`, this.node);

package/src/element/{supposition.js → proofAssertion/supposition.js}

@@ -1,15 +1,15 @@
 "use strict";
 
-import ProofAssertion from "./proofAssertion";
-import TemporaryContext from "../context/temporary";
-import assignAssignments from "../process/assign";
+import ProofAssertion from "../proofAssertion";
+import TransientContext from "../../context/transient";
+import assignAssignments from "../../process/assign";
 
-import { define } from "../elements";
-import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
+import { define } from "../../elements";
+import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../../utilities/json";
 
 export default define(class Supposition extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
-    super(context, string, node);
+    super(context, string, node, statement);
 
     this.procedureCall = procedureCall;
   }
@@ -21,9 +21,9 @@ export default define(class Supposition extends ProofAssertion {
   verify(context) {
     let verifies = false;
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    const transientContext = TransientContext.fromNothing(context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const node = this.getNode(),
           suppositionString = this.getString(); ///
@@ -76,10 +76,9 @@ export default define(class Supposition extends ProofAssertion {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const node = this.getNode(),
-          suppositionString = this.getString();
+    const suppositionString = this.getString();
 
-    context.trace(`Unifying the '${suppositionString}' supposition independently...`, node);
+    context.trace(`Unifying the '${suppositionString}' supposition independently...`);
 
     const specificContext = context;  ///
 
@@ -108,7 +107,7 @@ export default define(class Supposition extends ProofAssertion {
     }
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${suppositionString}' supposition independenly.`, node);
+      context.debug(`...unified the '${suppositionString}' supposition independenly.`);
     }
 
     return unifiesIndependently;
@@ -155,34 +154,35 @@ export default define(class Supposition extends ProofAssertion {
   }
 
   unifyProofAssertion(proofAssertion, substitutions, context) {
-    let stepUnifies = false;
+    let proofAssertionUnifies = false;
 
-    const node = this.getNode(),
-          suppositionString = this.getString(),
+    const suppositionString = this.getString(),
           proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`, node);
-
-    const specificContext = context;  ///
+    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`);
 
     context = this.getContext();
 
     const generalContext = context; ///
 
+    context = proofAssertion.getContext();
+
+    const specificContext = context;  ///
+
     context = specificContext;  ///
 
     const statement = proofAssertion.getStatement(),
           statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      stepUnifies = true;
+      proofAssertionUnifies = true;
     }
 
-    if (stepUnifies) {
-      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`, node);
+    if (proofAssertionUnifies) {
+      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`);
     }
 
-    return stepUnifies;
+    return proofAssertionUnifies;
   }
 
   unifySubproof(subproof, substitutions, context) {
@@ -287,7 +287,7 @@ export default define(class Supposition extends ProofAssertion {
           frames = framesFromJSON(json, context),
           statement = statementFromJSON(json, context),
           procedureCall = procedureCallFromJSON(json, context),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+          transientContext = TransientContext.fromTermsAndFrames(terms, frames, context);
 
     let string;
 
@@ -301,7 +301,7 @@ export default define(class Supposition extends ProofAssertion {
 
     const node = null;
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const supposition = new Supposition(context, string, node, statement, procedureCall);
 

package/src/element/proofAssertion.js

@@ -46,28 +46,21 @@ export default class ProofAssertion extends Element {
     return comparesToStatement;
   }
 
-  unifyStatement(statement, substitutions, context) {
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnifies = false;
 
     if (this.statement !== null) {
       const node = this.getNode(),
-            premiseString = this.getString(), ///
-            statementString = statement.getString();
+            context = specificContext, ///
+            statementString = statement.getString(),
+            proorAssertionString = this.getString();  ///
 
-      context.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`, node);
-
-      const specificContext = context;  ///
-
-      context = this.getContext();  ///
-
-      const generalContext = context; ///
-
-      context = specificContext;  ///
+      context.trace(`Unifying the '${statementString}' statement with the '${proorAssertionString}' proof assertion...`, node);
 
       statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
       if (statementUnifies) {
-        context.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`, node);
+        context.debug(`...unified the '${statementString}' statement with the '${proorAssertionString}' proof assertion.`, node);
       }
     }
 

package/src/element/reference.js

@@ -4,7 +4,8 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { referenceMetaTypeFromNothing } from "../metaTypes";
+import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
+import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { unifyMetavariableIntrinsically } from "../process/unify";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
@@ -39,41 +40,42 @@ export default define(class Reference extends Element {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchNode(metavariableNode); }
 
-  verify(context) {
-    let verifies = false;
+  validate(context) {
+    let validate = false;
 
     const referenceString = this.getString(); ///
 
-    context.trace(`Verifying the '${referenceString}' reference...`);
+    context.trace(`Validating the '${referenceString}' reference...`);
 
-    if (!verifies) {
+    if (!validate) {
       const metavariableValidates = this.validateMetavariable(context);
 
-      verifies = metavariableValidates; ///
+      validate = metavariableValidates; ///
     }
 
-    if (!verifies) {
+    if (!validate) {
       const reference = this, ///
             labelPresent = context.isLabelPresentByReference(reference);
 
-      verifies = labelPresent;  ///
+      validate = labelPresent;  ///
     }
 
-    if (verifies) {
+    if (validate) {
       const reference = this; ///
 
       context.addReference(reference);
 
-      context.debug(`...verified the '${referenceString}' reference.`);
+      context.debug(`...validated the '${referenceString}' reference.`);
     }
 
-    return verifies;
+    return validate;
   }
 
   validateMetavariable(context) {
     let metavariableValidates = false;
 
-    const referenceMetaType = referenceMetaTypeFromNothing(),
+    const metaTypeName = REFERENCE_META_TYPE_NAME,
+          referenceMetaType = findMetaTypeByMetaTypeName(metaTypeName),
           metaType = referenceMetaType, ///
           metavariableValidatesGivenMetaType = this.metavariable.validateGivenMetaType(metaType, context);
 
@@ -141,27 +143,27 @@ export default define(class Reference extends Element {
     return metavariableUnifies;
   }
 
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnifies;
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelMetaAssertionUnifies;
 
     const reference = this, ///
           referenceString = reference.getString(),
-          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
 
     const { Substitutions } = elements,
-          label = metaLemmaMetatheorem.getLabel(),
+          label = topLevelMetaAssertion.getLabel(),
           substitutions = Substitutions.fromNothing(),
           labelUnifies = this.unifyLabel(label, substitutions, context);
 
-    metaLemmaMetatheoremUnifies = labelUnifies;  ///
+    topLevelMetaAssertionUnifies = labelUnifies;  ///
 
-    if (metaLemmaMetatheoremUnifies) {
-      context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference.`);
+    if (topLevelMetaAssertionUnifies) {
+      context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference.`);
     }
 
-    return metaLemmaMetatheoremUnifies;
+    return topLevelMetaAssertionUnifies;
   }
 
   toJSON() {

package/src/element/rule.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import Element from "../element";
 import elements from "../elements";
-import LocalContext from "../context/local";
+import ScopedContext from "../context/scoped";
 
 import { define } from "../elements";
 import { labelsFromJSON,
@@ -70,9 +70,9 @@ export default define(class Rule extends Element {
     const labelsVerify = this.verifyLabels();
 
     if (labelsVerify) {
-      const localContext = LocalContext.fromNothing(context);
+      const scopedContext = ScopedContext.fromNothing(context);
 
-      context = localContext; ///
+      context = scopedContext; ///
 
       const premisesVerify = this.verifyPremises(context);
 

package/src/element/section.js

@@ -45,11 +45,11 @@ export default define(class Section extends Element {
     const hypothesesVerify = this.verifyHypotheses();
 
     if (hypothesesVerify) {
-      const axiomLemmaTheoremOrConjecture = (this.axiom || this.lemma || this.theorem || this.conjecture),
-            axiomLemmaTheoremOrConjectureVerifies = axiomLemmaTheoremOrConjecture.verify(this.context);
+      const topLevelAssertion = (this.axiom || this.lemma || this.theorem || this.conjecture),
+            topLevelAssertionVerifies = topLevelAssertion.verify(this.context);
 
-      if (axiomLemmaTheoremOrConjectureVerifies) {
-        axiomLemmaTheoremOrConjecture.setHypotheses(this.hypotheses);
+      if (topLevelAssertionVerifies) {
+        topLevelAssertion.setHypotheses(this.hypotheses);
 
         verifies = true;
       }

package/src/element/statement.js

@@ -18,15 +18,8 @@ export default define(class Statement extends Element {
   }
 
   getMetavariableName() {
-    let metavariableName = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const node = this.getNode();
-
-      metavariableName = node.getMetavariableName();
-    }
+    const node = this.getNode(),
+          metavariableName = node.getMetavariableName();
 
     return metavariableName;
   }

package/src/element/subproof.js

@@ -2,7 +2,7 @@
 
 import Element from "../element";
 import elements from "../elements";
-import LocalContext from "../context/local";
+import ScopedContext from "../context/scoped";
 
 import { define } from "../elements";
 
@@ -49,9 +49,9 @@ export default define(class Subproof extends Element {
   verify(substitutions, assignments, context) {
     let verifies = false;
 
-    const localContext = LocalContext.fromNothing(context);  ///
+    const scopedContext = ScopedContext.fromNothing(context);  ///
 
-    context = localContext; ///
+    context = scopedContext; ///
 
     const suppositionsVerify = this.suppositions.every((supposition) => {
       const suppositionVerifies = supposition.verify(context);

package/src/element/substitution/frame.js

@@ -3,7 +3,9 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { withinFragment } from "../../utilities/fragment";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
+import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromFrameSubstitutionNode, frameSubstitutionFromStatementNode } from "../../utilities/element";
 
 export default define(class FrameSubstitution extends Substitution {
@@ -86,18 +88,13 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   static fromFrameAndMetavariable(frame, metavariable, context) {
-    const string = stringFromFrameAndMetavariable(frame, metavariable),
-          frameSubstitutionNode = instantiateFrameSubstitution(string, context),
-          frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
-
-    return frameSubstitution;
+    return withinFragment((context) => {
+      const frameAndMetavariableString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
+            string = frameAndMetavariableString,  ///
+            frameSubstitutionNode = instantiateFrameSubstitution(string, context),
+            frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+
+      return frameSubstitution;
+    }, context);
   }
 });
-
-function stringFromFrameAndMetavariable(frame, metavariable) {
-  const frameString = frame.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${frameString} for [${metavariableString}]]`;
-
-  return string;
-}

package/src/element/substitution/statement.js

@@ -4,11 +4,13 @@ import elements from "../../elements";
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { withinFragment } from "../../utilities/fragment";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../../utilities/json";
+import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
   constructor(context, string, node, resolved, statement, metavariable, substitution) {
@@ -73,12 +75,13 @@ export default define(class StatementSubstitution extends Substitution {
     return substitutionEqualToSubstitution;
   }
 
-  isStatementEqualToStatement(statement, context) {
+  compareStatesment(statement, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const statementEqualToStatement = this.statement.isEqualTo(statement);
+    const statementEqualToStatement = this.statement.isEqualTo(statement),
+          comparesToStatement = statementEqualToStatement;  ///
 
-    return statementEqualToStatement;
+    return comparesToStatement;
   }
 
   isSimple() {
@@ -214,18 +217,14 @@ export default define(class StatementSubstitution extends Substitution {
   static fromStatementAndMetavariable(statement, metavariable, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const string = stringFromStatementAndMetavariable(statement, metavariable),
-          statementSubstitutionNode = instantiateStatementSubstitution(string, context);
+    const statementSubstitution = withinFragment((context) => {
+      const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
+            string = statementSubstitutionString, ///
+            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
+            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context)
 
-    context = {
-      nodeAsString: () => string
-    };
-
-    const statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
-
-    statementSubstitution.setStatement(statement);
-
-    statementSubstitution.setMetavariable(metavariable);
+      return statementSubstitution;
+    }, context);
 
     return statementSubstitution;
   }
@@ -233,46 +232,15 @@ export default define(class StatementSubstitution extends Substitution {
   static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context),
-          statementSubstitutionNode = instantiateStatementSubstitution(string, context);
-
-    context = {
-      nodeAsString: () => string
-    };
+    const statementSubstitution = withinFragment((context) => {
+      const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
+            string = statementSubstitutionString, ///
+            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
+            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context)
 
-    const statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
-
-    statementSubstitution.setStatement(statement);
-
-    statementSubstitution.setMetavariable(metavariable);
-
-    statementSubstitution.setSubstitution(substitution);
+      return statementSubstitution;
+    }, context);
 
     return statementSubstitution;
   }
 });
-
-function stringFromStatementAndMetavariable(statement, metavariable) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${statementString} for ${metavariableString}]`;
-
-  return string;
-}
-
-function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
-  let string;
-
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString();
-
-  if (substitution === null) {
-    string = `[${statementString} for ${metavariableString}]`;
-  } else {
-    const substitutionString = substitution.getString();
-
-    string = `[${statementString} for ${metavariableString}${substitutionString}]`;
-  }
-
-  return string;
-}

package/src/element/substitution.js

@@ -92,10 +92,10 @@ export default class Substitution extends Element {
     return referenceEqualToReference;
   }
 
-  isStatementEqualToStatement(statement, context) {
-    const statementEqualToStatement = false;
+  compareStatement(statement, context) {
+    const comparesToStatement = false;
 
-    return statementEqualToStatement;
+    return comparesToStatement;
   }
 
   isMetavariableEqualToMetavariable(metavariable) {