occam-verify-cli 1.0.438 → 1.0.444

package/src/utilities/element.js

@@ -2,11 +2,11 @@
 
 import elements from "../elements";
 
-import { baseType } from "../element/type";
+import { baseTypeFromNothing } from "../types";
 import { instantiateReference } from "../process/instantiate";
 import { equivalenceStringFromTerms,
-         subproofStringFromSubproofNode,
          rulsStringFromLabelsPremisesAndConclusion,
+         subproofStringFromSuppositionsAndSubDerivation,
          procedureCallStringFromProcedureReferenceAndParameters,
          sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture,
          metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction,
@@ -16,7 +16,9 @@ export function typeFromTypeNode(typeNode, context) {
   let type;
 
   if (typeNode === null) {
-    type = baseType;
+    const baseType = baseTypeFromNothing();
+
+    type = baseType;  ///
   } else {
     const { Type } = elements,
           typeName = typeNode.getTypeName(),
@@ -240,13 +242,13 @@ export function variableFromVariableNode(variableNode, context) {
 }
 
 export function subproofFromSubproofNode(subproofNode, context) {
-  const { SubProof } = elements,
+  const { Subproof } = elements,
         node = subproofNode, ///
         suppositions = suppositionsFromSubproofNode(subproofNode, context),
         subDerivation = subDerivationFromSubproofNode(subproofNode, context),
-        subproofString = subproofStringFromSubproofNode(subproofNode, context),
+        subproofString = subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation, context),
         string = subproofString,  ///
-        subproof = new SubProof(context, string, node, suppositions, subDerivation);
+        subproof = new Subproof(context, string, node, suppositions, subDerivation);
 
   return subproof;
 }
@@ -310,23 +312,6 @@ export function referenceFromReferenceNode(referenceNode, context) {
   return reference;
 }
 
-export function conjectureroConjectureNode(conjectureNode, context) {
-  const { Conjecture } = elements,
-        axiomLemmaTheoremConjectureNode = conjectureNode,  ///
-        proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        hypotheses = [],
-        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-        node = conjectureNode, ///
-        string = axiomLemmaTheoremConjectureString, ///
-        conjecture = new Conjecture(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
-
-  return conjecture;
-}
-
 export function judgementFromJudgementNode(judgementNode, context) {
   const { Judgement } = elements,
         node = judgementNode, ///
@@ -374,6 +359,33 @@ export function hypothesisFromHypothesisNode(hypotheseNode, context) {
   return parameter;
 }
 
+export function conjectureFromConjectureNode(conjectureNode, context) {
+  const { Conjecture } = elements,
+        axiomLemmaTheoremConjectureNode = conjectureNode,  ///
+        proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        hypotheses = [],
+        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        node = conjectureNode, ///
+        string = axiomLemmaTheoremConjectureString, ///
+        conjecture = new Conjecture(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
+
+  return conjecture;
+}
+
+export function combinatorFromCombinatorNode(combinatorNode, context) {
+  const { Combinator } = elements,
+        node = combinatorNode, ///
+        string = context.nodeAsString(node),
+        statement = statementFromCombinatorNode(combinatorNode, context),
+        combinator = new Combinator(context, string, node, statement);
+
+  return combinator;
+}
+
 export function conclusionFromConclusionNode(conclusionNode, context) {
   const { Conclusion } = elements,
         node = conclusionNode, ///
@@ -461,6 +473,16 @@ export function hyppothesisFromHypothesisNode(hypothesisNode, context) {
   return hypothesis
 }
 
+export function constructorFromConstructorNode(constructorNode, context) {
+  const { Constructor } = elements,
+        node = constructorNode, ///
+        string = context.nodeAsString(node),
+        term = termFromConstructorNode(constructorNode, context),
+        constructor = new Constructor(context, string, node, term);
+
+  return constructor;
+}
+
 export function suppositionFromSuppositionNode(suppositionNode, context) {
   const { Supposition } = elements,
         node = suppositionNode, ///
@@ -702,8 +724,8 @@ export function statementSubstitutionFromStatementSubstitutionNode(statementSubs
         node = statementSubstitutionNode,  ///
         string = context.nodeAsString(node),
         resolved = true,
-        statement = statementFromStatementSubstitutionNode(statementSubstitutionNode, context),
-        metavariable = metavariableFromStatementSubstitutionNode(statementSubstitutionNode, context),
+        statement = null,
+        metavariable = null,
         substitution = null,
         statementSubstitution = new StatementSubstitution(context, string, node, resolved, statement, metavariable, substitution);
 
@@ -876,6 +898,18 @@ export function derivationFromProofNode(proofNode, context) {
   return derivation;
 }
 
+export function termFromConstructorNode(ocnstructorNode, context) {
+  let term = null;
+
+  const termNode = ocnstructorNode.getTermNode();
+
+  if (termNode !== null) {
+    term = termFromTermNode(termNode, context);
+  }
+
+  return term;
+}
+
 export function statementFromPremiseNode(premiseNode, context) {
   let statement = null;
 
@@ -924,18 +958,6 @@ export function conclusionFromPremiseNode(premiseNode, context) {
   return conclusion;
 }
 
-export function judgementFomStatementNode(statementNode, context) {
-  let judgement = null;
-
-  const judgementNode = statementNode.getJudgementNode();
-
-  if (judgementNode !== null) {
-    judgement = judgementFromJudgementNode(judgementNode, context);
-  }
-
-  return judgement;
-}
-
 export function termFromTypeAssertionNode(typeAssertionNode, context) {
   let term = null;
 
@@ -991,6 +1013,18 @@ export function statementFromDeductionNode(deductionNode, context) {
   return statement;
 }
 
+export function judgementFromStatementNode(statementNode, context) {
+  let judgement = null;
+
+  const judgementNode = statementNode.getJudgementNode();
+
+  if (judgementNode !== null) {
+    judgement = judgementFromJudgementNode(judgementNode, context);
+  }
+
+  return judgement;
+}
+
 export function stepFromStepOrSubproofNode(stepOrSubproofNode, context) {
   let step = null;
 
@@ -1005,6 +1039,18 @@ export function stepFromStepOrSubproofNode(stepOrSubproofNode, context) {
   return step;
 }
 
+export function statementFromCombinatorNode(combinatorNode, context) {
+  let statement = null;
+
+  const statementNode = combinatorNode.getStatementNode();
+
+  if (statementNode !== null) {
+    statement = statementFromStatementNode(statementNode, context);
+  }
+
+  return statement;
+}
+
 export function statementFromConclusionNode(conclusinoNode, context) {
   let statement = null;
 
@@ -1149,18 +1195,6 @@ export function subDerivationFromSubproofNode(subproofNode, context) {
   return subDerviation;
 }
 
-export function typeAssertinFromStatementNode(statementNode, context) {
-  let typeAssertion = null;
-
-  const typeAssertionNode = statementNode.getTypeAssertionNode();
-
-  if (typeAssertionNode !== null) {
-    typeAssertion = typeAssertionFromTypeAssertionNode(typeAssertionNode, context);
-  }
-
-  return typeAssertion;
-}
-
 export function metavariableFromReferenceNode(referenceNode, context) {
   let metavariable = null;
 
@@ -1215,6 +1249,18 @@ export function parameterNameFromParameterNode(parameterNode, context) {
   return parameterName;
 }
 
+export function typeAssertionFromStatementNode(statementNode, context) {
+  let typeAssertion = null;
+
+  const typeAssertionNode = statementNode.getTypeAssertionNode();
+
+  if (typeAssertionNode !== null) {
+    typeAssertion = typeAssertionFromTypeAssertionNode(typeAssertionNode, context);
+  }
+
+  return typeAssertion;
+}
+
 export function metavariableFromAssumptionNode(assumptionNode, context) {
   let metavariable = null;
 
@@ -1301,6 +1347,18 @@ export function frameFromContainedAssertionNode(containedAssertionNode, context)
   return frame;
 }
 
+export function procedureCallFromSuppositionNode(suppositionNode, context) {
+  let procedureCall = null;
+
+  const procedureCallNode = suppositionNode.getProcedureCallNode();
+
+  if (procedureCallNode !== null) {
+    procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
+  }
+
+  return procedureCall;
+}
+
 export function propertyFromPropertyRelationNode(propertyRelationNode, context) {
   let property = null;
 
@@ -1325,18 +1383,6 @@ export function variableFromTermSubstitutionNode(termSubstitutionNode, context)
   return variable;
 }
 
-export function procedureCallFromSuppositionNode(suppositionNode, context) {
-  let procedureCall = null;
-
-  const procedureCallNode = suppositionNode.getProcedureCallNode();
-
-  if (procedureCallNode !== null) {
-    procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
-  }
-
-  return procedureCall;
-}
-
 export function definedAssertionFromStatementNode(statementNode, context) {
   let definedAssertion = null;
 
@@ -1476,7 +1522,9 @@ export function typeFromConstructorDeclarationNode(constructorDeclarationNode, c
   if (typeNode !== null) {
     type = typeFromTypeNode(typeNode, context);
   } else {
-    type = baseType;
+    const baseType = baseTypeFromNothing();
+
+    type = baseType;  ///
   }
 
   return type;
@@ -1664,13 +1712,10 @@ export function typePrefixFromTypePrefixDeclarationNode(typePrefixDeclarationNod
 export function combinatorFromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
   let combinator = null;
 
-  const statementNode = combinatorDeclarationNode.getStatementNode();
+  const combinatorNode = combinatorDeclarationNode.getCombinatorNode();
 
-  if (statementNode !== null) {
-    const { Combinator } = elements,
-      statement = statementFromStatementNode(statementNode, context);
-
-    combinator = new Combinator(statement);
+  if (combinatorNode !== null) {
+    combinator = combinatorFromCombinatorNode(combinatorNode, context);
   }
 
   return combinator;
@@ -1715,13 +1760,10 @@ export function propertyRelationFromPropertyAssertionNode(propertyAssertionNode,
 export function constructorFromConstructorDeclarationNode(constructorDeclarationNode, context) {
   let constructor = null;
 
-  const termNode = constructorDeclarationNode.getStatementNode();
+  const constructorNode = constructorDeclarationNode.getConstructorNode();
 
-  if (termNode !== null) {
-    const { Constructor } = elements,
-          term = termFromTermNode(termNode, context);
-
-    constructor = new Constructor(term);
+  if (constructorNode !== null) {
+    constructor = constructorFromConstructorNode(constructorNode, context);
   }
 
   return constructor;
@@ -1838,7 +1880,8 @@ export function superTypesFromSuperTypeNodes(superTypeNodes, context) {
         superTypesLength = superTypes.length;
 
   if (superTypesLength === 0) {
-    const superType = baseType; ///
+    const baseType = baseTypeFromNothing(),
+          superType = baseType; ///
 
     superTypes.push(superType);
   }
@@ -1952,6 +1995,13 @@ export function statementsFromSubproofAssertionNode(subproofAssertionNode, conte
   return statements;
 }
 
+export function suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+  const suppositionNodes = metaLemmaMetathoremNode.getSuppositionNodes(),
+        suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
+
+  return suppositions;
+}
+
 export function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
   const propertyDeclarationNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(),
         properties = propertiesFromPropertyDeclarationNodes(propertyDeclarationNodes, context);
@@ -1966,13 +2016,6 @@ export function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationN
   return superTypes;
 }
 
-export function suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
-  const suppositionNodes = metaLemmaMetathoremNode.getSuppositionNodes(),
-        suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
-
-  return suppositions;
-}
-
 export function labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
   const labelNodes = axiomLemmaTheoremConjectureNode.getLabelNodes(),
         labels = labelsFromLabelNodes(labelNodes, context);

package/src/utilities/instance.js

@@ -4,50 +4,50 @@ import nominalContext from "../context/nominal";
 
 import { BASE_TYPE_SYMBOL } from "../constants";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
-import { instantiateTerm, instantiateStatement } from "../process/instantiate";
-import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
+import { instantiateCombinator, instantiateConstructor } from "../process/instantiate";
+import { combinatorFromCombinatorNode, constructorFromConstructorNode } from "../utilities/element";
 
-let bracketedConstructorTerm = null,
-    bracketedCombinatorStatement = null;
+let bracketedCombinator = null,
+    bracketedConstructor = null;
 
-export function bracketedConstructorTermFromNothing() {
-  if (bracketedConstructorTerm === null) {
+export function bracketedCombinatorFromNothing() {
+  if (bracketedCombinator === null) {
     let context;
 
-    const string = `(${BASE_TYPE_SYMBOL})`;
+    const string = `(${STATEMENT_META_TYPE_NAME})`;
 
     context = nominalContext; ///
 
-    const node = instantiateTerm(string, context),
-          bracketedConstructorTermNode = node;  ///
+    const combinatorNode = instantiateCombinator(string, context),
+          bracketedCombinatorNode = combinatorNode;  ///
 
     context = {
       nodeAsString: () => string
     };
 
-    bracketedConstructorTerm = termFromTermNode(bracketedConstructorTermNode, context);
+    bracketedCombinator = combinatorFromCombinatorNode(bracketedCombinatorNode, context);
   }
 
-  return bracketedConstructorTerm;
+  return bracketedCombinator;
 }
 
-export function bracketedCombinatorStatementFromNothing() {
-  if (bracketedCombinatorStatement === null) {
+export function bracketedConstructorFromNothing() {
+  if (bracketedConstructor === null) {
     let context;
 
-    const string = `(${STATEMENT_META_TYPE_NAME})`;
+    const string = `(${BASE_TYPE_SYMBOL})`;
 
     context = nominalContext; ///
 
-    const node = instantiateStatement(string, context),
-          bracketedCombinatorStatementNode = node;  ///
+    const constructorNode = instantiateConstructor(string, context),
+          bracketedConstructorNode = constructorNode;  ///
 
     context = {
       nodeAsString: () => string
     };
 
-    bracketedCombinatorStatement = statementFromStatementNode(bracketedCombinatorStatementNode, context);
+    bracketedConstructor = constructorFromConstructorNode(bracketedConstructorNode, context);
   }
 
-  return bracketedCombinatorStatement;
+  return bracketedConstructor;
 }

package/src/utilities/statement.js

@@ -4,7 +4,7 @@ import { equalityFromStatementNode,
          judgementFromStatementNode,
          metavariableFromStatementNode,
          typeAssertionFromStatementNode,
-         dDefinedAssertionFromStatementNode,
+         definedAssertionFromStatementNode,
          propertyAssertionFromStatementNode,
          subproofAssertionFromStatementNode,
          containedAssertionFromStatementNode,
@@ -40,7 +40,7 @@ export function typeAssertionFromStatement(statement, context) {
 
 export function definedAssertionFromStatement(statement, context) {
   const statementNode = statement.getNode(),
-        definedAssertion = dDefinedAssertionFromStatementNode(statementNode, context);
+        definedAssertion = definedAssertionFromStatementNode(statementNode, context);
 
   return definedAssertion;
 }

package/src/utilities/string.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { baseType } from "../element/type";
+import { baseTypeFromNothing } from "../types";
 
 export function termsStringFromTerms(terms) {
   const termsString = terms.reduce((termsString, term) => {
@@ -59,17 +59,18 @@ export function hypothesesStringFromHypotheses(hypotheses, context) {
 }
 
 export function superTypesStringFromSuperTypes(superTypes) {
-  const superTypesString = superTypes.reduce((superTypesString, superType) => {
-    if (superType !== baseType) {
-      const superTypeString = superType.getString();
+  const baseType = baseTypeFromNothing(),
+        superTypesString = superTypes.reduce((superTypesString, superType) => {
+          if (superType !== baseType) {
+            const superTypeString = superType.getString();
 
-      superTypesString = (superTypesString === null) ?
-                           `'${superTypeString}'` :
-                             `${superTypesString}, '${superTypeString}'`;
-    }
+            superTypesString = (superTypesString === null) ?
+                                 `'${superTypeString}'` :
+                                   `${superTypesString}, '${superTypeString}'`;
+          }
 
-    return superTypesString;
-  }, null);
+          return superTypesString;
+        }, null);
 
   return superTypesString;
 }
@@ -116,6 +117,20 @@ 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}]`;
@@ -130,16 +145,6 @@ export function equivalenceStringFromTerms(terms) {
   return equivalenceString;
 }
 
-export function subproofStringFromSubproof(subproof) {
-  const lastStep = subproof.getLastStep(),
-        suppositions = subproof.getSuppositions(),
-        lastStepString = lastStep.getString(),
-        suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        subproofString = `[${suppositionsString}] ... ${lastStepString}`;
-
-  return subproofString;
-}
-
 export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
   const premisesString = premisesStringFromPremises(premises),
         conclusionString = conclusion.getString(),
@@ -151,6 +156,15 @@ export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conc
   return ruleString;
 }
 
+export function subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation) {
+  const lastStep = subDerivation.getLastStep(),
+        lastStepString = lastStep.getString(),
+        suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        subproofString = `[${suppositionsString}] ... ${lastStepString}`;
+
+  return subproofString;
+}
+
 export function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {
   let typeString;