occam-verify-cli 1.0.444 → 1.0.457

package/src/utilities/string.js

@@ -150,21 +150,40 @@ export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conc
         conclusionString = conclusion.getString(),
         labelsString = labelsStringFromLabels(labels),
         ruleString = (premisesString !== null) ?
-                       `${labelsString} :: [${premisesString}] ... ${conclusionString}` :
+                       `${labelsString} :: [${premisesString}]...${conclusionString}` :
                          `${labelsString} :: ${conclusionString}`;
 
   return ruleString;
 }
 
+export function sectionStringFromHypothesesTopLevelAssertion(hypotheses, axiom, lemma, theorem, conjecture, context) {
+  const topLevelAssertion = (axiom || lemma || theorem || conjecture),
+        topLevelAssertionString = topLevelAssertion.getString(),
+        hypothesesString = hypothesesStringFromHypotheses(hypotheses, context),
+        sectionString = (topLevelAssertionString !== null) ?
+                          `[${hypothesesString}]::: ${topLevelAssertionString}` :
+                            `[${hypothesesString}]::: `;
+
+  return sectionString;
+}
+
 export function subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation) {
-  const lastStep = subDerivation.getLastStep(),
-        lastStepString = lastStep.getString(),
+  const lastProofAssertion = subDerivation.getLastProofAssertion(),
         suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        subproofString = `[${suppositionsString}] ... ${lastStepString}`;
+        lastProofAssertionString = lastProofAssertion.getString(),
+        subproofString = `[${suppositionsString}]...${lastProofAssertionString}`;
 
   return subproofString;
 }
 
+export function frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable) {
+  const frameString = frame.getString(),
+        metavariableString = metavariable.getString(),
+        string = `[${frameString} for [${metavariableString}]]`;
+
+  return string;
+}
+
 export function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {
   let typeString;
 
@@ -189,44 +208,50 @@ export function procedureCallStringFromProcedureReferenceAndParameters(procedure
   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}]::: `;
+export function statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable) {
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString(),
+        statementSubstitutionString = `[${statementString} for ${metavariableString}]`;
 
-  return sectionString;
+  return statementSubstitutionString;
 }
 
-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;
+export function topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction) {
+  let topLevelAssertionString;
 
   const suppositionsString = suppositionsStringFromSuppositions(suppositions),
         deductionString = deduction.getString(),
         labelsString = labelsStringFromLabels(labels);
 
   if (labelsString !== null) {
-    axiomLemmaTheoremConjectureString = (suppositionsString !== null) ?
-                                          `${labelsString} :: [${suppositionsString}] ... ${deductionString}` :
-                                            `${labelsString} :: ${deductionString}`;
+    topLevelAssertionString = (suppositionsString !== null) ?
+                               `${labelsString} :: [${suppositionsString}]...${deductionString}` :
+                                 `${labelsString} :: ${deductionString}`;
   } else {
-    axiomLemmaTheoremConjectureString = (suppositionsString !== null) ?
-                                         `[${suppositionsString}] ... ${deductionString}` :
-                                            deductionString;
+    topLevelAssertionString = (suppositionsString !== null) ?
+                               `[${suppositionsString}]...${deductionString}` :
+                                  deductionString;
   }
 
-  return axiomLemmaTheoremConjectureString;
+  return topLevelAssertionString;
+}
+
+export function topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction) {
+  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        deductionString = deduction.getString(),
+        labelString = label.getString(),
+        topLevelMetaAssertionString = (suppositionsString !== null) ?
+                                       `${labelString} :: [${suppositionsString}]...${deductionString}` :
+                                         `${labelString} :: ${deductionString}`;
+
+  return topLevelMetaAssertionString;
+}
+
+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/unification.js

@@ -24,10 +24,10 @@ function unifyStatementWithRule(statement, reference, satisfiesAssertion, substi
 
       context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule...`);
 
-      const stepsOrSubproofs = context.getStepsOrSubproofs(),
-            statementAndStepsUnify = rule.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
+      const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
+            statementAndSubproofOrProofAssertionsUnify = rule.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
 
