occam-verify-cli 1.0.695 → 1.0.702

package/src/process/instantiate.js

@@ -6,21 +6,31 @@ import { TERM_RULE_NAME,
          LABEL_RULE_NAME,
          PREMISE_RULE_NAME,
          VARIABLE_RULE_NAME,
+         EQUALITY_RULE_NAME,
+         PROPERTY_RULE_NAME,
+         JUDGEMENT_RULE_NAME,
+         DEDUCTION_RULE_NAME,
          PARAMETER_RULE_NAME,
          STATEMENT_RULE_NAME,
          REFERENCE_RULE_NAME,
          COMBINATOR_RULE_NAME,
          CONCLUSION_RULE_NAME,
+         HYPOTHESIS_RULE_NAME,
+         ASSUMPTION_RULE_NAME,
+         TYPE_PREFIX_RULE_NAME,
+         SUPPOSITION_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          EQUIVALENCE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME,
+         PROPERTY_RELATION_RULE_NAME,
          DEFINED_ASSERTION_RULE_NAME,
          TERM_SUBSTITUTION_RULE_NAME,
          SUBPROOF_ASSERTION_RULE_NAME,
          FRAME_SUBSTITUTION_RULE_NAME,
          PROCEDURE_REFERENCE_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
+         SATISFIES_ASSERTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
          REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
@@ -29,39 +39,76 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       labelPlaceholderRule = ruleFromRuleName(LABEL_RULE_NAME),
       premisePlaceholderRule = ruleFromRuleName(PREMISE_RULE_NAME),
       variablePlaceholderRule = ruleFromRuleName(VARIABLE_RULE_NAME),
+      equalityPlaceholderRule = ruleFromRuleName(EQUALITY_RULE_NAME),
+      propertyPlaceholderRule = ruleFromRuleName(PROPERTY_RULE_NAME),
+      judgementlaceholderRule = ruleFromRuleName(JUDGEMENT_RULE_NAME),
+      deductionPlaceholderRule = ruleFromRuleName(DEDUCTION_RULE_NAME),
       parameterPlaceholderRule = ruleFromRuleName(PARAMETER_RULE_NAME),
       statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
       referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
       combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
       conclusionPlaceholderRule = ruleFromRuleName(CONCLUSION_RULE_NAME),
+      hypothesisPlaceholderRule = ruleFromRuleName(HYPOTHESIS_RULE_NAME),
+      assumptionPlaceholderRule = ruleFromRuleName(ASSUMPTION_RULE_NAME),
+      typePrefixPlaceholderRule = ruleFromRuleName(TYPE_PREFIX_RULE_NAME),
+      suppositionPlaceholderRule = ruleFromRuleName(SUPPOSITION_RULE_NAME),
       constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
       equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
       metavariablePlaceholderRule = ruleFromRuleName(METAVARIABLE_RULE_NAME),
       procedureCalllaceholderRule = ruleFromRuleName(PROCEDURE_CALL_RULE_NAME),
+      propertyRelationlaceholderRule = ruleFromRuleName(PROPERTY_RELATION_RULE_NAME),
       definedAssertionPlaceholderRule = ruleFromRuleName(DEFINED_ASSERTION_RULE_NAME),
       termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
       subproofAssertionlaceholderRule = ruleFromRuleName(SUBPROOF_ASSERTION_RULE_NAME),
       frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
       procedureReferencelaceholderRule = ruleFromRuleName(PROCEDURE_REFERENCE_RULE_NAME),
       containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
+      satisfiesAssertionPlaceholderRule = ruleFromRuleName(SATISFIES_ASSERTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
       referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
-export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
+export function instantiatePremise(string, context) {
+  string = `${string}
+`;  ///
 
-export function instantiateFrame(string, context) { return instantiate(framePlaceholderRule, string, context); }
+  return instantiate(premisePlaceholderRule, string, context);
+}
 
-export function instantiateLabel(string, context) { return instantiate(labelPlaceholderRule, string, context); }
+export function instantiateDeduction(string, context) {
+  string = `${string}
+`;  ///
 
-export function instantiatePremise(string, context) {
+  return instantiate(deductionPlaceholderRule, string, context);
+}
+
+export function instantiateConclusion(string, context) {
   string = `${string}
 `;  ///
 
-  return instantiate(premisePlaceholderRule, string, context);
+  return instantiate(conclusionPlaceholderRule, string, context);
+}
+
+export function instantiateSupposition(string, context) {
+  string = `${string}
+`;  ///
+
+  return instantiate(suppositionPlaceholderRule, string, context);
 }
 
+export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
+
+export function instantiateFrame(string, context) { return instantiate(framePlaceholderRule, string, context); }
+
+export function instantiateLabel(string, context) { return instantiate(labelPlaceholderRule, string, context); }
+
 export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
 
+export function instantiateEquality(string, context) { return instantiate(equalityPlaceholderRule, string, context); }
+
+export function instantiateProperty(string, context) { return instantiate(propertyPlaceholderRule, string, context); }
+
+export function instantiateJudgement(string, context) { return instantiate(judgementlaceholderRule, string, context); }
+
 export function instantiateParameter(string, context) { return instantiate(parameterPlaceholderRule, string, context); }
 
 export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
@@ -70,12 +117,11 @@ export function instantiateReference(string, context) { return instantiate(refer
 
 export function instantiateCombinator(string, context) { return instantiate(combinatorPlaceholderRule, string, context); }
 
-export function instantiateConclusion(string, context) {
-  string = `${string}
-`;  ///
+export function instantiateHypothesis(string, context) { return instantiate(hypothesisPlaceholderRule, string, context); }
 
-  return instantiate(conclusionPlaceholderRule, string, context);
-}
+export function instantiateAssumption(string, context) { return instantiate(assumptionPlaceholderRule, string, context); }
+
+export function instantiateTypePrefix(string, context) { return instantiate(typePrefixPlaceholderRule, string, context); }
 
 export function instantiateConstructor(string, context) { return instantiate(constructorPlaceholderRule, string, context); }
 
@@ -85,6 +131,8 @@ export function instantiateMetavariable(string, context) { return instantiate(me
 
 export function instantiateProcedureCall(string, context) { return instantiate(procedureCalllaceholderRule, string, context); }
 
+export function instantiatePropertyRelation(string, context) { return instantiate(propertyRelationlaceholderRule, string, context); }
+
 export function instantiateDefinedAssertion(string, context) { return instantiate(definedAssertionPlaceholderRule, string, context); }
 
 export function instantiateTermSubstitution(string, context) { return instantiate(termSubstitutionPlaceholderRule, string, context); }
@@ -97,6 +145,8 @@ export function instantiateProcedureReference(string, context) { return instanti
 
 export function instantiateContainedAssertion(string, context) { return instantiate(containedAssertionPlaceholderRule, string, context); }
 
+export function instantiateSatisfiesAssertion(string, context) { return instantiate(satisfiesAssertionPlaceholderRule, string, context); }
+
 export function instantiateStatementSubstitution(string, context) { return instantiate(statementSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }

package/src/utilities/element.js

@@ -370,6 +370,19 @@ export function parameterFromParameterNode(parameterNode, context) {
   return parameter;
 }
 
+export function signatureFromJSignatureNode(signatureNode, context) {
+  const { Signature } = elements,
+        node = signatureNode,
+        string = context.nodeAsString(node),
+        terms = termsFromSignatureNode(signatureNode, context);
+
+  context = null;
+
+  const signature = new Signature(context, string, node, terms);
+
+  return signature;
+}
+
 export function hypothesisFromHypothesisNode(hypotheseNode, context) {
   const { Hypothsis } = elements,
         node = hypotheseNode, ///
@@ -600,12 +613,12 @@ export function propertyRelationFromPropertyRelationNode(propertyRelationNode, c
   const { PropertyRelation } = elements,
         node = propertyRelationNode,  ///
         string = context.nodeAsString(node),
-        property = propertyFromPropertyRelationNode(propertyRelationNode, context),
-        term = termFromPropertyRelationNode(propertyRelationNode, context);
+        term = termFromPropertyRelationNode(propertyRelationNode, context),
+        property = propertyFromPropertyRelationNode(propertyRelationNode, context);
 
   context = null;
 
-  const propertyRelation = new PropertyRelation(context, string, node, property, term);
+  const propertyRelation = new PropertyRelation(context, string, node, term, property);
 
   return propertyRelation;
 }
@@ -870,6 +883,12 @@ export function lemmaFromSectionNode(sectionNode, context) {
   return lemma;
 }
 
+export function nameFromPropertyNode(propertyNode, context) {
+  const name = propertyNode.getName();
+
+  return name;
+}
+
 export function statementFromStepNode(stepNode, context) {
   let statement = null;
 
@@ -894,6 +913,19 @@ export function referenceFromStepNode(stepNode, context) {
   return reference;
 }
 
+export function nameFromParaneterNode(parameterNode, context) {
+  const name = parameterNode.getName();
+
+  return name;
+}
+
+export function nameFromTypePrefixNode(typePrefixNode, context) {
+  const typePrefixName = typePrefixNode.getTypePrefixName(),
+        name = typePrefixName;  ///
+
+  return name;
+}
+
 export function superTypesFromTypeNode(typeNode, context) {
   const superTypes = null;
 
@@ -908,7 +940,7 @@ export function propertiesFromTypeNode(typeNode, context) {
 
 export function prefixNameFromTypeNode(typeNode, context) {
   const typePrefixName = typeNode.getTypePrefixName(),
-    prefixName = typePrefixName;  ///
+        prefixName = typePrefixName;  ///
 
   return prefixName;
 }
@@ -946,6 +978,12 @@ export function termsFromSignatureNode(signatureNode, context) {
   return terms;
 }
 
+export function provisionalFromTypeNode(typeNode, context) {
+  const provisional = null;
+
+  return provisional;
+}
+
 export function derivationFromProofNode(proofNode, context) {
   const derivationNode = proofNode.getDerivationNode(),
         derivation = derivationFromDerivationNode(derivationNode, context);
@@ -953,12 +991,6 @@ export function derivationFromProofNode(proofNode, context) {
   return derivation;
 }
 
-export function provisionalFromTypeNode(typeNode, context) {
-  const provisional = null;
-
-  return provisional;
-}
-
 export function termFromConstructorNode(ocnstructorNode, context) {
   const termNode = ocnstructorNode.getTermNode(),
         term = termFromTermNode(termNode, context);
@@ -999,6 +1031,13 @@ export function termsFromEquivalenceNode(equivalenceNode, context) {
   return terms;
 }
 
+export function nameFromMetavariableNode(metavariableNode, context) {
+  const metavaraibleName = metavariableNode.getMetavariableName(),
+        name = metavaraibleName;  ///
+
+  return name;
+}
+
 export function metavariableFromFrameNode(frameNode, context) {
   let metavariable = null;
 
@@ -1121,6 +1160,12 @@ export function assumptionFromJudgementNode(judgementNode, context) {
   return assumption;
 }
 
+export function identifierFromParameterNode(parameterNode, context) {
+  const identifier = parameterNode.getIdentifier();
+
+  return identifier;
+}
+
 export function referenceFromAssumptionNode(assumptionNode, context) {
   const metavariableNode = assumptionNode.getMetavariableNode(),
         reference = referenceFromMetavariableNode(metavariableNode, context);
@@ -1260,6 +1305,18 @@ export function referenceFromMetavariableNode(metavariableNode, context) {
   }, context);
 }
 
+export function termFromJDefinedAssertionNode(definedAssertionNode, context) {
+  let term = null;
+
+  const termNode = definedAssertionNode.getTermNode();
+
+  if (termNode !== null) {
+    term = termFromTermNode(termNode, context);
+  }
+
+  return term
+}
+
 export function frameFromDefinedAssertionNode(definedAssertionNode, context) {
   let frame = null;
 
@@ -1303,6 +1360,18 @@ export function typeAssertionFromStatementNode(statementNode, context) {
   return typeAssertion;
 }
 
+export function frameFromJDefinedAssertionNode(definedAssertionNode, context) {
+  let frame = null;
+
+  const frameNode = definedAssertionNode.getFrameNode();
+
+  if (frameNode !== null) {
+    frame = frameFromFrameNode(frameNode, context);
+  }
+
+  return frame
+}
+
 export function proofFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
   let proof = null;
 
@@ -1385,6 +1454,12 @@ export function procedureCallFromSuppositionNode(suppositionNode, context) {
   return procedureCall;
 }
 
+export function negatedFromJDefinedAssertionNode(definedAssertionNode, context) {
+  const negated = definedAssertionNode.isNegated();
+
+  return negated
+}
+
 export function propertyFromPropertyRelationNode(propertyRelationNode, context) {
   const propertyNode = propertyRelationNode.getTermNode(),
         property = propertyFromPropertyNode(propertyNode, context);
@@ -1416,6 +1491,12 @@ export function termSubstitutionFromStatementNode(statementNode, context) {
   return termSubstitution;
 }
 
+export function negatedFromContainedAssertionNode(containedAssertionNode, context) {
+  const negated = containedAssertionNode.isNegated();
+
+  return negated;
+}
+
 export function typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   const typeNode = simpleTypeDeclarationNode.getTypeNode(),
         type = typeFromTypeNode(typeNode, context);
@@ -1571,6 +1652,20 @@ export function hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, cont
   return ypotheses;
 }
 
+export function signatureFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
+  const signatureNode = sasisfiesAssertionNode.getSignatureNode(),
+        signature = signatureFromJSignatureNode(signatureNode, context);
+
+  return signature;
+}
+
+export function referenceFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
+  const referenceNode = sasisfiesAssertionNode.getReferenceNode(),
+        reference = referenceFromReferenceNode(referenceNode, context);
+
+  return reference;
+}
+
 export function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
   const targetFrameNode = frameSubstitutionNode.getTargetFrameNode(),
         targetFrame = frameFromFrameNode(targetFrameNode, context);

package/src/utilities/json.js

@@ -198,6 +198,12 @@ export function procedureCallFromJSON(json, context) {
   return procedureCall;
 }
 
+export function nominalTypeNameFromJSON(json, context) {
+  const { nominalTypeName } = json;
+
+  return nominalTypeName;
+}
+
 export function procedureReferenceFromJSON(json, context) {
   let { procedureReference } = json;
 
@@ -277,7 +283,7 @@ export function framesFromJSON(json, context) {
 
   frames = framesJSON.map((frameJSON) => {
     const json = frameJSON,  ///
-      frame = Frame.fromJSON(json, context);
+          frame = Frame.fromJSON(json, context);
 
     return frame;
   });
@@ -798,6 +804,12 @@ export function procedureCallToProcedureCallJSON(procedureCall) {
   return procedureCallJSON;
 }
 
+export function nominalTypeNameToNominalTypeNameJSON(nominalTypeName) {
+  const nominalTypeNameJSON = nominalTypeName;  ///
+
+  return nominalTypeNameJSON;
+}
+
 export function procedureReferenceToProcedureReferenceJSON(procedureReference) {
   const procedureReferenceJSON = procedureReference.toJSON();