occam-verify-cli 1.0.448 → 1.0.457

package/src/utilities/string.js

@@ -156,6 +156,17 @@ export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conc
   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 lastProofAssertion = subDerivation.getLastProofAssertion(),
         suppositionsString = suppositionsStringFromSuppositions(suppositions),
@@ -165,6 +176,14 @@ export function subproofStringFromSuppositionsAndSubDerivation(suppositions, sub
   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

@@ -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,25 +135,25 @@ 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 subproofOrProofAssertions = context.getSubproofOrProofAssertions();
 
       substitutions = Substitutions.fromNothing();
 
-      const statementAndSubproofOrProofAssertionsUnify = axiomLemmaTheoremOrConjecture.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, substitutions, context);
+      const statementAndSubproofOrProofAssertionsUnify = topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, substitutions, context);
 
       if (statementAndSubproofOrProofAssertionsUnify) {
         const { StatementSubstitution } = elements,
@@ -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) {
@@ -334,7 +334,7 @@ export const unifyStatements = [
   unifyStatementWithRule,
   unifyStatementWithReference,
   unifyStatementAsSatisfiesAssertion,
-  unifyStatementWithAxiomLemmaTheoremOrConjecture,
+  unifyStatementWithTopLevelAssertion,
   unifyStatementAEquality,
   unifyStatementAsJudgement,
   unifyStatementAsTypeAssertion,

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;