-      if (statementAndStepsUnify) {
+      if (statementAndSubproofOrProofAssertionsUnify) {
         statementUnifiesWithRule = true;
       }
 
@@ -44,14 +44,14 @@ function unifyStatementWithReference(statement, reference, satisfiesAssertion, s
   let statementUnifiesWithReference = false;
 
   if (reference !== null) {
-    const metavariableVerifies = reference.verifyMetavariable(context);
+    const statementString = statement.getString(),
+          referenceString = reference.getString();
 
-    if (metavariableVerifies) {
-      const statementString = statement.getString(),
-            referenceString = reference.getString();
+    context.trace(`Unifying the '${statementString}' statement with the '${referenceString}' reference...`);
 
-      context.trace(`Unifying the '${statementString}' statement with the '${referenceString}' reference...`);
+    const metavariableValidates = reference.validateMetavariable(context);
 
+    if (metavariableValidates) {
       const { StatementSubstitution } = elements,
             metavariable = reference.getMetavariable(),
             statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
@@ -60,10 +60,10 @@ function unifyStatementWithReference(statement, reference, satisfiesAssertion, s
       substitutions.addSubstitution(substitution, context);
 
       statementUnifiesWithReference = true;
+    }
 
-      if (statementUnifiesWithReference) {
-        context.debug(`...unified the '${statementString}' statement with the '${referenceString}' reference.`);
-      }
+    if (statementUnifiesWithReference) {
+      context.debug(`...unified the '${statementString}' statement with the '${referenceString}' reference.`);
     }
   }
 
@@ -86,9 +86,9 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
     satisfiesAssertion.verifySignature(assignments, stated, context);
 
     if (reference === null) {
-      const stepsOrSubproofs = context.getStepsOrSubproofs();
+      const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
 
-      statementUnifiesAsSatisfiesAssertion = backwardsSome(stepsOrSubproofs, (stepsOrSubproof) => {
+      statementUnifiesAsSatisfiesAssertion = backwardsSome(subproofOrProofAssertions, (stepsOrSubproof) => {
         const stepOrSubProofUnifiesWIthSatisfiesAssertion = stepsOrSubproof.unifyWithSatisfiesAssertion(satisfiesAssertion, context);
 
         if (stepOrSubProofUnifiesWIthSatisfiesAssertion) {
@@ -96,9 +96,9 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
         }
       });
     } else {
-      const axiomLemmaTheoremOrConjecture = context.findAxiomLemmaTheoremOrConjectureByReference(reference);
+      const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
-      if (axiomLemmaTheoremOrConjecture !== null) {
+      if (topLevelAssertion !== null) {
         reference = satisfiesAssertion.getReference();
 
         const axiom = context.findAxiomByReference(reference);
@@ -109,9 +109,9 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
           if (satisfiable) {
             const { Substitutions } = elements,
                   substitutions = Substitutions.fromNothing(),
-                  axiomLemmaTheoremOrConjectureUnifies = axiom.unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context);
+                  topLevelAssertionUnifies = axiom.unifyTopLevelAssertion(topLevelAssertion, substitutions, context);
 
-            if (axiomLemmaTheoremOrConjectureUnifies) {
+            if (topLevelAssertionUnifies) {
               const substitutionsCorrelates = satisfiesAssertion.correlateSubstitutions(substitutions, context);
 
               if (substitutionsCorrelates) {
@@ -135,27 +135,27 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
   return statementUnifiesAsSatisfiesAssertion;
 }
 
-function unifyStatementWithAxiomLemmaTheoremOrConjecture(statement, reference, satisfiesAssertion, substitutions, context) {
-  let statementUnifiesWithAxiomLemmaTheoremOrConjecture = false;
+function unifyStatementWithTopLevelAssertion(statement, reference, satisfiesAssertion, substitutions, context) {
+  let statementUnifiesWithTopLevelAssertion = false;
 
   if (reference !== null) {
     const { Substitutions } = elements,
-          axiomLemmaTheoremOrConjecture = context.findAxiomLemmaTheoremOrConjectureByReference(reference),
+          topLevelAssertion = context.findTopLevelAssertionByReference(reference),
           generalSubstitutions = substitutions; ///
 
-    if (axiomLemmaTheoremOrConjecture !== null) {
+    if (topLevelAssertion !== null) {
       const statementString = statement.getString(),
-            axiomLemmaTheoremOrConjectureString = reference.getString();
+            topLevelAssertionString = reference.getString();
 
-      context.trace(`Unifying the '${statementString}' statement with the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture...`);
+      context.trace(`Unifying the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion...`);
 
-      const stepsOrSubproofs = context.getStepsOrSubproofs();
+      const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
 
       substitutions = Substitutions.fromNothing();
 
-      const statementAndStepsUnify = axiomLemmaTheoremOrConjecture.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
+      const statementAndSubproofOrProofAssertionsUnify = topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, substitutions, context);
 
-      if (statementAndStepsUnify) {
+      if (statementAndSubproofOrProofAssertionsUnify) {
         const { StatementSubstitution } = elements,
               metavariable = reference.getMetavariable(),
               statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
@@ -165,16 +165,16 @@ function unifyStatementWithAxiomLemmaTheoremOrConjecture(statement, reference, s
 
         substitutions.addSubstitution(substitution, context);
 
-        statementUnifiesWithAxiomLemmaTheoremOrConjecture = true;
+        statementUnifiesWithTopLevelAssertion = true;
       }
 
-      if (statementUnifiesWithAxiomLemmaTheoremOrConjecture) {
-        context.debug(`...unified the '${statementString}' statement with the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture.`);
+      if (statementUnifiesWithTopLevelAssertion) {
+        context.debug(`...unified the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion.`);
       }
     }
   }
 
-  return statementUnifiesWithAxiomLemmaTheoremOrConjecture;
+  return statementUnifiesWithTopLevelAssertion;
 }
 
 function unifyStatementAEquality(statement, reference, satisfiesAssertion, substitutions, context) {
@@ -292,8 +292,8 @@ function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAss
 
     context.trace(`Unifying the '${statementString}' statememnt with the '${satisfiesAssertionString}' satisfies assertion...`);
 
-    const stepsOrSubproofs = context.getStepsOrSubproofs(),
-          statementUnifies = satisfiesAssertion.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
+    const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
+          statementUnifies = satisfiesAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
 
     if (statementUnifies) {
       statementUnifiesWithSatisfiesAssertion = true;
@@ -307,23 +307,23 @@ function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAss
   return statementUnifiesWithSatisfiesAssertion;
 }
 
-function compareStatementWithStepsOrSubproofs(statement, reference, satisfiesAssertion, substitutions, context) {
+function compareStatementWithSubproofOrProofAssertions(statement, reference, satisfiesAssertion, substitutions, context) {
   let statementEquatesWithStepOrSubproofs = false;
 
   if (reference === null) {
     const statementString = statement.getString();
 
-    context.trace(`Comparing the '${statementString}' statement with the steps or subproofs...`);
+    context.trace(`Comparing the '${statementString}' statement with the subproofs or proof asssertions...`);
 
-    const stepsOrSubproofs = context.getStepsOrSubproofs(),
-          statementUnifiesWithSteps = statement.compareStepsOrSubproofs(stepsOrSubproofs, context);
+    const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
+          statementUnifiesWithSteps = statement.compareSubproofOrProofAssertions(subproofOrProofAssertions, context);
 
     if (statementUnifiesWithSteps) {
       statementEquatesWithStepOrSubproofs = true;
     }
 
     if (statementEquatesWithStepOrSubproofs) {
-      context.debug(`...compared the '${statementString}' statement with the steps or subproofs.`);
+      context.debug(`...compared the '${statementString}' statement with the subproofs or proof asssertions.`);
     }
   }
 
@@ -334,11 +334,11 @@ export const unifyStatements = [
   unifyStatementWithRule,
   unifyStatementWithReference,
   unifyStatementAsSatisfiesAssertion,
-  unifyStatementWithAxiomLemmaTheoremOrConjecture,
+  unifyStatementWithTopLevelAssertion,
   unifyStatementAEquality,
   unifyStatementAsJudgement,
   unifyStatementAsTypeAssertion,
   unifyStatementAsPropertyAssertion,
   unifyStatementWithSatisfiesAssertion,
-  compareStatementWithStepsOrSubproofs
+  compareStatementWithSubproofOrProofAssertions
 ];

package/src/utilities/validation.js

@@ -2,9 +2,9 @@
 
 import elements from "../elements";
 
+import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
 import { equalityFromStatement,
          judgementFromStatement,
-         metavariableFromStatement,
          typeAssertionFromStatement,
          definedAssertionFromStatement,
          propertyAssertionFromStatement,
@@ -15,8 +15,7 @@ import { equalityFromStatement,
 function unifyTermWithBracketedConstructor(term, context, validateAhead) {
   let termUnifiesWithBracketedConstructor;
 
-  const { BracketedConstructor } = elements,
-    bracketedConstructor = BracketedConstructor.fromNothing();
+  const bracketedConstructor = bracketedConstructorFromNothing();
 
   termUnifiesWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, validateAhead);
 
@@ -42,40 +41,31 @@ function unifyTermWithConstructors(term, context, validateAhead) {
 function validateTermAsVariable(term, context, validateAhead) {
   let termValidatesAsVariable = false;
 
-  const { Variable } = elements,
-    termNode = term.getNode(),
-    singularVariableNode = termNode.getSingularVariableNode();
+  const termNode = term.getNode(),
+        variableNode = termNode.getVariableNode();
 
-  if (singularVariableNode !== null) {
-    let variable;
+  if (variableNode !== null) {
+    const termString = term.getString();
 
-    const termString = term.getString(),
-      variableNode = singularVariableNode;  ///
+    context.trace(`Validating the '${termString}' term as a variable...`);
 
-    variable = Variable.fromVariableNode(variableNode, context);
-
-    context.trace(`Verifying the '${termString}' term as a variable...`);
-
-    const variableValidates = variable.validate(context);
-
-    if (variableValidates) {
-      let verifiesAhead;
-
-      const variableIdentifier = variable.getIdentifier();
-
-      variable = context.findVariableByVariableIdentifier(variableIdentifier);
+    const variableIdentifier = variableNode.getVariableIdentifier(),
+          variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
+    if (variable !== null) {
       const type = variable.getType();
 
       term.setType(type);
 
-      verifiesAhead = validateAhead();
+      const verifiesAhead = validateAhead();
 
-      termValidatesAsVariable = verifiesAhead; ///
+      if (verifiesAhead) {
+        termValidatesAsVariable = true;
+      }
     }
 
     if (termValidatesAsVariable) {
-      context.debug(`...verified the '${termString}' term as a variable.`);
+      context.debug(`...validated the '${termString}' term as a variable.`);
     }
   }
 
@@ -85,16 +75,20 @@ function validateTermAsVariable(term, context, validateAhead) {
 function validateStatementAsMetavariableAndSubstitution(statement, assignments, stated, context) {
   let statementValidatesAsMetavariableAndSubstitution = false;
 
-  const metavariable = metavariableFromStatement(statement, context);
+  const statementNode = statement.getNode(),
+        metavariableNode = statementNode.getMetavariableNode();
 
-  if (metavariable !== null) {
+  if (metavariableNode !== null) {
     const statementString = statement.getString();
 
     context.trace(`Validating the '${statementString}' statement as a metavariable and substitution...`);
 
-    const metavariableValidates = metavariable.validate(context);
+    const metavariableName = metavariableNode.getMetavariableName(),
+          metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+    if (metavariable !== null) {
+      statementValidatesAsMetavariableAndSubstitution = true;
 
-    if (metavariableValidates) {
       const { TermSubstitution, FrameSubstitution } = elements,
             frameSubstitution = FrameSubstitution.fromStatement(statement, context),
             termSubstitution = TermSubstitution.fromStatement(statement, context),
@@ -103,11 +97,9 @@ function validateStatementAsMetavariableAndSubstitution(statement, assignments,
       if (substitution !== null) {
         const substitutionValidates = substitution.validate(context);
 
-        if (substitutionValidates) {
-          statementValidatesAsMetavariableAndSubstitution = true;
+        if (!substitutionValidates) {
+          statementValidatesAsMetavariableAndSubstitution = false;
         }
-      } else {
-        statementValidatesAsMetavariableAndSubstitution = true;
       }
     }
 
@@ -124,8 +116,7 @@ function unifyStatementWithBracketedCombinator(statement, assignments, stated, c
 
   assignments = null; ///
 
-  const { BracketedCombinator } = elements,
-        bracketedCombinator = BracketedCombinator.fromNothing(),
+  const bracketedCombinator = bracketedCombinatorFromNothing(),
         statementUnifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
 
   return statementUnifiesWithBracketedCombinator;