occam-verify-cli 1.0.428 → 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,6 +30,34 @@ export function labelsStringFromLabels(labels) {
   return labelsString;
 }
 
+export function premisesStringFromPremises(premises) {
+  const premisesString = premises.reduce((premisesString, premise) => {
+    const premiseString = premise.getString();
+
+    premisesString = (premisesString !== null) ?
+                       `${premisesString}, ${premiseString}` :
+                         premiseString;  ///
+
+    return premisesString;
+  }, null);
+
+  return premisesString;
+}
+
+export function hypothesesStringFromHypotheses(hypotheses, context) {
+  const hypothesesString = hypotheses.reduce((hypothesesString, hypothesis) => {
+    const hypothesisString = hypothesis.getString();
+
+    hypothesesString = (hypothesesString !== null) ?
+                          `${hypothesesString}, ${hypothesisString}` :
+                            hypothesisString;  ///
+
+    return hypothesesString;
+  }, null);
+
+  return hypothesesString;
+}
+
 export function superTypesStringFromSuperTypes(superTypes) {
   const superTypesString = superTypes.reduce((superTypesString, superType) => {
     if (superType !== baseType) {
@@ -46,6 +74,34 @@ 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();
@@ -84,6 +140,17 @@ export function subproofStringFromSubproof(subproof) {
   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;
 
@@ -100,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;