occam-verify-cli 1.0.617 → 1.0.632

package/src/process/assign.js

@@ -1,57 +1,134 @@
 "use strict";
 
-export function variableAssignmentFromVariable(variable) {
-  return function (context) {
-    context.addVariable(variable);
+import { variableFromVariableNode } from "../utilities/element";
 
-    const variableTypeString = variable.getTypeString(),
-          variableString = variable.getString(),
-          assigned = true;
+export function equalityAssignmentFromEquality(equality, context) {
+  const equalityAssignment = (context) => {
+    const equalityAdded = context.addEquality(equality);
 
-    assigned ?
-      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeString}'.`) :
-        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeString}'.`);
+    return equalityAdded;
+  };
 
-    return assigned;
+  return equalityAssignment;
+}
+
+export function judgementAssignmentFromJudgement(judgement, context) {
+  const judgementAssignment = (context) => {
+    const judgementAdded = context.addJudgement(judgement);
+
+    return judgementAdded;
   };
+
+  return judgementAssignment;
 }
 
-export function equalityAssignmentFromEquality(equality) {
-  return function (context) {
-    const equalityString = equality.getString(),
-          equalityAdded = context.addEquality(equality),
-          assigned = equalityAdded; ///
+export function leftVariableAssignmentFromEquality(equality, context) {
+  let leftVariableAssignment = null;
 
-    assigned ?
-      context.trace(`Assigned the '${equalityString}' equality.`) :
-        context.debug(`Unable to assign the '${equalityString}' equality.`);
+  const leftTermNode = equality.getLeftTermNode(),
+        singularVariableNode = leftTermNode.getSingularVariableNode();
 
-    return assigned;
-  };
+  if (singularVariableNode !== null) {
+    const type = equality.getType(),
+          leftVariableNode = singularVariableNode;  ///
+
+    leftVariableAssignment = variableAssignmentFromVariableNodeAndType(leftVariableNode, type, context);
+  }
+
+  return leftVariableAssignment;
 }
 
-export function judgementAssignmentFromJudgement(judgement) {
-  return function (context) {
-    const judgementString = judgement.getString(),
-          judgementAdded = context.addJudgement(judgement),
-          assigned = judgementAdded; ///
+export function rightVariableAssignmentFromEquality(equality, context) {
+  let rightVariableAssignment = null;
 
-    assigned ?
-      context.trace(`Assigned the '${judgementString}' judgement.`) :
-        context.debug(`Unable to assign the '${judgementString}' judgement.`);
+  const rightTermNode = equality.getRightTermNode(),
+        singularVariableNode = rightTermNode.getSingularVariableNode();
 
-    return assigned;
-  };
+  if (singularVariableNode !== null) {
+    const type = equality.getType(),
+          rightVariableNode = singularVariableNode;  ///
+
+    rightVariableAssignment = variableAssignmentFromVariableNodeAndType(rightVariableNode, type, context);
+  }
+
+  return rightVariableAssignment;
 }
 
-export default function assignAssignments(assignments, context) {
-  const assignmentsAssigned = assignments.every((assigment) => {
-    const assigned = assigment(context);
+export function variableAssignmentFromTypeAssertion(typeAssertion, context) {
+
+  debugger
 
-    if (assigned) {
-      return true;
-    }
+  // const { Type, Variable } = elements,
+  //   termNode = this.term.getNode();
+  //
+  // let type,
+  //   provisional;
+  //
+  // provisional = this.type.isProvisional();
+  //
+  // if (!provisional) {
+  //   type = this.type;
+  // } else {
+  //   provisional = false;
+  //
+  //   type = Type.fromTypeAndProvisional(this.type, provisional);
+  // }
+  //
+  // const singularVariableNode = termNode.getSingularVariableNode();
+  //
+  // if (singularVariableNode !== null) {
+  //   const variableNode = singularVariableNode,  ///
+  //     variable = Variable.fromVariableNodeAndType(variableNode, type, context),
+  //     variableAssignment = variableAssignmentFromVariable(variable),
+
+}
+
+export function variableAssignmentFromPrepertyAssertion(propertyAssertion, context) {
+
+  debugger
+
+  // let variable;
+  //
+  // const { Variable } = elements,
+  //   termNode = this.term.getNode();
+  //
+  // variable = Variable.fromTermNode(termNode, context);
+  //
+  // if (variable !== null) {
+  //   const variableIdentifier = variable.getIdentifier();
+  //
+  //   variable = context.findVariableByVariableIdentifier(variableIdentifier);
+  //
+  //   variable = Variable.fromVariableAndPropertyRelation(variable, this.propertyRelation);
+  //
+  //   const variableAssignment = variableAssignmentFromVariable(variable),
+
+  }
+
+export default function assignAssignments(assignments, context) {
+  assignments.forEach((assignment) => {
+    assignment(context);
   });
+}
+
+function variableAssignmentFromVariableNodeAndType(variableNode, type, context) {
+  const variable = variableFromVariableNode(variableNode, context);
+
+  variable.setType(type);
+
+  const variableAssignment = (context) => {
+    context.addVariable(variable);
+
+    const variableTypeString = variable.getTypeString(),
+          variableString = variable.getString(),
+          assigned = true;
+
+    assigned ?
+      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeString}'.`) :
+        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeString}'.`);
+
+    return assigned;
+  };
 
-  return assignmentsAssigned;
+  return variableAssignment;
 }

package/src/process/unify.js

@@ -2,7 +2,6 @@
 
 import { ZipPass, queryUtilities } from "occam-languages";
 
-import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { termFromTermNode, frameFromFrameNode, statementFromStatementNode } from "../utilities/element";
 
 const { nodeQuery } = queryUtilities;
@@ -161,7 +160,7 @@ class CombinatorPass extends ZipPass {
         context = generalContext; ///
 
         const metaTypeName = metaTypeNode.getMetaTypeName(),
-              metaType = findMetaTypeByMetaTypeName(metaTypeName);
+              metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
 
         context = specificContext;  ///
 
@@ -189,7 +188,7 @@ class CombinatorPass extends ZipPass {
         context = generalContext; ///
 
         const metaTypeName = metaTypeNode.getMetaTypeName(),
-              metaType = findMetaTypeByMetaTypeName(metaTypeName);
+              metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
 
         context = specificContext;  ///
 

package/src/process/validate.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import { ForwardPass } from "occam-languages";
 import { queryUtilities } from "occam-languages";
+import { SimplePass, ForwardPass } from "occam-languages";
 
 import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
 
@@ -70,7 +70,7 @@ class TermPass extends ForwardPass {
   ];
 }
 
-class StatementPass extends ForwardPass {
+class StatementPass extends SimplePass {
   run(statementNode, context) {
     let success = false;
 
@@ -92,8 +92,8 @@ class StatementPass extends ForwardPass {
         let success = false;
 
         const statement = statementFromStatementNode(statementNode, context),
-              assignments = null,
               stated = false,
+              assignments = null,
               statementValidates = statement.validate(assignments, stated, context);
 
         if (statementValidates) {
@@ -143,11 +143,11 @@ class StatementPass extends ForwardPass {
 const termPass = new TermPass(),
       statementPass = new StatementPass();
 
-export function validateTerm(termNode, context) {
+export function validateTerm(termNode, context, validateForwards) {
   let termValidates = false;
 
   const node = termNode, ///
-        sucess = termPass.run(node, context);
+        sucess = termPass.run(node, context, validateForwards);
 
   if (sucess) {
     termValidates = true;

package/src/process/verify.js

@@ -295,8 +295,8 @@ class ConbinatorPass extends SimplePass {
         let success = false;
 
         const statement = statementFromStatementNode(statementNode, context),
-              assignments = null,
               stated = false,
+              assignments = null,
               statementValidates = statement.validate(assignments, stated, context);
 
         if (statementValidates) {

package/src/ruleNames.js

@@ -76,6 +76,7 @@ export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
 export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const STATEMENT_SUBSTITUTION_RULE_NAME = "statementSubstitution";
+export const REFERENCE_SUBSTITUTION_RULE_NAME = "referenceSubstitution";
 export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
 export const TYPE_PREFIX_DECLARATION_RULE_NAME = "typePrefixDeclaration";
 export const SIMPLE_TYPE_DECLARATION_RULE_NAME = "simpleTypeDeclaration";

package/src/utilities/element.js

@@ -7,6 +7,7 @@ import { baseTypeFromNothing } from "../utilities/type";
 import { instantiateReference } from "../process/instantiate";
 import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { equivalenceStringFromTerms,
+         typeStringFromNominalTypeName,
          rulsStringFromLabelsPremisesAndConclusion,
          sectionStringFromHypothesesTopLevelAssertion,
          subproofStringFromSuppositionsAndSubDerivation,
@@ -23,16 +24,15 @@ export function typeFromTypeNode(typeNode, context) {
     type = baseType;  ///
   } else {
     const { Type } = elements,
-          typeName = typeNode.getTypeName(),
-          typePrefixName = typeNode.getTypePrefixName(),
-          nominalTypeName = typeNode.getNominalTypeName(),
-          string = nominalTypeName,  ///
           node = typeNode,  ///
-          name = typeName,  ///
-          prefixName = typePrefixName,  ///
-          superTypes = null,
-          properties = null,
-          provisional = null;
+          name = nameFromTypeNode(typeNode, context),
+          prefixName = prefixNameFromTypeNode(typeNode, context),
+          superTypes = superTypesFromTypeNode(typeNode, context),
+          properties = propertiesFromTypeNode(typeNode, context),
+          provisional = provisionalFromTypeNode(typeNode, context),
+          nominalTypeName = nominalTypeNameFromTypeNode(typeNode, context),
+          typeString = typeStringFromNominalTypeName(nominalTypeName),
+          string = typeString;  ///
 
     type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
   }
@@ -195,7 +195,7 @@ export function theoremFromTheoremNode(theoremNode, context) {
 
 export function metaTypeFromMetaTypeNode(metaTypeNode, context) {
   const metaTypeName = metaTypeNode.getMetaTypeName(),
-        metaType = findMetaTypeByMetaTypeName(metaTypeName);
+        metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
 
   return metaType;
 }
@@ -236,21 +236,15 @@ export function subproofFromSubproofNode(subproofNode, context) {
   return subproof;
 }
 
-export function equalityFromStatementNode(statementNode, context) {
-  let equality = null;
-
-  const equalityNode = statementNode.getEqualityNode();
-
-  if (equalityNode !== null) {
-    const node = equalityNode,  ///
-          string = context.nodeAsString(node),
-          leftTerm = leftTermFromEqualityNode(equalityNode, context),
-          rightTerm = rightTermFromEqualityNode(equalityNode, context);
-
-    equality = new Equality(context, string, node, leftTerm, rightTerm);
-  }
+export function equalityFromEqualityNode(equalityNode, context) {
+  const { Equality } = elements,
+        node = equalityNode, ///
+        string = context.nodeAsString(node),
+        leftTerm = leftTermFromEqualityNode(equalityNode, context),
+        rightTerm = rightTermFromEqualityNode(equalityNode, context),
+        subproof = new Equality(context, string, node, leftTerm, rightTerm);
 
-  return equality;
+  return subproof;
 }
 
 export function deductionFromDeductionNode(deductionNode, context) {
@@ -713,6 +707,13 @@ export function metavariableDeclarationFromMetavariableDeclarationNode(metavaria
   return metavariableDeclaration;
 }
 
+export function nameFromTypeNode(typeNode, context) {
+  const typeName = typeNode.getTypeName(),
+    name = typeName;  ///
+
+  return name;
+}
+
 export function typeFromTermNode(termNode, context) {
   const type = null;
 
@@ -793,6 +794,25 @@ export function referenceFromStepNode(stepNode, context) {
   return reference;
 }
 
+export function superTypesFromTypeNode(typeNode, context) {
+  const superTypes = null;
+
+  return superTypes;
+}
+
+export function propertiesFromTypeNode(typeNode, context) {
+  const properties = null;
+
+  return properties;
+}
+
+export function prefixNameFromTypeNode(typeNode, context) {
+  const typePrefixName = typeNode.getTypePrefixName(),
+    prefixName = typePrefixName;  ///
+
+  return prefixName;
+}
+
 export function conclusionFromRuleNode(ruleNode, context) {
   const conclusionNode = ruleNode.getConclusionNode(),
         conclusion = conclusionFromConclusionNode(conclusionNode, context);
@@ -833,6 +853,12 @@ export function derivationFromProofNode(proofNode, context) {
   return derivation;
 }
 
+export function provisionalFromTypeNode(typeNode, context) {
+  const provisional = null;
+
+  return provisional;
+}
+
 export function termFromConstructorNode(ocnstructorNode, context) {
   const termNode = ocnstructorNode.getTermNode(),
         term = termFromTermNode(termNode, context);
@@ -859,6 +885,13 @@ export function statementFromPremiseNode(premiseNode, context) {
   return statement;
 }
 
+export function leftTermFromEqualityNode(equalityNode, context) {
+  const leftTermNode = equalityNode.getLeftTermNode(),
+        leftTerm = termFromTermNode(leftTermNode, context);
+
+  return leftTerm;
+}
+
 export function termsFromEquivalenceNode(equivalenceNode, context) {
   const termNodes = equivalenceNode.getTermNodes(),
         terms = termsFromTermNodes(termNodes, context);
@@ -897,6 +930,25 @@ export function conjectureFromSectionNode(sectionNode, context) {
   return conjecture;
 }
 
+export function rightTermFromEqualityNode(equalityNode, context) {
+  const rightTermNode = equalityNode.getRightTermNode(),
+        rightTerm = termFromTermNode(rightTermNode, context);
+
+  return rightTerm;
+}
+
+export function equalityFromStatementNode(statementNode, context) {
+  let equality = null;
+
+  const equalityNode = statementNode.getEqualityNode();
+
+  if (equalityNode !== null) {
+    equality = equalityFromEqualityNode(equalityNode, context);
+  }
+
+  return equality;
+}
+
 export function termFromTypeAssertionNode(typeAssertionNode, context) {
   const termNode = typeAssertionNode.getTermNode(),
         term = termFromTermNode(termNode, context);
@@ -956,6 +1008,12 @@ export function stepFromStepOrSubproofNode(stepOrSubproofNode, context) {
   return step;
 }
 
+export function nominalTypeNameFromTypeNode(typeNode, context) {
+  const nominalTypeName = typeNode.getNominalTypeName();
+
+  return nominalTypeName;
+}
+
 export function assumptionFromJudgementNode(judgementNode, context) {
   const assumptionNode = judgementNode.getAssumptionNode(),
         assumption = assumptionFromAssumptionNode(assumptionNode, context);
@@ -1543,7 +1601,7 @@ export function termSubstitutionFromStatementSubstitutionNode(statementSubstitut
   const termSubstitutionNode = statementSubstitutionNode.getTermSubstitutionNode();
 
   if (termSubstitutionNode !== null) {
-    termSubstitution = termSubstitutionFromTermubstitutionNode(termSubstitutionNode, context);
+    termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
   }
 
   return termSubstitution;
@@ -1676,4 +1734,3 @@ export function stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context
 
   return stepsOrSubproofs;
 }
-

package/src/utilities/json.js

@@ -44,7 +44,7 @@ export function metaTypeFromJSON(json, context) {
     const { name } = json,
           metaTypeName = name;  ///
 
-    metaType = findMetaTypeByMetaTypeName(metaTypeName);
+    metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
   }
 
   return metaType;

package/src/utilities/string.js

@@ -16,20 +16,6 @@ export function termsStringFromTerms(terms) {
   return termsString;
 }
 
-export function framesStringFromFrames(frames) {
-  const framesString = frames.reduce((framesString, frame) => {
-    const frameString = frame.getString();
-
-    framesString = (framesString !== null) ?
-                    `${framesString}, ${frameString}` :
-                       frameString;
-
-    return framesString;
-  }, null);
-
-  return framesString;
-}
-
 export function labelsStringFromLabels(labels) {
   const labelsString = labels.reduce((labelsString, label) => {
     const labelString = label.getString();
@@ -131,20 +117,6 @@ export function suppositionsStringFromSuppositions(suppositions) {
   return suppositionsString;
 }
 
-export function substitutionsStringFromSubstitutions(substitutions) {
-  const substitutionsString = substitutions.reduce((substitutionsString, substitution) => {
-    const substitutionString = substitution.getString();
-
-    substitutionsString = (substitutionsString === null) ?
-                             substitutionString : ///
-                              `${substitutionsString}, ${substitutionString}`;
-
-    return substitutionsString;
-  }, null);
-
-  return substitutionsString;
-}
-
 export function signatureStringFromTerms(terms) {
   const termsString = termsStringFromTerms(terms),
         signatureString = `[${termsString}]`;
@@ -154,11 +126,17 @@ export function signatureStringFromTerms(terms) {
 
 export function equivalenceStringFromTerms(terms) {
   const termsString = termsStringFromTerms(terms),
-        equivalenceString = termsString;  ///
+        equivalenceString = `[${termsString}]`;
 
   return equivalenceString;
 }
 
+export function typeStringFromNominalTypeName(nominalTypeName) {
+  const typeString = nominalTypeName;  ///
+
+  return typeString;
+}
+
 export function termSubstitutionStringFromTermAndVariable(term, variable) {
   const termString = term.getString(),
         variableString = variable.getString(),

package/src/utilities/substitutions.js

@@ -13,17 +13,13 @@ export function termFromTermAndSubstitutions(term, generalContext, specificConte
 
     if (termSingular) {
       const variableIdentifier = termNode.getVariableIdentifier(),
-            variable = generalContext.findVariableByVariableIdentifier(variableIdentifier);
+            substitution = specificContext.findSubstitutionByVariableIdentifier(variableIdentifier);
 
-      if (variable !== null) {
-        const substitution = specificContext.findSubstitutionByVariableIdentifier(variableIdentifier);
+      if (substitution !== null) {
+        const termSubstitution = substitution,  ///
+              replacementTerm = termSubstitution.getReplacementTerm();
 
-        if (substitution !== null) {
-          const termSubstitution = substitution,  ///
-                replacementTerm = termSubstitution.getReplacementTerm();
-
-          term = replacementTerm; ///
-        }
+        term = replacementTerm; ///
       }
     }
   }
@@ -40,17 +36,13 @@ export function frameFromFrameAndSubstitutions(frame, generalContext, specificCo
 
     if (frameSingular) {
       const metavariableName = frameNode.getMetavariableName(),
-            metavariable = generalContext.findMetavariableByMetavariableName(metavariableName);
-
-      if (metavariable !== null) {
-        const substitution = specificContext.findSubstitutionByMetavariableName(metavariableName);
+            substitution = specificContext.findSubstitutionByMetavariableName(metavariableName);
 
-        if (substitution !== null) {
-          const frameSubstitution = substitution, ///
-                replacementFrame = frameSubstitution.getReplacementFrame();
+      if (substitution !== null) {
+        const frameSubstitution = substitution, ///
+              replacementFrame = frameSubstitution.getReplacementFrame();
 
-          frame = replacementFrame; ///
-        }
+        frame = replacementFrame; ///
       }
     }
   }
@@ -86,20 +78,17 @@ export function statementFromStatementAndSubstitutions(statement, generalContext
         specificContext = context;  ///
       }
 
-      const metavariableName = statementNode.getMetavariableName(),
-            metavariable = generalContext.findMetavariableByMetavariableName(metavariableName);
+      const metavariableName = statementNode.getMetavariableName();
 
-      if (metavariable !== null) {
-        substitution = (substitution !== null) ?
-                         specificContext.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) :
-                           specificContext.findSubstitutionByMetavariableName(metavariableName);
+      substitution = (substitution !== null) ?
+                       specificContext.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) :
+                         specificContext.findSubstitutionByMetavariableName(metavariableName);
 
-        if (substitution !== null) {
-          const statementSubstitution = substitution, ///
-                replacementStatement = statementSubstitution.getReplacementStatement();
+      if (substitution !== null) {
+        const statementSubstitution = substitution, ///
+              replacementStatement = statementSubstitution.getReplacementStatement();
 
-          statement = replacementStatement; ///
-        }
+        statement = replacementStatement; ///
       }
     }
   }

package/src/utilities/validation.js

@@ -31,9 +31,9 @@ function validateTermAsVariable(term, context, validateForwards) {
 
       term.setType(type);
 
-      const verifiesForwards = validateForwards();
+      const validatesForwards = validateForwards();
 
-      if (verifiesForwards) {
+      if (validatesForwards) {
         termValidatesAsVariable = true;
       }
     }