occam-verify-cli 1.0.800 → 1.0.806

package/src/process/assign.js

@@ -14,9 +14,10 @@ export function equalityAssignmentFromEquality(equality, context) {
 
 export function judgementAssignmentFromJudgement(judgement, context) {
   const judgementAssignment = (context) => {
-    const judgementAdded = context.addJudgement(judgement);
+    const declaredJudgement = judgement,  ///
+          declaredJudgementAdded = context.addDeclaredJudgement(declaredJudgement);
 
-    return judgementAdded;
+    return declaredJudgementAdded;
   };
 
   return judgementAssignment;
@@ -27,12 +28,12 @@ export function leftVariableAssignmentFromEquality(equality, context) {
     ///
   };
 
-  const leftTermNode = equality.getLeftTermNode(),
+  const type = equality.getType(),
+        leftTermNode = equality.getLeftTermNode(),
         singularVariableNode = leftTermNode.getSingularVariableNode();
 
   if (singularVariableNode !== null) {
-    const type = equality.getType(),
-          leftVariableNode = singularVariableNode;  ///
+    const leftVariableNode = singularVariableNode;  ///
 
     leftVariableAssignment = variableAssignmentFromVariableNodeAndType(leftVariableNode, type, context);
   }
@@ -45,12 +46,12 @@ export function rightVariableAssignmentFromEquality(equality, context) {
     ///
   };
 
-  const rightTermNode = equality.getRightTermNode(),
+  const type = equality.getType(),
+        rightTermNode = equality.getRightTermNode(),
         singularVariableNode = rightTermNode.getSingularVariableNode();
 
   if (singularVariableNode !== null) {
-    const type = equality.getType(),
-          rightVariableNode = singularVariableNode;  ///
+    const rightVariableNode = singularVariableNode;  ///
 
     rightVariableAssignment = variableAssignmentFromVariableNodeAndType(rightVariableNode, type, context);
   }
@@ -109,15 +110,17 @@ function variableAssignmentFromVariableNodeAndType(variableNode, type, context)
   variable.setType(type);
 
   const variableAssignment = (context) => {
-    context.addVariable(variable);
+    const declaredVariable = variable;  ///
 
-    const variableTypeString = variable.getTypeString(),
-          variableString = variable.getString(),
-          assigned = true;
+    context.addDeclaredVariable(declaredVariable);
+
+    const declaredVariableTypeString = declaredVariable.getTypeString(),
+          declaredVariableString = declaredVariable.getString(),
+          assigned = true;  ///
 
     assigned ?
-      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeString}'.`) :
-        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeString}'.`);
+      context.trace(`Assigned the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`) :
+        context.debug(`Unable to assign the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`);
 
     return assigned;
   };

package/src/process/equate.js

@@ -2,6 +2,8 @@
 
 import { queryUtilities, EquivalencePass } from "occam-languages";
 
+import { findEquivalenceByTermNodes } from "../utilities/equivalences";
+
 const { nodeQuery } = queryUtilities;
 
 const termNodeQuery = nodeQuery("/term");
@@ -29,7 +31,7 @@ class EquationalPass extends EquivalencePass {
                   leftTermNode,
                   rightTermNode
                 ],
