occam-verify-cli 1.0.651 → 1.0.655

package/src/element/term.js

@@ -4,10 +4,13 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
 import { validateTerms } from "../utilities/validation";
-import { typeToTypeJSON } from "../utilities/json";
+import { instantiateTerm } from "../process/instantiate";
+import { variablesFromTerm } from "../utilities/equivalence";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
-const { filter, compress } = arrayUtilities;
+const { filter } = arrayUtilities;
 
 export default define(class Term extends Element {
   constructor(context, string, node, type) {
@@ -234,28 +237,17 @@ export default define(class Term extends Element {
   static name = "Term";
 
   static fromJSON(json, context) {
-    ///
-  }
-});
-
-export function variablesFromTerm(term, context) {
-  const termNode = term.getNode(),
-        variableNodes = termNode.getVariableNodes(),
-        variables = variableNodes.map((variableNode) => {
-          const variableIdentifier = variableNode.getVariableIdentifier(),
-                variable = context.findVariableByVariableIdentifier(variableIdentifier);
+    const term = literally((context) => {
+      const { string } = json,
+            termNode = instantiateTerm(string, context),
+            node = termNode,  ///
+            type = typeFromJSON(json, context),
+            term = new Term(context, string, node, type);
 
-          return variable;
-        });
+      return term;
 
-  compress(variables, (variableA, variableB) => {
-    const variableAEqualToVariableB = variableA.isEqualTo(variableB);
-
-    if (!variableAEqualToVariableB) {
-      return true;
-    }
-  });
-
-  return variables;
-}
+    }, context);
 
+    return term;
+  }
+});

package/src/element/topLevelAssertion/axiom.js

