occam-verify-cli 1.0.388 → 1.0.404

package/src/ontology/premise.js

@@ -1,20 +1,26 @@
 "use strict";
 
 import ontology from "../ontology";
+import TemporaryContext from "../context/temporary";
 
 import { define } from "../ontology";
 import { assignAssignments } from "../utilities/assignments";
 import { subproofAssertionFromStatement } from "../utilities/context";
-import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
+import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
 export default define(class Premise {
-  constructor(node, string, statement, procedureCall) {
+  constructor(context, node, string, statement, procedureCall) {
+    this.context = context;
     this.node = node;
     this.string = string;
     this.statement = statement;
     this.procedureCall = procedureCall;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getNode() {
     return this.node;
   }
@@ -34,6 +40,10 @@ export default define(class Premise {
   verify(context) {
     let verifies = false;
 
+    const temporaryContext = TemporaryContext.fromNothing(context);
+
+    context = temporaryContext; ///
+
     const premiseString = this.string; ///
 
     context.trace(`Verifying the '${premiseString}' premise...`, this.node);
@@ -71,6 +81,8 @@ export default define(class Premise {
     }
 
     if (verifies) {
+      this.context = context;
+
       context.debug(`...verified the '${premiseString}' premise.`, this.node);
     }
 
@@ -78,24 +90,38 @@ export default define(class Premise {
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiesIndependently;
+    let unifiesIndependently = false;
+
+    const premiseString = this.string,  ///
+          generalContext = this.context,  ///
+          specificContext = context;  ///
+
+    context.trace(`Unifying the '${premiseString}' premise independently...`, this.node);
 
     if (this.statement !== null) {
-      const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, context);
+      const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
 
-      unifiesIndependently = statementResolvedIndependently;  ///
+      if (statementUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
     }
 
     if (this.procedureCall !== null) {
       const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
 
-      unifiesIndependently = procedureCallResolvedIndependently;  ///
+      if (procedureCallResolvedIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
+    if (unifiesIndependently) {
+      context.debug(`...unified the '${premiseString}' premise independenly.`, this.node);
     }
 
     return unifiesIndependently;
   }
 
-  unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext) {
+  unifyStepOrSubproof(stepOrSubproof, substitutions, context) {
     let stepOrSubproofUnifies = false;
 
     const stepOrSubProofStep = stepOrSubproof.isStep(),
@@ -109,33 +135,35 @@ export default define(class Premise {
     substitutions.snapshot();
 
     if (subproof !== null) {
-      const subproofUnifies = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
+      const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
 
       stepOrSubproofUnifies = subproofUnifies; ///
     }
 
     if (step !== null) {
-      const statementUnifies = this.unifyStep(step, substitutions, generalContext, specificContext);
+      const statementUnifies = this.unifyStep(step, substitutions, context);
 
       stepOrSubproofUnifies = statementUnifies;  ///
     }
 
     if (stepOrSubproofUnifies) {
-      substitutions.resolve(generalContext, specificContext);
+      substitutions.resolve(context);
     }
 
     stepOrSubproofUnifies ?
       substitutions.continue() :
-        substitutions.rollback(specificContext);
+        substitutions.rollback(context);
 
     return stepOrSubproofUnifies;
   }
 
-  unifyStep(step, substitutions, generalContext, specificContext) {
+  unifyStep(step, substitutions, context) {
     let stepUnifies = false;
 
+    context = step.getContext();
+
     const statement = step.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+          statementUnifies = this.unifyStatement(statement, substitutions, context);
 
     if (statementUnifies) {
       stepUnifies = true;
@@ -170,34 +198,53 @@ export default define(class Premise {
     return subproofUnifies;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
     const premise = this, ///
           premiseString = premise.getString(),
           statementString = statement.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
 
     if (this.statement !== null) {
+      const generalContext = this.context,  ///
+            specificContext = context;  ///
+
       statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
     }
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
+      context.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
     }
 
     return statementUnifies;
   }
 
   toJSON() {
-    const statementJSON = statementToStatementJSON(this.statement),
-          procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
+    let frames,
+        terms;
+
+    frames = this.context.getFrames();
+
+    terms = this.context.getTerms();
+
+    const procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
+          statementJSON = statementToStatementJSON(this.statement),
+          framesJSON = framesToFramesJSON(frames),
+          termsJSON = termsToTermsJSON(terms);
+
+    frames = framesJSON;  ///
+
+    terms = termsJSON;  ///
+
+    const procedureCall = procedureCallJSON,  ///
           statement = statementJSON,  ///
-          procedureCall = procedureCallJSON,  ///
           json = {
+            procedureCall,
             statement,
-            procedureCall
+            frames,
+            terms
           };
 
     return json;
@@ -206,8 +253,11 @@ export default define(class Premise {
   static name = "Premise";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context),
-          procedureCall = procedureCallFromJSON(json, context);
+    const terms = termsFromJSON(json, context),
+          frames = framesFromJSON(json, context),
+          statement = statementFromJSON(json, context),
+          procedureCall = procedureCallFromJSON(json, context),
+          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
 
     let string;
 
@@ -219,8 +269,11 @@ export default define(class Premise {
       string = procedureCall.getString();
     }
 
-    const node = null,
-          premise = new Premise(node, string, statement, procedureCall);
+    const node = null;
+
+    context = temporaryContext; ///
+
+    const premise = new Premise(context, node, string, statement, procedureCall);
 
     return premise;
   }
@@ -231,7 +284,11 @@ export default define(class Premise {
           string = context.nodeAsString(node),
           statement = Statement.fromPremiseNode(premiseNode, context),
           procedureCall = ProcedureCall.fromPremiseNode(premiseNode, context),
-          premise = new Premise(node, string, statement, procedureCall);
+          temporaryContext = null;
+
+    context = temporaryContext; ///
+
+    const premise = new Premise(context, node, string, statement, procedureCall);
 
     return premise
   }

package/src/ontology/procedureCall.js

@@ -8,29 +8,29 @@ import { define } from "../ontology";
 import { parametersFromJSON, procedureReferenceFromJSON, parametersToParametersJSON, procedureReferenceToProcedureReferenceJSON } from "../utilities/json";
 
 export default define(class ProcedureCall {
-  constructor(node, string, procedureReference, parameters) {
-    this.node = node;
+  constructor(string, node, parameters, procedureReference) {
     this.string = string;
-    this.procedureReference = procedureReference;
+    this.node = node;
     this.parameters = parameters;
-  }
-
-  getNode() {
-    return this.node;
+    this.procedureReference = procedureReference;
   }
 
   getString() {
     return this.string;
   }
 
-  getProcedureReference() {
-    return this.procedureReference;
+  getNode() {
+    return this.node;
   }
 
   getParameters() {
     return this.parameters;
   }
 
+  getProcedureReference() {
+    return this.procedureReference;
+  }
+
   getName() { return this.procedureReference.getName(); }
 
   findNodes(substitutions) {
@@ -118,11 +118,11 @@ export default define(class ProcedureCall {
   static name = "ProcedureCall";
 
   static fromJSON(json, context) {
-    const procedureReference = procedureReferenceFromJSON(json, context),
+    const node = null,
           parameters = parametersFromJSON(json, context),
-          node = null,
+          procedureReference = procedureReferenceFromJSON(json, context),
           string = stringFromProcedureReferenceAndParameters(procedureReference, parameters),
-          procedureCall = new ProcedureCall(node, string, procedureReference, parameters);
+          procedureCall = new ProcedureCall(string, node, parameters, procedureReference);
 
     return procedureCall;
   }
@@ -155,10 +155,10 @@ export default define(class ProcedureCall {
 function procedureCallFromProcedureCallNode(procedureCallNode, context) {
   const { ProcedureCall, ProcedureReference } = ontology,
         node = procedureCallNode, ///
-        procedureReference = ProcedureReference.fromProcedureCallNode(procedureCallNode, context),
         parameters = parametersFromProcedureCallNode(procedureCallNode, context),
+        procedureReference = ProcedureReference.fromProcedureCallNode(procedureCallNode, context),
         string = stringFromProcedureReferenceAndParameters(procedureReference, parameters),
-        procedureCall = new ProcedureCall(node, string, procedureReference, parameters);
+        procedureCall = new ProcedureCall(string, node, parameters, procedureReference);
 
   return procedureCall;
 }

package/src/ontology/procedureReference.js

@@ -25,6 +25,8 @@ export default define(class ProcedureReference {
     return json;
   }
 
+  static name = "ProcedureReference";
+
   static fromJSON(json, context) {
     const { name } = json,
           string = name,  ///
@@ -33,8 +35,6 @@ export default define(class ProcedureReference {
     return procedureReference;
   }
 
-  static name = "ProcedureReference";
-
   static fromProcedureCallNode(procedureCallNode, context) {
     const procedureName = procedureCallNode.getProcedureName(),
           name = procedureName, ///

package/src/ontology/proof.js

@@ -27,7 +27,7 @@ export default define(class Proof {
   verify(substitutions, conclusion, context) {
     let verifies = false;
 
-    const localContext = LocalContext.fromContext(context); ///
+    const localContext = LocalContext.fromNothing(context); ///
 
     context = localContext; ///
 

package/src/ontology/reference.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import ontology from "../ontology";
-import Substitutions from "../substitutions";
 
 import { define } from "../ontology";
 import { referenceMetaType } from ".//metaType";
@@ -33,12 +32,7 @@ export default define(class Reference {
     return metavariableNode;
   }
 
-  isMetavariableEqualTo(metavariable) {
-    const equalTo = this.metavariable.isEqualTo(metavariable),
-          metavariableEqualTo = equalTo;  ///
-
-    return metavariableEqualTo;
-  }
+  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
   matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 
@@ -120,7 +114,8 @@ export default define(class Reference {
 
     context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const substitutions = Substitutions.fromNothing(),
+    const { Substitutions } = ontology,
+          substitutions = Substitutions.fromNothing(),
           generalContext = context, ///
           specificContext = context,  ///
           generalMetavariable = this.metavariable,  ///
@@ -145,7 +140,8 @@ export default define(class Reference {
 
     context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference...`);
 
-    const label = metaLemmaMetatheorem.getLabel(),
+    const { Substitutions } = ontology,
+          label = metaLemmaMetatheorem.getLabel(),
           substitutions = Substitutions.fromNothing(),
           labelUnifies = this.unifyLabel(label, substitutions, context);
 

package/src/ontology/rule.js

@@ -4,7 +4,6 @@ import { arrayUtilities } from "necessary";
 
 import ontology from "../ontology";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 
 import { define } from "../ontology";
 import { labelsStringFromLabels } from "./topLevelAssertion";
@@ -68,85 +67,6 @@ export default define(class Rule {
     return metavariableNameMatches;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
-    let statementAndStepsOrSubproofsUnify = false;
-
-    const generalContext = this.context, ///
-          specificContext = context; ///
-
-    const substitutions = Substitutions.fromNothing(),
-          statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext);
-
-    if (statementUnifiesWithConclusion) {
-      const stepsOrSubproofsUnifyWithPremises = this.unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, generalContext, specificContext);
-
-      if (stepsOrSubproofsUnifyWithPremises) {
-        const substitutionsResolved = substitutions.areResolved();
-
-        if (substitutionsResolved) {
-          statementAndStepsOrSubproofsUnify = true;
-        }
-      }
-    }
-
-    return statementAndStepsOrSubproofsUnify;
-  }
-
-  unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext) {
-    let statementUnifiesWithConclusion = false;
-
-    const statementUnifies = this.conclusion.unifyStatement(statement, substitutions, generalContext, specificContext);
-
-    if (statementUnifies) {
-      statementUnifiesWithConclusion = true;
-    }
-
-    return statementUnifiesWithConclusion;
-  }
-
-  unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, generalContext, specificContext) {
-    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
-
-    const stepsOrSubproofsUnifyWithPremises = backwardsEvery(this.premises, (premise) => {
-      const stepUnifiesWithPremise = this.unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, generalContext, specificContext);
-
-      if (stepUnifiesWithPremise) {
-        return true;
-      }
-    });
-
-    return stepsOrSubproofsUnifyWithPremises;
-  }
-
-  unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, generalContext, specificContext) {
-    let stepsOrSubproofsUnifyWithPremise = false;
-
-    if (!stepsOrSubproofsUnifyWithPremise) {
-      const context = specificContext,  ///
-            premiseUnifiesIndependently = premise.unifyIndependently(substitutions, context);
-
-      if (premiseUnifiesIndependently) {
-        stepsOrSubproofsUnifyWithPremise = true;
-      }
-    }
-
-    if (!stepsOrSubproofsUnifyWithPremise) {
-      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepOrSubproofUnifies = premise.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
-
-        if (stepOrSubproofUnifies) {
-          return true;
-        }
-      }) || null;
-
-      if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifyWithPremise = true;
-      }
-    }
-
-    return stepsOrSubproofsUnifyWithPremise;
-  }
-
   verify() {
     let verifies = false;
 
@@ -157,7 +77,7 @@ export default define(class Rule {
     const labelsVerify = this.verifyLabels();
 
     if (labelsVerify) {
-      const localContext = LocalContext.fromContext(this.context),
+      const localContext = LocalContext.fromNothing(this.context),
             context = localContext, ///
             premisesVerify = this.verifyPremises(context);
 
@@ -228,7 +148,8 @@ export default define(class Rule {
     if (this.proof === null) {
       proofVerifies = true;
     } else {
-      const substitutions = Substitutions.fromNothing();
+      const { Substitutions } = ontology,
+            substitutions = Substitutions.fromNothing();
 
       proofVerifies = this.proof.verify(substitutions, this.conclusion, context);
     }
@@ -236,6 +157,82 @@ export default define(class Rule {
     return proofVerifies;
   }
 
+  unifyStatementWithConclusion(statement, substitutions, context) {
+    let statementUnifiesWithConclusion = false;
+
+    const statementUnifies = this.conclusion.unifyStatement(statement, substitutions, context);
+
+    if (statementUnifies) {
+      statementUnifiesWithConclusion = true;
+    }
+
+    return statementUnifiesWithConclusion;
+  }
+
+  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
+    let statementAndStepsOrSubproofsUnify = false;
+
+    const { Substitutions } = ontology,
+          substitutions = Substitutions.fromNothing(),
+          statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, context);
+
+    if (statementUnifiesWithConclusion) {
+      const stepsOrSubproofsUnifiesWithPremises = this.unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, context);
+
+      if (stepsOrSubproofsUnifiesWithPremises) {
+        const substitutionsResolved = substitutions.areResolved();
+
+        if (substitutionsResolved) {
+          statementAndStepsOrSubproofsUnify = true;
+        }
+      }
+    }
+
+    return statementAndStepsOrSubproofsUnify;
+  }
+
+  unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, context) {
+    let stepsOrSubproofsUnifiesWithPremise = false;
+
+    if (!stepsOrSubproofsUnifiesWithPremise) {
+      const premiseUnifiesIndependently = premise.unifyIndependently(substitutions, context);
+
+      if (premiseUnifiesIndependently) {
+        stepsOrSubproofsUnifiesWithPremise = true;
+      }
+    }
+
+    if (!stepsOrSubproofsUnifiesWithPremise) {
+      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
+        const stepOrSubproofUnifies = premise.unifyStepOrSubproof(stepOrSubproof, substitutions, context);
+
+        if (stepOrSubproofUnifies) {
+          return true;
+        }
+      }) || null;
+
+      if (stepOrSubproof !== null) {
+        stepsOrSubproofsUnifiesWithPremise = true;
+      }
+    }
+
+    return stepsOrSubproofsUnifiesWithPremise;
+  }
+
+  unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, context) {
+    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
+
+    const stepsOrSubproofsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
+      const stepUnifiesWithPremise = this.unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, context);
+
+      if (stepUnifiesWithPremise) {
+        return true;
+      }
+    });
+
+    return stepsOrSubproofsUnifiesWithPremises;
+  }
+
   toJSON() {
     const labelsJSON = labelsToLabelsJSON(this.labels),
           premisesJSON = premisesToPremisesJSON(this.premises),

package/src/ontology/section.js

@@ -91,7 +91,7 @@ export default define(class Section {
   static name = "Section";
 
   static fromSectionNode(sectionNode, context) {
-    const localContext = LocalContext.fromContext(context);
+    const localContext = LocalContext.fromNothing(context);
 
     context = localContext; ///
 

package/src/ontology/signature.js

@@ -71,7 +71,7 @@ export default define(class Signature {
                       termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
                       substitution = termSubstitution;  ///
 
-                substitutions.addSubstitution(substitution, specificContext);
+                substitutions.addSubstitution(substitution, context);
 
                 return true;
               }