occam-verify-cli 1.0.792 → 1.0.799

package/src/utilities/context.js

@@ -114,14 +114,14 @@ export function unserialise(innerFunction, json, context) {
   return innerFunction(json, context);
 }
 
-export async function asyncRestrict(innerFunction, assumptions, context) {
+export async function asyncRestrict(innerFunction, metaLevelAssumptions, context) {
   if (context === undefined) {
-    context = assumptions;  ///
+    context = metaLevelAssumptions;  ///
 
-    assumptions = null;
+    metaLevelAssumptions = null;
   }
 
-  const proofContext = ProofContext.fromAssumptions(assumptions, context);
+  const proofContext = ProofContext.fromMetaLevelAssumptions(metaLevelAssumptions, context);
 
   context = proofContext;  ///
 

package/src/utilities/element.js

@@ -10,7 +10,7 @@ import { equivalenceStringFromTerms,
          subproofStringFromSuppositionsAndSubDerivation,
          procedureCallStringFromProcedureReferenceAndParameters,
          topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
-         topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
+         topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions } from "../utilities/string";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -210,13 +210,6 @@ export function theoremFromTheoremNode(theoremNode, context) {
   return theorem;
 }
 
-export function metaTypeFromMetaTypeNode(metaTypeNode, context) {
-  const metaTypeName = metaTypeNode.getMetaTypeName(),
-        metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
-
-  return metaType;
-}
-
 export function propertyFromPropertyNode(propertyNode, context) {
   const { Property } = elements,
         node = propertyNode, ///
@@ -346,11 +339,11 @@ export function metaLemmaFromMetaLemmaNode(metaLemmaNode, context) {
         label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        assumptions = assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
+        metaLevelAssumptions = metaLevelAssumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions(label, suppositions, deduction, metaLevelAssumptions),
         node = metaLemmaMetathoremNode, ///
         string = topLevelMetaAssertionString, ///
-        metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, assumptions);
+        metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, metaLevelAssumptions);
 
   return metaLemma;
 }
@@ -467,11 +460,8 @@ export function assumptionFromAssumptionNode(assumptionNode, context) {
         node = assumptionNode,  ///
         string = context.nodeAsString(node),
         reference = referenceFromAssumptionNode(assumptionNode, context),
-        statement = statementFromAssumptionNode(assumptionNode, context);
-
-  context = null;
-
-  const assumption = new Assumption(context, string, node, reference, statement);
+        statement = statementFromAssumptionNode(assumptionNode, context),
+        assumption = new Assumption(context, string, node, reference, statement);
 
   return assumption;
 }
@@ -523,11 +513,11 @@ export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
         label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        assumptions = assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
+        metaLevelAssumptions = metaLevelAssumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions(label, suppositions, deduction, metaLevelAssumptions),
         node = metaLemmaMetathoremNode, ///
         string = topLevelMetaAssertionString, ///
-        metatheorem = new Metatheorem(context, string, node, label, suppositions, deduction, proof, assumptions);
+        metatheorem = new Metatheorem(context, string, node, label, suppositions, deduction, proof, metaLevelAssumptions);
 
   return metatheorem;
 }
@@ -730,6 +720,17 @@ export function variableDeclarationFromVariableDeclarationNode(variableDeclarati
   return variableDeclaration;
 }
 
+export function metaLevelAssumptionFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context) {
+  const { MetaLevelAssumption } = elements,
+        node = metaLevelAssumptionNode,  ///
+        string = context.nodeAsString(node),
+        reference = referenceFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context),
+        statement = statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context),
+        metaLevelAssumption = new MetaLevelAssumption(context, string, node, reference, statement);
+
+  return metaLevelAssumption;
+}
+
 export function typePrefixDeclarationFromTypePrefixDeclarationNode(typePrefixDeclarationNode, context) {
   const { TypePrefixDeclaration } = elements,
         node = typePrefixDeclarationNode, ///
@@ -1072,7 +1073,7 @@ export function termFromMetavariableNode(metavariableNode, context) {
   const termNode = metavariableNode.getTermNode();
 
   if (termNode !== null) {
-    term = termFromTermNode(termNode, context);
+    term = context.findTermByTermNode(termNode);
   }
 
   return term;
@@ -1245,13 +1246,8 @@ export function statementFromConclusionNode(conclusinoNode, context) {
 }
 
 export function statementFromAssumptionNode(assumptionNode, context) {
-  let statement;
-
-  const statementNode = assumptionNode.getStatementNode();
-
-  if (statementNode !== null) {
-    statement = statementFromStatementNode(statementNode, context);
-  }
+  const statementNode = assumptionNode.getStatementNode(),
+        statement = statementFromStatementNode(statementNode, context);
 
   return statement;
 }
@@ -1725,6 +1721,22 @@ export function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, cont
   return targetFrame;
 }
 
+export function statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context) {
+  const statementNode = metaLevelAssumptionNode.getStatementNode(),
+        statement = statementFromStatementNode(statementNode, context);
+
+  return statement;
+}
+
+export function referenceFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context) {
+  const { Reference } = elements,
+        referenceNode = metaLevelAssumptionNode.getReferenceNode(),
+        referenceString = context.nodeAsString(referenceNode),
+        reference = Reference.fromReferenceString(referenceString, context);
+
+  return reference;
+}
+
 export function suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
   const suppositionNodes = topLevelAsssertionNode.getSuppositionNodes(),
         suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
