occam-verify-cli 1.0.427 → 1.0.436

package/src/utilities/instance.js

@@ -0,0 +1,53 @@
+"use strict";
+
+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";
+
+let bracketedConstructorTerm = null,
+    bracketedCombinatorStatement = null;
+
+export function bracketedConstructorTermFromNothing() {
+  if (bracketedConstructorTerm === null) {
+    let context;
+
+    const string = `(${BASE_TYPE_SYMBOL})`;
+
+    context = nominalContext; ///
+
+    const node = instantiateTerm(string, context),
+          bracketedConstructorTermNode = node;  ///
+
+    context = {
+      nodeAsString: () => string
+    };
+
+    bracketedConstructorTerm = termFromTermNode(bracketedConstructorTermNode, context);
+  }
+
+  return bracketedConstructorTerm;
+}
+
+export function bracketedCombinatorStatementFromNothing() {
+  if (bracketedCombinatorStatement === null) {
+    let context;
+
+    const string = `(${STATEMENT_META_TYPE_NAME})`;
+
+    context = nominalContext; ///
+
+    const node = instantiateStatement(string, context),
+          bracketedCombinatorStatementNode = node;  ///
+
+    context = {
+      nodeAsString: () => string
+    };
+
+    bracketedCombinatorStatement = statementFromStatementNode(bracketedCombinatorStatementNode, context);
+  }
+
+  return bracketedCombinatorStatement;
+}

package/src/utilities/string.js

@@ -30,19 +30,32 @@ export function labelsStringFromLabels(labels) {
   return labelsString;
 }
 
-export function signatureStringFromTerms(terms) {
-  const termsString = termsStringFromTerms(terms),
-        signatureString = `[${termsString}]`;
+export function premisesStringFromPremises(premises) {
+  const premisesString = premises.reduce((premisesString, premise) => {
+    const premiseString = premise.getString();
 
-  return signatureString;
+    premisesString = (premisesString !== null) ?
+                       `${premisesString}, ${premiseString}` :
+                         premiseString;  ///
+
+    return premisesString;
+  }, null);
+
+  return premisesString;
 }
 
-export function subproofStringFromSubproof(subproof) {
-  const suppositionStatementsOrNonsenseString = suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, context),
-        lastStatementOrNonsenseString = lastStatementOrNonsenseStringFromSubproofNode(subproofNode, context),
-        subproofString = `[${suppositionStatementsOrNonsenseString}] ... ${lastStatementOrNonsenseString}`;
+export function hypothesesStringFromHypotheses(hypotheses, context) {
+  const hypothesesString = hypotheses.reduce((hypothesesString, hypothesis) => {
+    const hypothesisString = hypothesis.getString();
 
-  return subproofString;
+    hypothesesString = (hypothesesString !== null) ?
+                          `${hypothesesString}, ${hypothesisString}` :
+                            hypothesisString;  ///
+
+    return hypothesesString;
+  }, null);
+
+  return hypothesesString;
 }
 
 export function superTypesStringFromSuperTypes(superTypes) {
@@ -61,13 +74,41 @@ export function superTypesStringFromSuperTypes(superTypes) {
   return superTypesString;
 }
 
+export function parametersStringFromParameters(parameters) {
+  const parametersString = parameters.reduce((parametersString, parameter) => {
+    const parameterString = parameter.getString();
+
+    parametersString = (parametersString === null) ?
+                         parameterString : ///
+                          `${parametersString}, ${parameterString}`;
+
+    return parametersString;
+  }, null);
+
+  return parametersString;
+}
+
+export function assumptionsStringFromAssumptions(assumptions) {
+  const assumptionsString = assumptions.reduce((assumptionsString, assumption) => {
+    const assumptionString = assumption.getString();
+
+    assumptionsString = (assumptionsString === null) ?
+                          assumptionString :
+                            `${assumptionsString}, ${assumptionString}`;
+
+    return assumptionsString;
+  }, null);
+
+  return assumptionsString;
+}
+
 export function suppositionsStringFromSuppositions(suppositions) {
   const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
     const suppositionString = supposition.getString();
 
-    suppositionsString = (suppositionsString !== null) ?
-                          `${suppositionsString}, ${suppositionString}` :
-                            suppositionString;  ///
+    suppositionsString = (suppositionsString === null) ?
+                           suppositionString: ///
+                            `${suppositionsString}, ${suppositionString}`;
 
     return suppositionsString;
   }, null);
@@ -75,6 +116,41 @@ export function suppositionsStringFromSuppositions(suppositions) {
   return suppositionsString;
 }
 
+export function signatureStringFromTerms(terms) {
+  const termsString = termsStringFromTerms(terms),
+        signatureString = `[${termsString}]`;
+
+  return signatureString;
+}
+
+export function equivalenceStringFromTerms(terms) {
+  const termsString = termsStringFromTerms(terms),
+        equivalenceString = termsString;  ///
+
+  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(),
+        labelsString = labelsStringFromLabels(labels),
+        ruleString = (premisesString !== null) ?
+                       `${labelsString} :: [${premisesString}] ... ${conclusionString}` :
+                         `${labelsString} :: ${conclusionString}`;
+
+  return ruleString;
+}
+
 export function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {
   let typeString;
 
@@ -91,6 +167,36 @@ export function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, type
   return typeString;
 }
 
+export function procedureCallStringFromProcedureReferenceAndParameters(procedureReference, parameters) {
+  const procedureReferenceName = procedureReference.getName(),
+        parametersString = parametersStringFromParameters(parameters),
+        procedureCallString = `${procedureReferenceName}(${parametersString})`;
+
+  return procedureCallString;
+}
+
+export function sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context) {
+  const axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture),
+        axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString(),
+        hypothesesString = hypothesesStringFromHypotheses(hypotheses, context),
+        sectionString = (axiomLemmaTheoremOrConjectureString !== null) ?
+                          `[${hypothesesString}]::: ${axiomLemmaTheoremOrConjectureString}` :
+                            `[${hypothesesString}]::: `;
+
+  return sectionString;
+}
+
+export function metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction) {
+  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        deductionString = deduction.getString(),
+        labelString = label.getString(),
+        metaLemmaMetatheoremString = (suppositionsString !== null) ?
+                                       `${labelString} :: [${suppositionsString}] ... ${deductionString}` :
+                                         `${labelString} :: ${deductionString}`;
+
+  return metaLemmaMetatheoremString;
+}
+
 export function axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction) {
   let axiomLemmaTheoremConjectureString;
 
@@ -110,50 +216,3 @@ export function axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduct
 
   return axiomLemmaTheoremConjectureString;
 }