-                equivalence = equivalences.findEquivalenceByTermNodes(termNodes);
+                equivalence = findEquivalenceByTermNodes(equivalences, termNodes);
 
           if (equivalence !== null) {
             success = true;

package/src/process/unify.js

@@ -126,14 +126,13 @@ class MetaLevelPass extends ZipPassBase {
         let success = false;
 
         const termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode, ///
-              variableIdentifier = variableNode.getVariableIdentifier();
+              variableNode = generalTermVariableNode; ///
 
         let context;
 
         context = generalContext; ///
 
-        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
+        const variable = context.findVariableByVariableNode(variableNode);
 
         context = specificContext;  ///
 
@@ -409,14 +408,13 @@ class SubstitutionPass extends ZipPass {
         let success = false;
 
         const termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode, ///
-              variableIdentifier = variableNode.getVariableIdentifier();
+              variableNode = generalTermVariableNode; ///
 
         let context;
 
         context = generalContext; ///
 
-        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
+        const variable = context.findVariableByVariableNode(variableNode);
 
         context = specificContext;  ///
 
@@ -442,14 +440,13 @@ class IntrinsicLevelPass extends ZipPass {
         let success = false;
 
         const termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode, ///
-              variableIdentifier = variableNode.getVariableIdentifier();
+              variableNode = generalTermVariableNode; ///
 
         let context;
 
         context = generalContext; ///
 
-        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
+        const variable = context.findVariableByVariableNode(variableNode);
 
         context = specificContext;  ///
 
@@ -510,10 +507,10 @@ export function unifySubstitution(generalSubstitution, specificSubstitution, gen
   let substitutionUnifies = false;
 
   const generalSubstitutionNode = generalSubstitution.getNode(),
-    specificSubstitutionNode = specificSubstitution.getNode(),
-    generalNode = generalSubstitutionNode, ///
-    specificNode = specificSubstitutionNode,  ///
-    success = substitutionPass.run(generalNode, specificNode, generalContext, specificContext);
+        specificSubstitutionNode = specificSubstitution.getNode(),
+        generalNode = generalSubstitutionNode, ///
+        specificNode = specificSubstitutionNode,  ///
+        success = substitutionPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     substitutionUnifies = true;

package/src/utilities/context.js

@@ -10,6 +10,7 @@ import IllativeContext from "../context/illative";
 import EphemeralContext from "../context/ephemeral";
 import BranchingContext from "../context/branching";
 import SyntheticContext from "../context/synthetic";
+import NominalFileContext from "../context/file/nominal";
 
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
@@ -20,6 +21,18 @@ export function join(innerFunction, ...contexts) {
   return innerFunction(context);
 }
 
+export function ablate(innerFunction, context) {
+  let contextNominalFileContext = (context instanceof NominalFileContext);
+
+  while (!contextNominalFileContext) {
+    context = context.getContext();
+
+    contextNominalFileContext = (context instanceof NominalFileContext)
+  }
+
+  return innerFunction(context);
+}
+
 export function choose(innerFunction, context) {
   const branchingContext = BranchingContext.fromNothing(context);
 
@@ -53,12 +66,6 @@ export function descend(innerFunction, context) {
 }
 
 export function attempt(innerFunction, context) {
-  const contextEphemeralContext = (context instanceof EphemeralContext);
-
-  if (contextEphemeralContext) {
-    context = context.getContext();
-  }
-
   const ephemeralContext = EphemeralContext.fromNothing(context);
 
   context = ephemeralContext;  ///

package/src/utilities/element.js

@@ -775,6 +775,7 @@ export function referenceSubstitutionFromReferenceSubstitutionNode(referenceSubs
 }
 
 export function statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+
   const { StatementSubstitution } = elements,
         node = statementSubstitutionNode,  ///
         string = context.nodeAsString(node),

package/src/utilities/equivalences.js

@@ -0,0 +1,158 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { variablesFromTerm } from "../utilities/equivalence";
+
+const { push, separate } = arrayUtilities;
+
+export function mergeEquivalences(equivalencesA, equivalencesB, context) {
+  equivalencesA = [  ///
+    ...equivalencesA
+  ];
+
+  equivalencesB.forEach((equivalenceB) => {
+    equivalencesA = mergeEquivalence(equivalencesA, equivalenceB, context);
+  });
+
+  return equivalencesA;
+}
+
+export function findEquivalenceByTerm(equivalences, term) {
+  const equivalence = equivalences.find((equivalence) => {
+    const equivalenceComparesToTerm = equivalence.compareTerm(term);
+
+    if (equivalenceComparesToTerm) {
+      return true;
+    }
+  }) || null;
+
+  return equivalence;
+}
+
+export function findEquivalenceByTermNodes(equivalences, termNodes) {
+  const equivalence = equivalences.find((equivalence) => {
+    const termNodeMatches = equivalence.matchTermNodes(termNodes);
+
+    if (termNodeMatches) {
+      return true;
+    }
+  }) || null;
+
+  return equivalence;
+}
+
+export function separateGroundedTermsAndDefinedVariables(equivalences, groundedTerms, definedVariables, context) {
+  let groundedEquivalences,
+      remainingEquivalences,
+      initiallyGroundedEquivalences,
+      implicitlyGroundedEquivalences;
+
+  remainingEquivalences = [];
+
+  initiallyGroundedEquivalences = [];
+
+  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context);
+
+  const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.getLength();
+
+  if (initiallyGroundedEquivalencesLength > 0) {
+    groundedEquivalences = initiallyGroundedEquivalences; ///
+
+    let implicitlyGroundedEquivalencesLength = 1;
+
+    while (implicitlyGroundedEquivalencesLength > 0) {
+      let definedVariablesLength = 0,
+            previousDefinedVariablesLength = -1;
+
+      while (definedVariablesLength > previousDefinedVariablesLength) {
+        previousDefinedVariablesLength = definedVariablesLength;  ///
+
+        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);
+
+        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);
+
+        definedVariablesLength = definedVariables.length;
+      }
+
+      equivalences = remainingEquivalences; ///
+
+      remainingEquivalences = [];
+
+      implicitlyGroundedEquivalences = [];
+
+      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
+
+      push(groundedEquivalences, implicitlyGroundedEquivalences);
+
+      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.getLength();  ///
+    }
+  }
+}
+
+function mergeEquivalence(equivalencesA, equivalenceB, context) {
+  const mergedEquivalences = [];
+
+  equivalencesA.forEach((equivalenceA) => {
+    const equivalenceBDisjointFromEquivalenceA = equivalenceB.isDisjointFrom(equivalenceA);
+
+    if (equivalenceBDisjointFromEquivalenceA) {
+      const mergedEquivalence = equivalenceB;  ///
+
+      mergedEquivalences.push(mergedEquivalence);
+    } else {
+      equivalenceB = equivalenceB.mergedWith(equivalenceA, context);
+    }
+  });
+
+  const mergedEquivalence = equivalenceB;  ///
+
+  mergedEquivalences.push(mergedEquivalence);
+
+  equivalencesA = mergedEquivalences;  ///
+
+  return equivalencesA;
+}
+
+function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context) {
+  separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
+    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
+
+    if (!equivalenceInitiallyGrounded) {
+      return true;
+    }
+  });
+}
+
+function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
+  separate(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {
+    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
+
+    if (!equivalenceImplicitlyGrounded) {
+      return true;
+    }
+  });
+}
+
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
+  groundedTerms.forEach((groundedTerm) => {
+    const term = groundedTerm,  ///
+          variables = variablesFromTerm(term, context);
+
+    variables.forEach((variable) => {
+      const definedVariablesIncludesTermVariable = definedVariables.includes(variable);
+
+      if (!definedVariablesIncludesTermVariable) {
+        const definedVariable = variable;  ///
+
+        definedVariables.push(definedVariable);
+      }
+    });
+  });
+}
+
+function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
+  groundedEquivalences.forEach((groundedEquivalence) => {
+    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
+  });
+}