@@ -19,23 +19,6 @@ export default define(class Axiom extends TopLevelAssertion {
     return satisfiable;
   }
 
-  verifySignature() {
-    let signatureVerifies;
-
-    const satisfiable = this.isSatisfiable();
-
-    if (satisfiable) {
-      const context = this.getContext(),
-            signature = this.getSignature();
-
-      signatureVerifies = signature.verify(context);
-    } else {
-      signatureVerifies = true
-    }
-
-    return signatureVerifies;
-  }
-
   compareSignature(signature, substitutions, context) {
     let comparesToSignature = false;
 
@@ -59,6 +42,51 @@ export default define(class Axiom extends TopLevelAssertion {
     return comparesToSignature;
   }
 
+  async verify() {
+    let verifies;
+
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const axiomString = this.getString(); ///
+
+    context.trace(`Verifying the '${axiomString}' axiom...`);
+
+    const signatureVerifies = this.verifySignature();
+
+    if (signatureVerifies) {
+      verifies = await super.verify();
+    }
+
+    if (verifies) {
+      const axiom = this; ///
+
+      context.addAxiom(axiom);
+
+      context.debug(`...verified the '${axiomString}' axiom.`);
+    }
+
+    return verifies;
+  }
+
+  verifySignature() {
+    let signatureVerifies;
+
+    const satisfiable = this.isSatisfiable();
+
+    if (satisfiable) {
+      const context = this.getContext(),
+            signature = this.getSignature();
+
+      signatureVerifies = signature.verify(context);
+    } else {
+      signatureVerifies = true
+    }
+
+    return signatureVerifies;
+  }
+
   unifyStep(step, substitutions, context) {
     let stepUnifies = false;
 
@@ -239,34 +267,6 @@ export default define(class Axiom extends TopLevelAssertion {
     return topLevelAssertionUnifies;
   }
 
-  async verify() {
-    let verifies;
-
-    const context = this.getContext();
-
-    await this.break(context);
-
-    const axiomString = this.getString(); ///
-
-    context.trace(`Verifying the '${axiomString}' axiom...`);
-
-    const signatureVerifies = this.verifySignature();
-
-    if (signatureVerifies) {
-      verifies = await super.verify();
-    }
-
-    if (verifies) {
-      const axiom = this; ///
-
-      context.addAxiom(axiom);
-
-      context.debug(`...verified the '${axiomString}' axiom.`);
-    }
-
-    return verifies;
-  }
-
   static name = "Axiom";
 
   static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Axiom, json, context); }

package/src/element/topLevelMetaAssertion.js

@@ -53,25 +53,6 @@ export default class TopLevelMetaAssertion extends Element {
     return comparesToReference;
   }
 
-  verifyLabel() {
-    let labelVerifies;
-
-    const context = this.getContext(),
-          topLevelMetaAssertionString = this.getString(); ///
-
-    context.trace(`Verifiesing the '${topLevelMetaAssertionString}' top level meta assertion's label...`);
-
-    const nameOnly = true;
-
-    labelVerifies = this.label.verify(nameOnly);
-
-    if (labelVerifies) {
-      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion's label.`);
-    }
-
-    return labelVerifies;
-  }
-
   async verify() {
     let verifies = false;
 
@@ -107,6 +88,25 @@ export default class TopLevelMetaAssertion extends Element {
     return verifies;
   }
 
+  verifyLabel() {
+    let labelVerifies;
+
+    const context = this.getContext(),
+          topLevelMetaAssertionString = this.getString(); ///
+
+    context.trace(`Verifiesing the '${topLevelMetaAssertionString}' top level meta assertion's label...`);
+
+    const nameOnly = true;
+
+    labelVerifies = this.label.verify(nameOnly);
+
+    if (labelVerifies) {
+      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion's label.`);
+    }
+
+    return labelVerifies;
+  }
+
   async verifyProof(context) {
     let proofVerifies;
 

package/src/element/type.js

@@ -314,16 +314,7 @@ export default define(class Type extends Element {
   static name = "Type";
 
   static fromJSON(json, context) {
-    const { name, prefixName, provisional } = json,
-          properties = propertiesFromJSON(json, context),
-          superTypes = superTypesFromJSON(json, context),
-          typeName = name,  ///
-          typePrefixName = null,
-          string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          node = null,
-          type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
-
-    return type;
+    debugger
   }
 
   static fromName(name, context) {

package/src/element/typePrefix.js

@@ -40,11 +40,6 @@ export default define(class TypePrefix extends Element {
   static name = "TypePrefix";
 
   static fromJSON(json, context) {
-    const { name } = json,
-          string = name,  ///
-          node = null,
-          typePrefix = new TypePrefix(context, string, node, name);
-
-    return typePrefix;
+    debugger
   }
 });

package/src/element/variable.js

@@ -202,6 +202,6 @@ export default define(class Variable extends Element {
   static name = "Variable";
 
   static fromJSON(json, context) {
-    ///
+    debugger
   }
 });

package/src/process/instantiate.js

@@ -1,34 +1,58 @@
 "use strict";
 
 import { ruleFromRuleName } from "../utilities/bnf";
-import { REFERENCE_RULE_NAME,
+import { LABEL_RULE_NAME,
+         PREMISE_RULE_NAME,
+         STATEMENT_RULE_NAME,
+         REFERENCE_RULE_NAME,
          COMBINATOR_RULE_NAME,
+         CONCLUSION_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          EQUIVALENCE_RULE_NAME,
+         METAVARIABLE_RULE_NAME,
          TERM_SUBSTITUTION_RULE_NAME,
          FRAME_SUBSTITUTION_RULE_NAME,
+         SUBPROOF_ASSERTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
          REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
-const referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
+const labelPlaceholderRule = ruleFromRuleName(LABEL_RULE_NAME),
+      premisePlaceholderRule = ruleFromRuleName(PREMISE_RULE_NAME),
+      statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
+      referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
       combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
+      conclusionPlaceholderRule = ruleFromRuleName(CONCLUSION_RULE_NAME),
       constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
       equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
+      metavariablePlaceholderRule = ruleFromRuleName(METAVARIABLE_RULE_NAME),
+      subproofAssertionlaceholderRule = ruleFromRuleName(SUBPROOF_ASSERTION_RULE_NAME),
       termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
       frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
       referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
+export function instantiateLabel(string, context) { return instantiate(labelPlaceholderRule, string, context); }
+
+export function instantiatePremise(string, context) { return instantiate(premisePlaceholderRule, string, context); }
+
+export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
+
 export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
 
 export function instantiateCombinator(string, context) { return instantiate(combinatorPlaceholderRule, string, context); }
 
+export function instantiateConclusion(string, context) { return instantiate(conclusionPlaceholderRule, string, context); }
+
 export function instantiateConstructor(string, context) { return instantiate(constructorPlaceholderRule, string, context); }
 
 export function instantiateEquivalence(string, context) { return instantiate(equivalencePlaceholderRule, string, context); }
 
+export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }
+
 export function instantiateTermSubstitution(string, context) { return instantiate(termSubstitutionPlaceholderRule, string, context); }
 
+export function instantiateSubproofAssertion(string, context) { return instantiate(subproofAssertionlaceholderRule, string, context); }
+
 export function instantiateFrameSubstitution(string, context) { return instantiate(frameSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateStatementSubstitution(string, context) { return instantiate(statementSubstitutionPlaceholderRule, string, context); }

package/src/utilities/equivalence.js

@@ -0,0 +1,26 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { compress } = arrayUtilities;
+
+export function variablesFromTerm(term, context) {
+  const termNode = term.getNode(),
+        variableNodes = termNode.getVariableNodes(),
+        variables = variableNodes.map((variableNode) => {
+          const variableIdentifier = variableNode.getVariableIdentifier(),
+                variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+          return variable;
+        });
+
+  compress(variables, (variableA, variableB) => {
+    const variableAEqualToVariableB = variableA.isEqualTo(variableB);
+
+    if (!variableAEqualToVariableB) {
+      return true;
+    }
+  });
+
+  return variables;
+}