occam-verify-cli 0.0.1238 → 0.0.1241

package/src/dom/frame.js

@@ -11,7 +11,8 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable"),
-      definedAssertionFrameNodeQuery = nodeQuery("/definedAssertion/frame");
+      definedAssertionFrameNodeQuery = nodeQuery("/definedAssertion/frame"),
+      containedAssertionFrameNodeQuery = nodeQuery("/containedAssertion/frame");
 
 const { first } = arrayUtilities;
 
@@ -311,6 +312,23 @@ export default domAssigned(class Frame {
 
     return frame;
   }
+
+  static fromContainedAssertionNode(containedAssertionNode, context) {
+    let frame = null;
+
+    const containedAssertionFrameNode = containedAssertionFrameNodeQuery(containedAssertionNode);
+
+    if (containedAssertionFrameNode !== null) {
+      const frameNode = containedAssertionFrameNode,  ///
+            metavariableNode = metavariableNodeQuery(frameNode);
+
+      if (metavariableNode !== null) {
+        frame = frameFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, context)
+      }
+    }
+
+    return frame;
+  }
 });
 
 function frameFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, context) {

package/src/dom/metavariable.js

@@ -281,7 +281,7 @@ export default domAssigned(class Metavariable {
                 metavariableString = this.string, ///
                 frameMetavariableString = frameMetavariable.getString();
 
-          specificContext.trace(`Unifying the frame's ${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
+          specificContext.trace(`Unifying the frame's '${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
 
           const specificMetavariable = frameMetavariable, ///
                 generalMetavariable = this, ///

package/src/dom/procedureCall.js

@@ -49,10 +49,16 @@ export default domAssigned(class ProcedureCall {
 
     context.trace(`Verifying the '${procedureCallString}' procedure call...`);
 
-    const procedurePresent = context.isProcedurePresentByReference(this.reference);
+    const procedure = context.findProcedureByReference(this.reference);
 
-    if (procedurePresent) {
-      verified = true;
+    if (procedure !== null) {
+      const procedureBoolean = procedure.isBoolean();
+
+      if (procedureBoolean) {
+        verified = true;
+      } else {
+        context.trace(`The '${procedureCallString}' procedure is not boolean.`);
+      }
     } else {
       context.trace(`The '${procedureCallString}' procedure is not present.`);
     }

package/src/dom/statement.js

@@ -12,7 +12,7 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { unifyStatement } from "../utilities/unification";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
-import { definedAssertionFromStatement, subproofAssertionFromStatement } from "../utilities/verification";
+import { definedAssertionFromStatement, containedAssertionFromStatement, subproofAssertionFromStatement } from "../utilities/verification";
 
 const { match, backwardsSome } = arrayUtilities;
 
@@ -110,22 +110,28 @@ export default domAssigned(class Statement {
   unifyIndependently(substitutions, context) {
     let unifiedIndependently = false;
 
-    const statement = this; ///
+    const statement = this, ///
+          statementString = this.string;
 
-    const definedAssertion = definedAssertionFromStatement(statement, context);
+    context.trace(`Unifying the '${statementString}' statement independently...`);
 
-    if (definedAssertion !== null) {
-      const statementString = this.string;
-
-      context.trace(`Unifying the '${statementString}' statement independently...`);
+    const definedAssertion = definedAssertionFromStatement(statement, context),
+          containedAssertion = containedAssertionFromStatement(statement, context);
 
+    if (definedAssertion !== null) {
       const definedAssertionUnifiedIndependently = definedAssertion.unifyIndependently(substitutions, context);
 
       unifiedIndependently = definedAssertionUnifiedIndependently; ///
+    }
 
-      if (unifiedIndependently) {
-        specificContext.debug(`...unified the '${statementString}' statement independently.`);
-      }
+    if (containedAssertion !== null) {
+      const containedAssertionUnifiedIndependently = containedAssertion.unifyIndependently(substitutions, context);
+
+      unifiedIndependently = containedAssertionUnifiedIndependently; ///
+    }
+
+    if (unifiedIndependently) {
+      context.debug(`...unified the '${statementString}' statement independently.`);
     }
 
     return unifiedIndependently;

package/src/dom/term.js

@@ -17,7 +17,8 @@ const { filter, compress } = arrayUtilities;
 
 const variableNodesQuery = nodesQuery("//variable"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      definedAssertionTermNodeQuery = nodeQuery("/definedAssertion/term");
+      definedAssertionTermNodeQuery = nodeQuery("/definedAssertion/term"),
+      containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term");
 
 export default domAssigned(class Term {
   constructor(string, node, type) {
@@ -298,4 +299,25 @@ export default domAssigned(class Term {
 
     return term;
   }
+
+  static fromContainedAssertionNode(containedAssertionNode, context) {
+    let term = null;
+
+    const containedAssertionTermNode = containedAssertionTermNodeQuery(containedAssertionNode);
+
+    if (containedAssertionTermNode !== null) {
+      const termNode = containedAssertionTermNode,  ///
+            termVariableNode = termVariableNodeQuery(termNode);
+
+      if (termVariableNode !== null) {
+        const node = termNode,  ///
+              string = context.nodeAsString(node),
+              type = null;
+
+        term = new Term(string, node, type);
+      }
+    }
+
+    return term;
+  }
 });

package/src/index.js

@@ -35,6 +35,7 @@ import TypeAssertion from "./dom/assertion/type";
 import TypeDeclaration from "./dom/declaration/type";
 import DefinedAssertion from "./dom/assertion/defined";
 import SubproofAssertion from "./dom/assertion/subproof";
+import ContainedAssertion from "./dom/assertion/contained";
 import VariableDeclaration from "./dom/declaration/variable";
 import CombinatorDeclaration from "./dom/declaration/combinator";
 import ConstructorDeclaration from "./dom/declaration/constructor";

package/src/mixins/statement/verify.js

@@ -7,6 +7,7 @@ import { equalityFromStatement,
          metavariableFromStatement,
          typeAssertionFromStatement,
          definedAssertionFromStatement,
+         containedAssertionFromStatement,
          subproofAssertionFromStatement } from "../../utilities/verification";
 
 function verifyAsMetavariable(statement, assignments, stated, context) {
@@ -119,6 +120,28 @@ function verifyAsDefinedAssertion(statement, assignments, stated, context) {
   return verifiedAsDefinedAssertion;
 }
 
+function verifyAsContainedAssertion(statement, assignments, stated, context) {
+  let verifiedAsContainedAssertion = false;
+
+  const containedAssertion = containedAssertionFromStatement(statement, context);
+
+  if (containedAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
+
+    const containedAssertionVerified = containedAssertion.verify(assignments, stated, context);
+
+    verifiedAsContainedAssertion = containedAssertionVerified; ///
+
+    if (verifiedAsContainedAssertion) {
+      context.debug(`...verified the '${statementString}' statement as a defined assertion.`);
+    }
+  }
+
+  return verifiedAsContainedAssertion;
+}
+
 function verifyAsSubproofAssertion(statement, assignments, stated, context) {
   let verifiedAsSubproofAssertion = false;
 
@@ -175,6 +198,7 @@ const verifyMixins = [
   verifyAsJudgement,
   verifyAsTypeAssertion,
   verifyAsDefinedAssertion,
+  verifyAsContainedAssertion,
   verifyAsSubproofAssertion,
   unifyWithBracketedCombinator,
   unifyWithCombinators

package/src/utilities/verification.js

@@ -63,6 +63,16 @@ export function definedAssertionFromStatement(statement, context) {
   return definedAssertion;
 }
 
+export function containedAssertionFromStatement(statement, context) {
+  context = contextFromStatement(statement, context); ///
+
+  const { ContainedAssertion } = dom,
+        statementNode = statement.getNode(),
+        containedAssertion = ContainedAssertion.fromStatementNode(statementNode, context);
+
+  return containedAssertion;
+}
+
 export function subproofAssertionFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///