package/src/utilities/json.js

@@ -686,6 +686,23 @@ export function ephemeralContextFromJSON(json, context) {
   return emphemeralContext;
 }
 
+export function declaredVariablesFromJSON(json, context) {
+  let { declaredVariables } = json;
+
+  const { Variable } = elements,
+        declaredVariablesJSON = declaredVariables; ///
+
+  declaredVariables = declaredVariablesJSON.map((declaredVariableJSON) => {
+    const json = declaredVariableJSON,  ///
+          variable = Variable.fromJSON(json, context),
+          declaredVariable = variable;  ///
+
+    return declaredVariable;
+  });
+
+  return declaredVariables;
+}
+
 export function propertyRelationsFromJSON(json, context) {
   let { propertyRelations } = json;
 
@@ -718,6 +735,23 @@ export function metaLevelAssumptionsFromJSON(json, context) {
   return metaLevelAssumptions;
 }
 
+export function declaredMetavariablesFromJSON(json, context) {
+  let { declaredMetavariables } = json;
+
+  const { Metavariable } = elements,
+        declaredMetavariablesJSON = declaredMetavariables; ///
+
+  declaredMetavariables = declaredMetavariablesJSON.map((declaredMetavariableJSON) => {
+    const json = declaredMetavariableJSON,  ///
+          metavariable = Metavariable.fromJSON(json, context),
+          declaredMetavariable = metavariable;  ///
+
+    return declaredMetavariable;
+  });
+
+  return declaredMetavariables;
+}
+
 export function nameToNameJSON(name) {
   const nameJSON = name;  ///
 
@@ -760,6 +794,12 @@ export function negatedToNegatedJSON(negated) {
   return negatedJSON;
 }
 
+export function ariableToVariableJSON(ariable) {
+  const ariableJSON = ariable.toJSON();
+
+  return ariableJSON;
+}
+
 export function metaTypeToMetaTypeJSON(metaType) {
   const metaTypeJSON = (metaType !== null) ?
                          metaType.toJSON() :
@@ -846,6 +886,12 @@ export function procedureReferenceToProcedureReferenceJSON(procedureReference) {
   return procedureReferenceJSON;
 }
 
+export function declaredMetavariableToDEclaredMetavariableJSON(declaredMetavariable) {
+  const declaredMetavariableJSON = declaredMetavariable.toJSON();
+
+  return declaredMetavariableJSON;
+}
+
 export function substitutionFromSubstitutionJSON(json, context) {
   const { TermSubstitution, FrameSubstitution, StatementSubstitution, ReferenceSubstitution } = elements,
         substitution = TermSubstitution.fromJSON(json, context) ||
@@ -1136,6 +1182,16 @@ export function propertyRelationsToPropertyRelationsJSON(propertyRelations) {
   return propertyRelationsJSON;
 }
 
+export function declaredVariablesToDeclaredVariablesJSON(declaredVariables) {
+  const declaredVariablesJSON = declaredVariables.map((declaredVariable) => {
+    const declaredVariableJSON = declaredVariable.toJSON();
+
+    return declaredVariableJSON;
+  });
+
+  return declaredVariablesJSON;
+}
+
 export function metaLevelAssumptionsToMetaLevelAssumptionsJSON(metaLevelAssumptions) {
   const metaLevelAssumptionsJSON = metaLevelAssumptions.map((metaLevelAssumption) => {
     const metaLevelAssumptionJSON = metaLevelAssumption.toJSON();
@@ -1146,6 +1202,16 @@ export function metaLevelAssumptionsToMetaLevelAssumptionsJSON(metaLevelAssumpti
   return metaLevelAssumptionsJSON;
 }
 
+export function declaredMetavariablesToDeclaredMetavariablesJSON(declaredMetavariables) {
+  const declaredMetavariablesJSON = declaredMetavariables.map((declaredMetavariable) => {
+    const declaredMetavariableJSON = declaredMetavariable.toJSON();
+
+    return declaredMetavariableJSON;
+  });
+
+  return declaredMetavariablesJSON;
+}
+
 function findTypeByName(name, context) {
   const typeName = name,  ///
         type = context.findTypeByTypeName(typeName);

package/src/utilities/validation.js

@@ -101,18 +101,19 @@ function validateStatementAsMetavariable(statement, context) {
     if (metavariable !== null) {
       statementValidatesAsMetavariable = true;
 
-      const { TermSubstitution, FrameSubstitution } = elements,
-            generalContext = context, ///
-            specificContext = context;  ///
+      const { TermSubstitution, FrameSubstitution } = elements;
 
       let substitution;
 
-      const frameSubstitution = FrameSubstitution.fromStatement(statement, context),
-            termSubstitution = TermSubstitution.fromStatement(statement, context);
+      const termSubstitution = TermSubstitution.fromStatement(statement, context),
+            frameSubstitution = FrameSubstitution.fromStatement(statement, context);
 
       substitution = (termSubstitution || frameSubstitution);
 
       if (substitution !== null) {
+        const generalContext = context, ///
+              specificContext = context;  ///
+
         substitution = substitution.validate(generalContext, specificContext);  ///
 
         if (substitution === null) {