occam-verify-cli 1.0.387 → 1.0.396

package/src/mixins/statement/verify.js

@@ -12,6 +12,41 @@ import { equalityFromStatement,
          containedAssertionFromStatement,
          satisfiesAssertionFromStatement } from "../../utilities/context";
 
+function verifyAsMetavariableAndSubstitution(statement, assignments, stated, context) {
+  let verifiesAsMetavariableAndSubstitution = false;
+
+  const metavariable = metavariableFromStatement(statement, context);
+
+  if (metavariable !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Verifying the '${statementString}' statement as a metavariable and substitution...`);
+
+    const metavariableVerifies = metavariable.verify(context);
+
+    if (metavariableVerifies) {
+      const { TermSubstitution, FrameSubstitution } = ontology,
+            substitution = TermSubstitution.fromStatement(statement, context) || FrameSubstitution.fromStatement(statement, context);
+
+      if (substitution !== null) {
+        const substitutionVerifies = substitution.verify(context);
+
+        if (substitutionVerifies) {
+          verifiesAsMetavariableAndSubstitution = true;
+        }
+      } else {
+        verifiesAsMetavariableAndSubstitution = true;
+      }
+    }
+
+    if (verifiesAsMetavariableAndSubstitution) {
+      context.debug(`...verified the '${statementString}' statement as a metavariable and substitution.`);
+    }
+  }
+
+  return verifiesAsMetavariableAndSubstitution;
+}
+
 function unifyWithBracketedCombinator(statement, assignments, stated, context) {
   stated = true;  ///
 
@@ -41,28 +76,6 @@ function unifyWithCombinators(statement, assignments, stated, context) {
   return unifiesWithCombinators;
 }
 
-function verifyAsMetavariable(statement, assignments, stated, context) {
-  let verifiesAsMetavariable = false;
-
-  const metavariable = metavariableFromStatement(statement, context);
-
-  if (metavariable !== null) {
-    const statementString = statement.getString();
-
-    context.trace(`Verifying the '${statementString}' statement as a metavariable...`);
-
-    const metavariableVerifies = metavariable.verify(context);
-
-    verifiesAsMetavariable = metavariableVerifies; ///
-
-    if (verifiesAsMetavariable) {
-      context.debug(`...verified the '${statementString}' statement as a metavariable.`);
-    }
-  }
-
-  return verifiesAsMetavariable;
-}
-
 function verifyAsEquality(statement, assignments, stated, context) {
   let verifiesAsEquality = false;
 
@@ -122,6 +135,10 @@ function verifyAsTypeAssertion(statement, assignments, stated, context) {
     verifiesAsTypeAssertion = typeAssertionVerifies; ///
 
     if (verifiesAsTypeAssertion) {
+      const assertion = typeAssertion;  ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a type assertion.`);
     }
   }
@@ -144,6 +161,10 @@ function verifyAsDefinedAssertion(statement, assignments, stated, context) {
     verifiesAsDefinedAssertion = definedAssertionVerifies; ///
 
     if (verifiesAsDefinedAssertion) {
+      const assertion = definedAssertion;  ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a defined assertion.`);
     }
   }
@@ -166,6 +187,10 @@ function verifyAsPropertyAssertion(statement, assignments, stated, context) {
     verifiesAsPropertyAssertion = propertyAssertionVerifies; ///
 
     if (verifiesAsPropertyAssertion) {
+      const assertion = propertyAssertion; ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a property assertion.`);
     }
   }
@@ -188,6 +213,10 @@ function verifyAsSubproofAssertion(statement, assignments, stated, context) {
     verifiesAsSubproofAssertion = subproofAssertionVerifies; ///
 
     if (verifiesAsSubproofAssertion) {
+      const assertion = subproofAssertion; ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
     }
   }
@@ -210,6 +239,10 @@ function verifyAsContainedAssertion(statement, assignments, stated, context) {
     verifiesAsContainedAssertion = containedAssertionVerifies; ///
 
     if (verifiesAsContainedAssertion) {
+      const assertion = containedAssertion; ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a contained assertion.`);
     }
   }
@@ -232,6 +265,10 @@ function verifyAsSatisfiesAssertion(statement, assignments, stated, context) {
     verifiesAsSatisfiesAssertion = satisfiesAssertionVerifies; ///
 
     if (verifiesAsSatisfiesAssertion) {
+      const assertion = satisfiesAssertion; ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a satisfies assertion.`);
     }
   }
