occam-verify-cli 1.0.617 → 1.0.631

package/src/element/substitution.js

@@ -6,12 +6,6 @@ import { primitiveUtilities } from "occam-furtle";
 const { primitiveFromNode } =primitiveUtilities;
 
 export default class Substitution extends Element {
-  getSubstitution() {
-    const substitution = null;
-
-    return substitution;
-  }
-
   getPrimitive() {
     const context = this.getContext(),
           replacementNode = this.getReplacementNode(),
@@ -28,18 +22,6 @@ export default class Substitution extends Element {
     return substitutionNode;
   }
 
-  getNetavariableName() {
-    const metavariableName = null;
-
-    return metavariableName;
-  }
-
-  getVariableIdentifier() {
-    const variableIdentifier = null;
-
-    return variableIdentifier;
-  }
-
   matchSubstitutionNode(substitutionNode) {
     const substitutionNodeA = substitutionNode; ///
 
@@ -68,12 +50,6 @@ export default class Substitution extends Element {
     return equalTo;
   }
 
-  isSimple() {
-    const simple = true;
-
-    return simple;
-  }
-
   isComplex() {
     const simple = this.isSimple(),
           complex = !simple;
@@ -81,12 +57,6 @@ export default class Substitution extends Element {
     return complex;
   }
 
-  isTrivial() {
-    const trivial = false;
-
-    return trivial;
-  }
-
   isNonTrivial() {
     const trivial = this.isTrivial(),
           nonTrivlal = !trivial;
@@ -94,22 +64,64 @@ export default class Substitution extends Element {
     return nonTrivlal;
   }
 
+  getVariable() {
+    const variable = null;
+
+    return variable;
+  }
+
+  getSubstitution() {
+    const substitution = null;
+
+    return substitution;
+  }
+
+  getMetavariable() {
+    const metavariable = null;
+
+    return metavariable;
+  }
+
+  getMetavariableName() {
+    const metavariableName = null;
+
+    return metavariableName;
+  }
+
+  getVariableIdentifier() {
+    const variableIdentifier = null;
+
+    return variableIdentifier;
+  }
+
+  isSimple() {
+    const simple = true;
+
+    return simple;
+  }
+
+  isTermEqualToTerm(term) {
+    const termEqualToTerm = false;
+
+    return termEqualToTerm;
+  }
+
   isFrameEqualToFrame(frame) {
     const frameEqualToFrame = false;
 
     return frameEqualToFrame;
   }
 
-  isReferenceEqualToReference(reference) {
-    const referenceEqualToReference = false;
+  isStatementEqualToStatement(statement) {
+    const statementEqualToStatement = false;
 
-    return referenceEqualToReference;
+    return statementEqualToStatement;
   }
 
-  compare(substitution) {
-    const comparesToSubstitution = false;
+  isReferenceEqualToReference(reference) {
+    const referenceEqualToReference = false;
 
-    return comparesToSubstitution;
+    return referenceEqualToReference;
   }
 
   compareTerm(term, context) {
@@ -136,6 +148,18 @@ export default class Substitution extends Element {
     return compaaresToMetavariable;
   }
 
+  compareMetavariableName(metavariableName) {
+    const comparesToMetavariableName = false;
+
+    return comparesToMetavariableName;
+  }
+
+  compareVariableIdentifier(variableIdentifier) {
+    const comparesToVariableIdentifier = false;
+
+    return comparesToVariableIdentifier;
+  }
+
   resolve(substitutions, generalContext, specificContext) {
     const resolved = true;
 

package/src/element/term.js

@@ -44,12 +44,30 @@ export default define(class Term extends Element {
     termNode = this.getTermNode();
 
     const termNodeB = termNode, ///
-      termNodeAAMatchesTermBNodeB = termNodeA.match(termNodeB),
-      equalTo = termNodeAAMatchesTermBNodeB; ///
+          termNodeAAMatchesTermBNodeB = termNodeA.match(termNodeB),
+          equalTo = termNodeAAMatchesTermBNodeB; ///
 
     return equalTo;
   }
 
+  compareVariableIdentifier(variableIdentifier) {
+    let comparesToVariableIdentifier = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const variableIdentifierA = variableIdentifier; ///
+
+      variableIdentifier = this.getVariableIdentifier();
+
+      const variableIdentifierB = variableIdentifier;
+
+      comparesToVariableIdentifier = (variableIdentifierA === variableIdentifierB);
+    }
+
+    return comparesToVariableIdentifier;
+  }
+
   isValid(context) {
     const termNode = this.getTermNode(),
           termPresent = context.isTermPresentByTermNode(termNode),

package/src/element/topLevelAssertion.js

@@ -255,15 +255,13 @@ export default class TopLevelAssertion extends Element {
             suppositionVerifies = await supposition.verify(assignments, context)
 
       if (suppositionVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const subproofOrProofAssertion = supposition;  ////
+        const subproofOrProofAssertion = supposition;  ////
 
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });
 

package/src/element/topLevelMetaAssertion.js

@@ -159,15 +159,13 @@ export default class TopLevelMetaAssertion extends Element {
             suppositionVerifies = await supposition.verify(assignments, context)
 
       if (suppositionVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const subproofOrProofAssertion = supposition;  ////
+        const subproofOrProofAssertion = supposition;  ////
 
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });
 

package/src/element/variable.js

@@ -2,6 +2,8 @@
 
 import { Element } from "occam-languages";
 
+import elements from "../elements";
+
 import { define } from "../elements";
 import { typeToTypeJSON } from "../utilities/json";
 

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

@@ -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) {

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/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;