occam-verify-cli 1.0.983 → 1.0.985

package/src/utilities/string.js

@@ -1,282 +0,0 @@
-"use strict";
-
-import { baseTypeFromNothing } from "../utilities/type";
-import { EMPTY_STRING, PROVISIONAL, PROVISIONALLY } from "../constants";
-
-export function termsStringFromTerms(terms) {
-  const termsString = terms.reduce((termsString, term) => {
-    const termString = term.getString();
-
-    termsString = (termsString !== null) ?
-                   `${termsString}, ${termString}` :
-                      termString;
-
-    return termsString;
-  }, null);
-
-  return termsString;
-}
-
-export function labelsStringFromLabels(labels) {
-  const labelsString = labels.reduce((labelsString, label) => {
-    const labelString = label.getString();
-
-    labelsString = (labelsString === null) ?
-                     labelString: ///
-                      `${labelsString}, ${labelString}`;
-
-    return labelsString;
-  }, null);
-
-  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) {
-  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) {
-  let superTypesString;
-
-  const baseType = baseTypeFromNothing();
-
-  superTypesString = superTypes.reduce((superTypesString, superType) => {
-    if (superType !== baseType) {
-      const superTypeString = superType.getString();
-
-      superTypesString = (superTypesString === null) ?
-                           `'${superTypeString}'` :
-                              `${superTypesString}, '${superTypeString}'`;
-    }
-
-    return superTypesString;
-  }, null);
-
-  superTypesString = (superTypesString !== null) ?
-                       `:${superTypesString}` :
-                          EMPTY_STRING;
-
-  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 provisinalStringFromProvisional(provisional) {
-  const provisinalString = provisional ?
-                            `${PROVISIONAL} ` :
-                              EMPTY_STRING;
-
-  return provisinalString;
-}
-
-export function provisionallyStringFromProvisional(provisional) {
-  const provisinallyString = provisional ?
-                              ` ${PROVISIONALLY}` :
-                                 EMPTY_STRING;
-
-  return provisinallyString;
-}
-
-export function suppositionsStringFromSuppositions(suppositions) {
-  const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
-    const suppositionString = supposition.getString();
-
-    suppositionsString = (suppositionsString === null) ?
-      suppositionString: ///
-      `${suppositionsString}, ${suppositionString}`;
-
-    return suppositionsString;
-  }, null);
-
-  return suppositionsString;
-}
-
-export function equivalenceStringFromTerms(terms) {
-  const termsString = termsStringFromTerms(terms),
-        equivalenceString = `[${termsString}]`;
-
-  return equivalenceString;
-}
-
-export function signatureStringFromSignature(signature) {
-  const signatureString = (signature !== null) ?
-                            signature.getString() :
-                              null;
-
-  return signatureString;
-}
-
-export function typeStringFromNominalTypeName(nominalTypeName) {
-  const typeString = nominalTypeName;  ///
-
-  return typeString;
-}
-
-export function termSubstitutionStringFromTermAndVariable(term, variable) {
-  const termString = term.getString(),
-        variableString = variable.getString(),
-        termSubstitutionString = `[${termString} for ${variableString}]`;
-
-  return termSubstitutionString;
-}
-
-export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
-  let ruleString = EMPTY_STRING;
-
-  const conclusionString = conclusion.getString(),
-        premisesString = premisesStringFromPremises(premises),
-        labelsString = labelsStringFromLabels(labels);
-
-  ruleString = `${ruleString}${labelsString} :: `;
-
-  ruleString = (premisesString !== null) ?
-                 `${ruleString}[${premisesString}]...${conclusionString}` :
-                   `${ruleString}${conclusionString}`;
-
-  return ruleString;
-}
-
-export function subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation) {
-  const lastStep = subDerivation.getLastStep(),
-        suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        lastStepString = lastStep.getString(),
-        subproofString = `[${suppositionsString}]...${lastStepString}`;
-
-  return subproofString;
-}
-
-export function frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable) {
-  const frameString = frame.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${frameString} for [${metavariableString}]]`;
-
-  return string;
-}
-
-export function sectionStringFromHypothesesAndTopLevelAssertion(hypotheses, topLevelAssertion) {
-  const topLevelAssertionString = topLevelAssertion.getString(),
-        hypothesesString = hypothesesStringFromHypotheses(hypotheses),
-        sectionString = `[${hypothesesString}]::: ${topLevelAssertionString}`;
-
-  return sectionString;
-}
-
-export function metaLevelAssumptionStringFromReferenceAndStatement(reference, statement) {
-  const statementString = statement.getString(),
-        referneceString = reference.getString(),
-        metaLevelAssumptionString = `${referneceString} :: ${statementString}`;
-
-  return metaLevelAssumptionString;
-}
-
-export function procedureCallStringFromProcedureReferenceAndParameters(procedureReference, parameters) {
-  const procedureReferenceName = procedureReference.getName(),
-        parametersString = parametersStringFromParameters(parameters),
-        procedureCallString = `@${procedureReferenceName}(${parametersString})`;
-
-  return procedureCallString;
-}
-
-export function statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        statementSubstitutionString = `[${statementString} for ${metavariableString}]`;
-
-  return statementSubstitutionString;
-}
-
-export function referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable) {
-  const referenceString = reference.getString(),
-        metavariableString = metavariable.getString(),
-        referenceSubstitutionString = `[${referenceString} for ${metavariableString}]`;
-
-  return referenceSubstitutionString;
-}
-
-export function complexTypeDeclarationStringFromTypeSuperTypesAndProvisional(type, superTypes, provisional) {
-  const typeString = type.getString(),
-        superTypesString = superTypesStringFromSuperTypes(superTypes),
-        provisionalString = provisinalStringFromProvisional(provisional),
-        complexTypeDeclarationString = `${provisionalString}${typeString}${superTypesString}`;
-
-  return complexTypeDeclarationString;
-}
-
-export function topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction) {
-  const labelString = label.getString(),
-        deductionString = deduction.getString(),
-        suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        topLevelMetaAssertionString = (suppositionsString !== null) ?
-                                       `${labelString} :: [${suppositionsString}]...${deductionString}` :
-                                         `${labelString} :: ${deductionString}`;
-
-  return topLevelMetaAssertionString;
-}
-
-export function topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeduction(labels, signature, suppositions, deduction) {
-  let topLevelAssertionString = EMPTY_STRING;
-
-  const deductionString = deduction.getString(),
-        labelsString = labelsStringFromLabels(labels),
-        signatureString = signatureStringFromSignature(signature),
-        suppositionsString = suppositionsStringFromSuppositions(suppositions);
-
-  topLevelAssertionString = (labelsString !== null) ?
-                             `${topLevelAssertionString}${labelsString}` :
-                               `${topLevelAssertionString}`;
-  topLevelAssertionString = (signatureString !== null) ?
-                             `${topLevelAssertionString}${signatureString}` :
-                               `${topLevelAssertionString}`;
-
-
-  topLevelAssertionString = (suppositionsString !== null) ?
-                             `${topLevelAssertionString} :: [${suppositionsString}]...${deductionString}` :
-                               `${topLevelAssertionString} :: ${deductionString}`;
-
-  return topLevelAssertionString;
-}
-
-export function statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        substitutionString = substitution.getString(),
-        statementSubstitutionString = `[${statementString} for ${metavariableString}${substitutionString}]`;
-
-  return statementSubstitutionString;
-}

package/src/utilities/substitutions.js

@@ -1,93 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-const { compress } = arrayUtilities;
-
-export function termFromTermAndSubstitutions(term, context) {
-  if (term !== null) {
-    const termNode = term.getNode(),
-          termSingular = term.isSingular();
-
-    term = null;  ///
-
-    if (termSingular) {
-      const variableNode = termNode.getVariableNode(),
-            derivedSubstitution = context.findDerivedSubstitutionByVariableNode(variableNode);
-
-      if (derivedSubstitution !== null) {
-        const replacementTerm = derivedSubstitution.getReplacementTerm();
-
-        term = replacementTerm; ///
-      }
-    }
-  }
-
-  return term;
-}
-
-export function frameFromFrameAndSubstitutions(frame, context) {
-  if (frame !== null) {
-    const frameNode = frame.getNode(),
-          frameSingular = frame.isSingular();
-
-    frame = null;  ///
-
-    if (frameSingular) {
-      const metavariableNode = frameNode.getMetavariableNode(),
-            derivedSubstitution = context.findDerivedSubstitutionByMetavariableNode(metavariableNode);
-
-      if (derivedSubstitution !== null) {
-        const replacementFrame = derivedSubstitution.getReplacementFrame();
-
-        frame = replacementFrame; ///
-      }
-    }
-  }
-
-  return frame;
-}
-
-export function statementFromStatementAndSubstitutions(statement, context) {
-  if (statement !== null) {
-    const statementNode = statement.getNode(),
-          statementSingular = statement.isSingular();
-
-    statement = null;  ///
-
-    if (statementSingular) {
-      const metavariableNode = statementNode.getMetavariableNode(),
-            derivedSubstitution = context.findDerivedSubstitutionByMetavariableNode(metavariableNode);
-
-      if (derivedSubstitution !== null) {
-        const replacementStatement = derivedSubstitution.getReplacementStatement();
-
-        statement = replacementStatement; ///
-      }
-    }
-  }
-
-  return statement;
-}
-
-export function metavariableNodesFromDerivedSubstitutions(derivedSubstitutions) {
-  const metavariableNodes = [];
-
-  derivedSubstitutions.forEach((derivedSubstitution) => {
-    const metavariableNode = derivedSubstitution.getMetavariableNode();
-
-    if (metavariableNode !== null) {
-      metavariableNodes.push(metavariableNode);
-    }
-  });
-
-  compress(metavariableNodes, (metavariableNodeA, metavariableNodeB) => {
-    const metavariableNodeAMatchesetavariableNodeB = metavariableNodeA.match(metavariableNodeB);
-
-    if (!metavariableNodeAMatchesetavariableNodeB) {
-      return true;
-    }
-  });
-
-  return metavariableNodes;
-}

package/src/utilities/synoptic.js

@@ -1,135 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-const { compress } = arrayUtilities;
-
-export function compressTerms(terms) {
-  compress(terms, (termA, termB) => {
-    const termAEqualToTermB = termA.isEqualTo(termB);
-
-    if (!termAEqualToTermB) {
-      return true;
-    }
-  });
-}
-
-export function compressFrames(frames) {
-  compress(frames, (frameA, frameB) => {
-    const frameAEqualToFrameB = frameA.isEqualTo(frameB);
-
-    if (!frameAEqualToFrameB) {
-      return true;
-    }
-  });
-}
-
-export function compressProperties(properties) {
-  compress(properties, (propertyA, propertyB) => {
-    const propertyAEqualToPropertyB = propertyA.isEqualTo(propertyB);
-
-    if (!propertyAEqualToPropertyB) {
-      return true;
-    }
-  });
-}
-
-export function compressEqualities(equalities) {
-  compress(equalities, (equalityA, equalityB) => {
-    const equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
-
-    if (!equalityAEqualToEqualityB) {
-      return true;
-    }
-  });
-}
-
-export function compressJudgements(judgements) {
-  compress(judgements, (judgementA, judgementB) => {
-    const judgementAEqualToJudgementB = judgementA.isEqualTo(judgementB);
-
-    if (!judgementAEqualToJudgementB) {
-      return true;
-    }
-  });
-}
-
-export function compressAssertions(assertions) {
-  compress(assertions, (assertionA, assertionB) => {
-    const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
-
-    if (!assertionAEqualToAssertionB) {
-      return true;
-    }
-  });
-}
-
-export function compressStatements(statements) {
-  compress(statements, (statementA, statementB) => {
-    const statementAEqualToStatementB = statementA.isEqualTo(statementB);
-
-    if (!statementAEqualToStatementB) {
-      return true;
-    }
-  });
-}
-
-export function compressSignatures(signatures) {
-  compress(signatures, (signatureA, signatureB) => {
-    const signatureAEqualToSignatureB = signatureA.isEqualTo(signatureB);
-
-    if (!signatureAEqualToSignatureB) {
-      return true;
-    }
-  });
-}
-
-export function compressReferences(references) {
-  compress(references, (referenceA, referenceB) => {
-    const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
-
-    if (!referenceAEqualToReferenceB) {
-      return true;
-    }
-  });
-}
-
-export function compressAssumptions(assumptions) {
-  compress(assumptions, (assumptionA, assumptionB) => {
-    const assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
-
-    if (!assumptionAEqualToAssumptionB) {
-      return true;
-    }
-  });
-}
-
-export function compressMetavariables(metavariables) {
-  compress(metavariables, (metavariableA, metavariableB) => {
-    const metavariableAEqualToMetavariableB = metavariableA.isEqualTo(metavariableB);
-
-    if (!metavariableAEqualToMetavariableB) {
-      return true;
-    }
-  });
-}
-
-export function compressSubstitutions(substitutions) {
-  compress(substitutions, (substitutionA, substitutionB) => {
-    const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
-
-    if (!substitutionAEqualToSubstitutionB) {
-      return true;
-    }
-  });
-}
-
-export function compressPropertyRelations(propertyRelations) {
-  compress(propertyRelations, (propertyRelationA, propertyRelationB) => {
-    const propertyRelationAEqualToPropertyRelationB = propertyRelationA.isEqualTo(propertyRelationB);
-
-    if (!propertyRelationAEqualToPropertyRelationB) {
-      return true;
-    }
-  });
-}

package/src/utilities/type.js

@@ -1,19 +0,0 @@
-"use strict";
-
-import elements from "../elements";
-
-import { BASE_TYPE_SYMBOL } from "../constants";
-
-let baseType = null;
-
-export function baseTypeFromNothing() {
-  if (baseType === null) {
-    const { Type } = elements,
-          name = BASE_TYPE_SYMBOL,  ///
-          context = null;
-
-    baseType = Type.fromName(name, context);
-  }
-
-  return baseType;
-}