-
-function suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, context) {
-  const suppositionNodes = subproofNode.getSuppositionNodes(),
-        suppositionStatementsOrNonsenseString = suppositionNodes.reduce((suppositionStatementsOrNonsenseString, suppositionNode) => {
-          const suppositionOrStepNode = suppositionNode,  ///
-                statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context),
-                suppositionStatementOrNonsenseString = statementOrNonsenseString; ///
-
-          suppositionStatementsOrNonsenseString = (suppositionStatementsOrNonsenseString !== null) ?
-                                                    `${suppositionStatementsOrNonsenseString}, ${suppositionStatementOrNonsenseString}` :
-                                                      suppositionStatementOrNonsenseString; ///
-
-          return suppositionStatementsOrNonsenseString;
-        }, null);
-
-  return suppositionStatementsOrNonsenseString;
-}
-
-function statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context) {
-  let statementOrNonsenseString;
-
-  const nonsenseNode = suppositionOrStepNode.getNonsenseNode(),
-        statementNode = suppositionOrStepNode.getStatementNode();
-
-  if (false) {
-    ///
-  } else if (nonsenseNode !== null) {
-    const nonsenseString = context.nodeAsString(nonsenseNode);
-
-    statementOrNonsenseString = nonsenseString; ///
-  } else if (statementNode !== null) {
-    const statementString = context.nodeAsString(statementNode);
-
-    statementOrNonsenseString = statementString;  ///
-  }
-
-  return statementOrNonsenseString;
-}
-
-function lastStatementOrNonsenseStringFromSubproofNode(subproofNode, context) {
-  const lastStepNode = subproofNode.getLastStepNode(),
-        suppositionOrStepNode = lastStepNode, ///
-        statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context),
-        lastStatementOrNonsenseString = statementOrNonsenseString; ///
-
-  return lastStatementOrNonsenseString;
-}