@@ -240,9 +277,9 @@ function verifyAsSatisfiesAssertion(statement, assignments, stated, context) {
 }
 
 const verifyMixins = [
+  verifyAsMetavariableAndSubstitution,
   unifyWithBracketedCombinator,
   unifyWithCombinators,
-  verifyAsMetavariable,
   verifyAsEquality,
   verifyAsJudgement,
   verifyAsTypeAssertion,

package/src/mixins/step/unify.js

@@ -59,7 +59,7 @@ function unifyWithReference(statement, reference, satisfiesAssertion, substituti
             statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
             substitution = statementSubstitution; ///
 
-      substitutions.addSubstitution(substitution, specificContext);
+      substitutions.addSubstitution(substitution, context);
 
       unifiesWithReference = true;
 
@@ -164,7 +164,7 @@ function unifyWithAxiomLemmaTheoremOrConjecture(statement, reference, satisfiesA
 
         substitutions = generalSubstitutions; ///
 
-        substitutions.addSubstitution(substitution, specificContext);
+        substitutions.addSubstitution(substitution, context);
 
         unifiesWithAxiomLemmaTheoremOrConjecture = true;
       }

package/src/node/substitution/frame.js

@@ -19,5 +19,31 @@ export default class FrameSubstitutionNode extends NonTerminalNode {
     return firstFrameNode;
   }
 
+  getLastMetavariableNode() {
+    let lastMetavariableNode = null;
+
+    const lastFrameNode = this.getLastFrameNode(),
+          singularMetavariableNode = lastFrameNode.getSingularMetavariableNode();
+
+    if (singularMetavariableNode !== null) {
+      lastMetavariableNode = singularMetavariableNode;  ///
+    }
+
+    return lastMetavariableNode;
+  }
+
+  getFirstMetavariableNode() {
+    let firstMetavariableNode = null;
+
+    const firstFrameNode = this.getFirstFrameNode(),
+          singularMetavariableNode = firstFrameNode.getSingularMetavariableNode();
+
+    if (singularMetavariableNode !== null) {
+      firstMetavariableNode = singularMetavariableNode;  ///
+    }
+
+    return firstMetavariableNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(FrameSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/substitution/term.js

@@ -19,5 +19,31 @@ export default class TermSubstitutionNode extends NonTerminalNode {
     return firstTermNode;
   }
 
+  getLastVariableNode() {
+    let lastVariableNode = null;
+
+    const lastTermNode = this.getLastTermNode(),
+          singularVariableNode = lastTermNode.getSingularVariableNode();
+
+    if (singularVariableNode !== null) {
+      lastVariableNode = singularVariableNode;  ///
+    }
+
+    return lastVariableNode;
+  }
+
+  getFirstVariableNode() {
+    let firstVariableNode = null;
+
+    const firstTermNode = this.getFirstTermNode(),
+          singularVariableNode = firstTermNode.getSingularVariableNode();
+
+    if (singularVariableNode !== null) {
+      firstVariableNode = singularVariableNode;  ///
+    }
+
+    return firstVariableNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TermSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/ontology/assertion/contained.js

@@ -1,34 +1,22 @@
 "use strict";
 
 import ontology from "../../ontology";
-import LocalContext from "../../context/local";
+import Assertion from "../assertion";
+import TemporaryContext from "../../context/temporary";
 
 import { define } from "../../ontology";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 
-export default define(class ContainedAssertion {
+export default define(class ContainedAssertion extends Assertion {
   constructor(string, node, tokens, term, frame, negated, statement) {
-    this.string = string;
-    this.node = node;
-    this.tokens = tokens;
+    super(string, node, tokens);
+
     this.term = term;
     this.frame = frame;
     this.negated = negated;
     this.statement = statement;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getTokens() {
-    return this.tokens;
-  }
-
   getTerm() {
     return this.term;
   }
@@ -48,7 +36,7 @@ export default define(class ContainedAssertion {
   verify(assignments, stated, context) {
     let verifies = false;
 
-    const containedAssertionString = this.string; ///
+    const containedAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
 
@@ -159,7 +147,7 @@ export default define(class ContainedAssertion {
   verifyWhenStated(assignments, context) {
     let verifiesWhenStated;
 
-    const containedAssertionString = this.string; ///
+    const containedAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`);
 
@@ -175,7 +163,7 @@ export default define(class ContainedAssertion {
   verifyWhenDerived(context) {
     let verifiesWhenDerived;
 
-    const containedAssertionString = this.string; ///
+    const containedAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`);
 
@@ -191,13 +179,14 @@ export default define(class ContainedAssertion {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently;
 
-    const containedAssertionString = this.string; ///
+    const containedAssertionString = this.getString(); ///
 
     context.trace(`Unifying the '${containedAssertionString}' contained assertion independently...`);
 
-    const localContext = LocalContext.fromContextAndTokens(context, this.tokens);
+    const tokens = this.getTokens(),
+          temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
 
-    context = localContext; ///
+    context = temporaryContext; ///
 
     const term = termFromTermAndSubstitutions(this.term, substitutions, context),
           frame = frameFromFrameAndSubstitutions(this.frame, substitutions, context),

package/src/ontology/assertion/defined.js

@@ -1,33 +1,21 @@
 "use strict";
 
 import ontology from "../../ontology";
-import LocalContext from "../../context/local";
+import Assertion from "../assertion";
+import TemporaryContext from "../../context/temporary";
 
 import { define } from "../../ontology";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
 
-export default define(class DefinedAssertion {
+export default define(class DefinedAssertion extends Assertion {
   constructor(string, node, tokens, term, frame, negated) {
-    this.string = string;
-    this.node = node;
-    this.tokens = tokens;
+    super(string, node, tokens);
+
     this.term = term;
     this.frame= frame;
     this.negated = negated;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getTokens() {
-    return this.tokens;
-  }
-
   getTerm() {
     return this.term;
   }
@@ -43,7 +31,7 @@ export default define(class DefinedAssertion {
   verify(assignments, stated, context) {
     let verifies = false;
 
-    const definedAssertionString = this.string; ///
+    const definedAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
 
@@ -131,7 +119,7 @@ export default define(class DefinedAssertion {
   verifyWhenStated(assignments, context) {
     let verifiesWhenStated;
 
-    const definedAssertionString = this.string; ///
+    const definedAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`);
 
@@ -147,7 +135,7 @@ export default define(class DefinedAssertion {
   verifyWhenDerived(context) {
     let verifiesWhenDerived;
 
-    const definedAssertionString = this.string; ///
+    const definedAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);
 
@@ -163,13 +151,14 @@ export default define(class DefinedAssertion {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently;
 
-    const definedAssertionString = this.string; ///
+    const definedAssertionString = this.getString(); ///
 
     context.trace(`Unifying the '${definedAssertionString}' defined assertion independently...`);
 
-    const localContext = LocalContext.fromContextAndTokens(context, this.tokens);
+    const tokens = this.getTokens(),
+          temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
 
-    context = localContext; ///
+    context = temporaryContext; ///
 
     const term = termFromTermAndSubstitutions(this.term, substitutions, context),
           frame = frameFromFrameAndSubstitutions(this.frame, substitutions, context),

package/src/ontology/assertion/property.js

@@ -1,32 +1,19 @@
 "use strict";
 
 import ontology from "../../ontology";
-
+import Assertion from "../assertion";
 import VariableAssignment from "../../assignment/variable";
 
 import { define } from "../../ontology";
 
-export default define(class PropertyAssertion {
+export default define(class PropertyAssertion extends Assertion {
   constructor(string, node, tokens, term, propertyRelation) {
-    this.string = string;
-    this.node = node;
-    this.tokens = tokens;
+    super(string, node, tokens);
+
     this.term = term;
     this.propertyRelation = propertyRelation;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getTokens() {
-    return this.tokens;
-  }
-
   getTerm() {
     return this.term;
   }
@@ -64,7 +51,7 @@ export default define(class PropertyAssertion {
   verify(assignments, stated, context) {
     let verifies = false;
 
-    const propertyAssertionString = this.string; ///
+    const propertyAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${propertyAssertionString}' property assertion...`);
 
@@ -141,7 +128,7 @@ export default define(class PropertyAssertion {
   verifyWhenStated(assignments, context) {
     let verifiesWhenStated = false;
 
-    const propertyAssertionString = this.string; ///
+    const propertyAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${propertyAssertionString}' stated property assertion...`);
 
@@ -157,7 +144,7 @@ export default define(class PropertyAssertion {
   verifyWhenDerived(context) {
     let verifiesWhenDerived;
 
-    const propertyAssertionString = this.string; ///
+    const propertyAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${propertyAssertionString}' derived property assertion...`);
 

package/src/ontology/assertion/satisfies.js

@@ -1,28 +1,19 @@
 "use strict";
 
 import ontology from "../../ontology";
+import Assertion from "../assertion";
+import Substitutions from "../../substitutions";
 
 import { define } from "../../ontology";
 
-import Substitutions from "../../substitutions";
-
-export default define(class SatisfiesAssertion {
+export default define(class SatisfiesAssertion extends Assertion {
   constructor(string, node, tokens, signature, reference) {
-    this.string = string;
-    this.node = node;
-    this.tokens = tokens;
+    super(string, node, tokens);
+
     this.signature = signature;
     this.reference = reference;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getTokens() {
     return this.tokens;
   }
@@ -42,7 +33,7 @@ export default define(class SatisfiesAssertion {
   verify(assignments, stated, context) {
     let verifies = false;
 
-    const satisfiesAssertionString = this.string; ///
+    const satisfiesAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${satisfiesAssertionString}' satisfies assertion...`);
 
@@ -95,7 +86,7 @@ export default define(class SatisfiesAssertion {
     let statementUnifies = false;
 
     const statementString = statement.getString(),
-          satisfiesAssertionString = this.string; ///
+          satisfiesAssertionString = this.getString(); ///
 
     context.trace(`Unifying the '${statementString}' statement with the '${satisfiesAssertionString}' satisfies assertion...`);
 

package/src/ontology/assertion/subproof.js

@@ -3,63 +3,28 @@
 import { arrayUtilities } from "necessary";
 
 import ontology from "../../ontology";
+import Assertion from "../assertion";
 
 import { define } from "../../ontology";
 import { unifyStatement } from "../../utilities/unification";
 
 const { match } = arrayUtilities;
 
-export default define(class SubproofAssertion {
-  constructor(string, node, statements) {
-    this.string = string;
-    this.node = node;
-    this.statements = statements;
-  }
-
-  getString() {
-    return this.string;
-  }
+export default define(class SubproofAssertion extends Assertion {
+  constructor(string, node, tokens, statements) {
+    super(string, node, tokens);
 
-  getNode() {
-    return this.node;
+    this.statements = statements;
   }
 
   getStatements() {
     return this.statements;
   }
 
-  unifySubproof(subproof, substitutions, generalContext, specificContext) {
-    let subproofUnifies;
-
-    const subproofString = subproof.getString(),
-          subproofAssertionString = this.string;  ///
-
-    specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
-
-    const subproofStatements = subproof.getStatements(),
-          subproofAssertionStatements = this.statements;  ///
-
-    subproofUnifies = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
-      const generalStatement = subproofAssertionStatement,  ///
-            specificStatement = subproofStatement,  ///
-            statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
-
-      if (statementUnifies) {
-        return true;
-      }
-    });
-
-    if (subproofUnifies) {
-      specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
-    }
-
-    return subproofUnifies;
-  }
-
   verify(assignments, stated, context) {
     let verifies;
 
-    const subproofAssertionString = this.string;  ///
+    const subproofAssertionString = this.getString();  ///
 
     context.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);
 
@@ -90,6 +55,34 @@ export default define(class SubproofAssertion {
     return statementsVerify;
   }
 
+  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+    let subproofUnifies;
+
+    const subproofString = subproof.getString(),
+          subproofAssertionString = this.getString();  ///
+
+    specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+
+    const subproofStatements = subproof.getStatements(),
+          subproofAssertionStatements = this.statements;  ///
+
+    subproofUnifies = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
+      const generalStatement = subproofAssertionStatement,  ///
+            specificStatement = subproofStatement,  ///
+            statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+
+      if (statementUnifies) {
+        return true;
+      }
+    });
+
+    if (subproofUnifies) {
+      specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+    }
+
+    return subproofUnifies;
+  }
+
   static name = "SubproofAssertion";
 
   static fromStatementNode(statementNode, context) {
@@ -99,10 +92,11 @@ export default define(class SubproofAssertion {
 
     if (subproofAssertionNode !== null) {
       const node = subproofAssertionNode, ///
+            tokens = null,
             string = context.nodeAsString(node),
             statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context);
 
-      subproofAssertion = new SubproofAssertion(string, node, statements);
+      subproofAssertion = new SubproofAssertion(string, node, tokens, statements);
     }
 
     return subproofAssertion;