@@ -1794,18 +1806,12 @@ export function combinatorFromCombinatorDeclarationNode(combinatorDeclarationNod
 }
 
 export function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
-  const metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),
-        metaType = metaTypeFromMetaTypeNode(metaTypeNode, context);
+  const metaTypeName = metavariableDeclarationNode.getMetaTypeName(),
+        metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
 
   return metaType;
 }
 
-export function assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
-  const assumptions = [];
-
-  return assumptions;
-}
-
 export function provisionalFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   const provisional = simpleTypeDeclarationNode.isProvisional();
 
@@ -1937,6 +1943,12 @@ export function replacementStatementFromStatementSubstitutionNode(statementSubst
   return replacementStatement;
 }
 
+export function metaLevelAssumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
+  const metaLevelAssumptions = [];
+
+  return metaLevelAssumptions;
+}
+
 export function termsFromTermNodes(termNodes, context) {
   const terms = termNodes.map((termNode) => {
     const term = termFromTermNode(termNode, context);

package/src/utilities/json.js

@@ -565,7 +565,7 @@ export function assumptionsFromJSON(json, context) {
   let { assumptions } = json;
 
   const { Assumption } = elements,
-        assumptionsJSON = assumptions; ///
+    assumptionsJSON = assumptions; ///
 
   assumptions = assumptionsJSON.map((assumptionJSON) => {
     const json = assumptionJSON,  ///
@@ -702,6 +702,22 @@ export function propertyRelationsFromJSON(json, context) {
   return propertyRelations;
 }
 
+export function metaLevelAssumptionsFromJSON(json, context) {
+  let { metaLevelAssumptions } = json;
+
+  const { MetaLevelAssumption } = elements,
+        metaLevelAssumptionsJSON = metaLevelAssumptions; ///
+
+  metaLevelAssumptions = metaLevelAssumptionsJSON.map((metaLevelAssumptionJSON) => {
+    const json = metaLevelAssumptionJSON,  ///
+          metaLevelAssumption = MetaLevelAssumption.fromJSON(json, context);
+
+    return metaLevelAssumption;
+  });
+
+  return metaLevelAssumptions;
+}
+
 export function nameToNameJSON(name) {
   const nameJSON = name;  ///
 
@@ -1120,6 +1136,16 @@ export function propertyRelationsToPropertyRelationsJSON(propertyRelations) {
   return propertyRelationsJSON;
 }
 
+export function metaLevelAssumptionsToMetaLevelAssumptionsJSON(metaLevelAssumptions) {
+  const metaLevelAssumptionsJSON = metaLevelAssumptions.map((metaLevelAssumption) => {
+    const metaLevelAssumptionJSON = metaLevelAssumption.toJSON();
+
+    return metaLevelAssumptionJSON;
+  });
+
+  return metaLevelAssumptionsJSON;
+}
+
 function findTypeByName(name, context) {
   const typeName = name,  ///
         type = context.findTypeByTypeName(typeName);

package/src/utilities/string.js

@@ -117,6 +117,20 @@ export function suppositionsStringFromSuppositions(suppositions) {
   return suppositionsString;
 }
 
+export function metalevelAssumptionsStringFromMetaLevelAssumptions(metaLevelAssumptions) {
+  const metaLevelAssumptionsString = metaLevelAssumptions.reduce((metaLevelAssumptionsString, metaLevelAssumption) => {
+    const metaLevelAssumptionString = metaLevelAssumption.getString();
+
+    metaLevelAssumptionsString = (metaLevelAssumptionsString === null) ?
+                                   metaLevelAssumptionString: ///
+                                    `${metaLevelAssumptionsString}, ${metaLevelAssumptionString}`;
+
+    return metaLevelAssumptionsString;
+  }, null);
+
+  return metaLevelAssumptionsString;
+}
+
 export function signatureStringFromTerms(terms) {
   const termsString = termsStringFromTerms(terms),
         signatureString = `[${termsString}]`;
@@ -137,14 +151,6 @@ export function typeStringFromNominalTypeName(nominalTypeName) {
   return typeString;
 }
 
-export function assumptionStringFromStatementAndReference(statement, reference) {
-  const statementString = statement.getString(),
-        referneceString = reference.getString(),
-        assumptionString = `${referneceString} :: ${statementString}`;
-
-  return assumptionString;
-}
-
 export function termSubstitutionStringFromTermAndVariable(term, variable) {
   const termString = term.getString(),
         variableString = variable.getString(),
@@ -192,6 +198,14 @@ export function frameSubstitutionStringFromFrameAndMetavariable(frame, metavaria
   return string;
 }
 
+export function metaLevelAssumptionStringFromStatementAndReference(statement, reference) {
+  const statementString = statement.getString(),
+        referneceString = reference.getString(),
+        metaLevelAssumptionString = `${referneceString} :: ${statementString}`;
+
+  return metaLevelAssumptionString;
+}
+
 export function procedureCallStringFromProcedureReferenceAndParameters(procedureReference, parameters) {
   const procedureReferenceName = procedureReference.getName(),
         parametersString = parametersStringFromParameters(parameters),
@@ -236,17 +250,6 @@ export function topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels
   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(),
@@ -255,3 +258,15 @@ export function statementSubstitutionStringFromStatementMetavariableAndSubstitut
 
   return statementSubstitutionString;
 }
+
+export function topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions(label, suppositions, deduction, metaLevelAssumptions) {
+  const labelString = label.getString(),
+        deductionString = deduction.getString(),
+        suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        metalevelAssumptionsString = metalevelAssumptionsStringFromMetaLevelAssumptions(metaLevelAssumptions),
+        topLevelMetaAssertionString = (suppositionsString !== null) ?
+                                       `${labelString} :: [${suppositionsString}]...${deductionString} ${metalevelAssumptionsString}` :
+                                         `${labelString} :: ${deductionString} ${metalevelAssumptionsString}`;
+
+  return topLevelMetaAssertionString;
+}

package/src/utilities/unification.js

@@ -59,10 +59,10 @@ async function unifyStatementWithReference(statement, reference, satisfiesAssert
 
       if (metaLevel) {
         descend((context) => {
-          const { Assumption } = elements,
-                assumption = Assumption.fromStatementAndReference(statement, reference, context);
+          const { MetaLevelAssumption } = elements,
+                metaLevelAssumption = MetaLevelAssumption.fromStatementAndReference(statement, reference, context);
 
-          assumption.validate(context);
+          metaLevelAssumption.validate(context);
 
           statementUnifiesWithReference = true;
         }, context);

package/src/utilities/validation.js

@@ -94,7 +94,9 @@ function validateStatementAsMetavariable(statement, context) {
 
     context.trace(`Validating the '${statementString}' statement as a metavariable...`);
 
-    metavariable = metavariable.validate(context);
+    const strict = true;  ///
+
+    metavariable = metavariable.validate(strict, context);
 
     if (metavariable !== null) {
       statementValidatesAsMetavariable = true;
@@ -103,25 +105,17 @@ function validateStatementAsMetavariable(statement, context) {
             generalContext = context, ///
             specificContext = context;  ///
 
-      let termSubstitution,
-          frameSubstitution;
-
-      termSubstitution = TermSubstitution.fromStatement(statement, context);
-
-      if (termSubstitution !== null) {
-        termSubstitution = termSubstitution.validate(generalContext, specificContext);  ///
+      let substitution;
 
-        if (termSubstitution === null) {
-          statementValidatesAsMetavariable = false;
-        }
-      }
+      const frameSubstitution = FrameSubstitution.fromStatement(statement, context),
+            termSubstitution = TermSubstitution.fromStatement(statement, context);
 
-      frameSubstitution = FrameSubstitution.fromStatement(statement, context);
+      substitution = (termSubstitution || frameSubstitution);
 
-      if (frameSubstitution !== null) {
-        frameSubstitution = frameSubstitution.validate(generalContext, specificContext);  ///
+      if (substitution !== null) {
+        substitution = substitution.validate(generalContext, specificContext);  ///
 
-        if (frameSubstitution === null) {
+        if (substitution === null) {
           statementValidatesAsMetavariable = false;
         }
       }