occam-verify-cli 1.0.211 → 1.0.219

package/src/dom/variable.js

@@ -61,23 +61,6 @@ export default domAssigned(class Variable {
     return variableNameMatches;
   }
 
-  isEffectivelyEqualToTerm(term, generalContext, specificContext) {
-    let effectivelyEqualToTerm = false;
-
-    const generalContextFilePath = generalContext.getFilePath(),
-          specificContextFilePath = specificContext.getFilePath();
-
-    if (generalContextFilePath === specificContextFilePath) {
-      const termString = term.getString();
-
-      if (termString === this.string) {
-        effectivelyEqualToTerm = true;
-      }
-    }
-
-    return effectivelyEqualToTerm;
-  }
-
   verify(context) {
     let verified;
 
@@ -137,32 +120,26 @@ export default domAssigned(class Variable {
 
     specificContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
 
-    const effectivelyEqualToTerm = this.isEffectivelyEqualToTerm(term, generalContext, specificContext);
+    const variable = this, ///
+          substitutionPresent = substitutions.isSubstitutionPresentByVariable(variable);
 
-    if (effectivelyEqualToTerm) {
-      termUnified = true;
-    } else {
-      const variable = this, ///
-            substitutionPresent = substitutions.isSubstitutionPresentByVariable(variable);
-
-      if (substitutionPresent) {
-        const substitution = substitutions.findSubstitutionByVariable(variable),
-              substitutionTermEqualToTerm = substitution.isTermEqualTo(term);
-
-        if (substitutionTermEqualToTerm) {
-          termUnified = true;
-        }
-      } else {
-        const { TermSubstitution } = dom,
-              context = specificContext,  ///
-              variable = this,  ///
-              termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
-              substitution = termSubstitution;  ///
-
-        substitutions.addSubstitution(substitution, specificContext);
+    if (substitutionPresent) {
+      const substitution = substitutions.findSubstitutionByVariable(variable),
+            substitutionTermEqualToTerm = substitution.isTermEqualTo(term);
 
+      if (substitutionTermEqualToTerm) {
         termUnified = true;
       }
+    } else {
+      const { TermSubstitution } = dom,
+            context = specificContext,  ///
+            variable = this,  ///
+            termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
+            substitution = termSubstitution;  ///
+
+      substitutions.addSubstitution(substitution, specificContext);
+
+      termUnified = true;
     }
 
     if (termUnified) {
@@ -174,7 +151,7 @@ export default domAssigned(class Variable {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          string = this.string,
+          string = this.string, ///
           type = typeJSON,  ///
           json = {
             type,

package/src/mixins/step/unify.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import dom from "../../dom";
 import Substitutions from "../../substitutions";
 
@@ -9,7 +11,9 @@ import { equalityFromStatement,
          propertyAssertionFromStatement,
          satisfiesAssertionFromStatement } from "../../utilities/context";
 
-function unifyAWithRule(statement, reference, substitutions, context) {
+const { backwardsSome } = arrayUtilities;
+
+function unifyWithRule(statement, reference, substitutions, context) {
   let unifiedWithRule = false;
 
   if (reference !== null) {
@@ -35,7 +39,7 @@ function unifyAWithRule(statement, reference, substitutions, context) {
   return unifiedWithRule;
 }
 
-function unifyAWithReference(statement, reference, substitutions, context) {
+function unifyWithReference(statement, reference, substitutions, context) {
   let unifiedWithReference = false;
 
   if (reference !== null) {
@@ -69,40 +73,58 @@ function unifyAWithReference(statement, reference, substitutions, context) {
 function unifyAsSatisfiesAssertion(statement, reference, substitutions, context) {
   let unifiedAsSatisfiesAssertion = false;
 
-  if (reference !== null) {
-    const satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
+  const satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
 
-    if (satisfiesAssertion !== null) {
-      const statementString = statement.getString();
+  if (satisfiesAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Unifying the '${statementString}' statement as a satisfies assertion...`);
+
+    const stated = true,
+          assignments = null;
+
+    satisfiesAssertion.verifySignature(assignments, stated, context);
 
-      context.trace(`Unifying the '${statementString}' statement as a satisfies assertion...`);
+    if (reference === null) {
+      const stepsOrSubproofs = context.getStepsOrSubproofs();
 
+      unifiedAsSatisfiesAssertion = backwardsSome(stepsOrSubproofs, (stepsOrSubproof) => {
+        const satisfiedAssertionUnified = stepsOrSubproof.unifySatisfiesAssertion(satisfiesAssertion, context);
+
+        if (satisfiedAssertionUnified) {
+          return true;
+        }
+      });
+    } else {
       const axiomLemmaTheoremConjecture = context.findAxiomLemmaTheoremConjectureByReference(reference);
 
       if (axiomLemmaTheoremConjecture !== null) {
         reference = satisfiesAssertion.getReference();
 
-        const axiom = context.findAxiomByReference(reference),
-              substitutions = Substitutions.fromNothing(),
-              axiomLemmaTheoremConjectureUnified = axiom.unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, substitutions, context);
+        const axiom = context.findAxiomByReference(reference);
 
-        if (axiomLemmaTheoremConjectureUnified) {
-          const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
+        if (axiom !== null) {
+          const substitutions = Substitutions.fromNothing(),
+                axiomLemmaTheoremConjectureUnified = axiom.unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, substitutions, context);
 
-          unifiedAsSatisfiesAssertion = substitutionsMatch;  ///
+          if (axiomLemmaTheoremConjectureUnified) {
+            const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
+
+            unifiedAsSatisfiesAssertion = substitutionsMatch;  ///
+          }
         }
       }
+    }
 
-      if (unifiedAsSatisfiesAssertion) {
-        context.debug(`...unified the '${statementString}' statement as a satisfies assertion.`);
-      }
+    if (unifiedAsSatisfiesAssertion) {
+      context.debug(`...unified the '${statementString}' statement as a satisfies assertion.`);
     }
   }
 
   return unifiedAsSatisfiesAssertion;
 }
 
-function unifyAWithAxiomLemmaTheoremOrConjecture(statement, reference, substitutions, context) {
+function unifyWithAxiomLemmaTheoremOrConjecture(statement, reference, substitutions, context) {
   let unifiedWithAxiomLemmaTheoremOrConjecture = false;
 
   if (reference !== null) {
@@ -115,10 +137,9 @@ function unifyAWithAxiomLemmaTheoremOrConjecture(statement, reference, substitut
 
       context.trace(`Unifying the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`);
 
-      const stepsOrSubproofs = context.getStepsOrSubproofs(),
-            specificSubstitutions = Substitutions.fromNothing();
+      const stepsOrSubproofs = context.getStepsOrSubproofs();
 
-      substitutions = specificSubstitutions;  ///
+      substitutions = Substitutions.fromNothing();
 
       const statementAndStepsUnified = axiomLemmaTheoremConjecture.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
 
@@ -240,16 +261,16 @@ function unifyAsPropertyAssertion(statement, reference, substitutions, context)
 }
 
 function unifyWithStepsOrSubproofs(statement, reference, substitutions, context) {
-  let unifiedWithSteps = false;
+  let unifiedWithStepOrSubproofs = false;
 
   if (reference === null) {
     const stepsOrSubproofs = context.getStepsOrSubproofs(),
           statementUnifiedWithSteps = statement.unifyWithStepsOrSubproofs(stepsOrSubproofs, context);
 
-    unifiedWithSteps = statementUnifiedWithSteps; ///
+    unifiedWithStepOrSubproofs = statementUnifiedWithSteps; ///
   }
 
-  return unifiedWithSteps;
+  return unifiedWithStepOrSubproofs;
 }
 
 function unifyWithSatisfiesAssertion(statement, reference, substitutions, context) {
@@ -274,8 +295,8 @@ function unifyWithSatisfiesAssertion(statement, reference, substitutions, contex
           return satisfiesAssertions;
         }, []);
 
-  unifiedWithSatisfiesAssertion = satisfiesAssertions.some((satisfiesAssertion) => {
-    const statementUnified = satisfiesAssertion.unifyStatement(statement, context);
+  unifiedWithSatisfiesAssertion = backwardsSome(satisfiesAssertions, (satisfiesAssertion) => {
+    const statementUnified = satisfiesAssertion.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
 
     if (statementUnified) {
       return true;
@@ -286,10 +307,10 @@ function unifyWithSatisfiesAssertion(statement, reference, substitutions, contex
 }
 
 const unifyMixins = [
-  unifyAWithRule,
-  unifyAWithReference,
+  unifyWithRule,
+  unifyWithReference,
   unifyAsSatisfiesAssertion,
-  unifyAWithAxiomLemmaTheoremOrConjecture,
+  unifyWithAxiomLemmaTheoremOrConjecture,
   unifyAsEquality,
   unifyAsJudgement,
   unifyAsTypeAssertion,

package/src/node/conclusion.js

@@ -2,9 +2,16 @@
 
 import NonTerminalNode from "../node/nonTerminal";
 
-import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default class ConclusionNode extends NonTerminalNode {
+  getNonsenseNode() {
+    const ruleName = NONSENSE_RULE_NAME,
+          nonsenseNode = this.getNodeByRuleName(ruleName);
+
+    return nonsenseNode;
+  }
+
   getStatementNode() {
     const ruleName = STATEMENT_RULE_NAME,
           statementNode = this.getNodeByRuleName(ruleName);

package/src/node/deduction.js

@@ -2,9 +2,16 @@
 
 import NonTerminalNode from "../node/nonTerminal";
 
-import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default class DeductionNode extends NonTerminalNode {
+  getNonsenseNode() {
+    const ruleName = NONSENSE_RULE_NAME,
+          nonsenseNode = this.getNodeByRuleName(ruleName);
+
+    return nonsenseNode;
+  }
+
   getStatementNode() {
     const ruleName = STATEMENT_RULE_NAME,
           statementNode = this.getNodeByRuleName(ruleName);

package/src/node/nonsense.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+export default class NonsenseNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(NonsenseNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/premise.js

@@ -2,9 +2,16 @@
 
 import NonTerminalNode from "../node/nonTerminal";
 
-import { STATEMENT_RULE_NAME, PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
+import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME, PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
 
 export default class PremiseNode extends NonTerminalNode {
+  getNonsenseNode() {
+    const ruleName = NONSENSE_RULE_NAME,
+          nonsenseNode = this.getNodeByRuleName(ruleName);
+
+    return nonsenseNode;
+  }
+
   getStatementNode() {
     const ruleName = STATEMENT_RULE_NAME,
           statementNode = this.getNodeByRuleName(ruleName);

package/src/node/step.js

@@ -2,7 +2,7 @@
 
 import NonTerminalNode from "../node/nonTerminal";
 
-import { REFERENCE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+import { NONSENSE_RULE_NAME, REFERENCE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default class StepNode extends NonTerminalNode {
   isStepNode() {
@@ -17,6 +17,13 @@ export default class StepNode extends NonTerminalNode {
     return subproofNode;
   }
 
+  getNonsenseNode() {
+    const ruleName = NONSENSE_RULE_NAME,
+          nonsenseNode = this.getNodeByRuleName(ruleName);
+
+    return nonsenseNode;
+  }
+
   getStatementNode() {
     const ruleName = STATEMENT_RULE_NAME,
           statementNode = this.getNodeByRuleName(ruleName);

package/src/node/supposition.js

@@ -2,9 +2,16 @@
 
 import NonTerminalNode from "../node/nonTerminal";
 
-import { STATEMENT_RULE_NAME, PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
+import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME, PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
 
 export default class SuppositionNode extends NonTerminalNode {
+  getNonsenseNode() {
+    const ruleName = NONSENSE_RULE_NAME,
+          nonsenseNode = this.getNodeByRuleName(ruleName);
+
+    return nonsenseNode;
+  }
+
   getStatementNode() {
     const ruleName = STATEMENT_RULE_NAME,
           statementNode = this.getNodeByRuleName(ruleName);

package/src/nonTerminalNodeMap.js

@@ -14,6 +14,7 @@ import LabelNode from "./node/label";
 import LabelsNode from "./node/labels";
 import PremiseNode from "./node/premise";
 import TheoremNode from "./node/theorem";
+import NonsenseNode from "./node/nonsense";
 import ArgumentNode from "./node/argument";
 import SubproofNode from "./node/subproof";
 import PropertyNode from "./node/property";
@@ -74,6 +75,7 @@ import { RULE_RULE_NAME,
          LABELS_RULE_NAME,
          THEOREM_RULE_NAME,
          PREMISE_RULE_NAME,
+         NONSENSE_RULE_NAME,
          ARGUMENT_RULE_NAME,
          SUBPROOF_RULE_NAME,
          PROPERTY_RULE_NAME,
@@ -140,6 +142,7 @@ const nonTerminalNodeMap = {
   [SUBPROOF_RULE_NAME]: SubproofNode,
   [EQUALITY_RULE_NAME]: EqualityNode,
   [VARIABLE_RULE_NAME]: VariableNode,
+  [NONSENSE_RULE_NAME]: NonsenseNode,
   [META_TYPE_RULE_NAME]: MetaTypeNode,
   [SIGNATURE_RULE_NAME]: SignatureNode,
   [REFERENCE_RULE_NAME]: ReferenceNode,

package/src/ruleNames.js

@@ -19,6 +19,7 @@ export const PROPERTY_RULE_NAME = "property";
 export const EQUALITY_RULE_NAME = "equality";
 export const VARIABLE_RULE_NAME = "variable";
 export const SUBPROOF_RULE_NAME = "subproof";
+export const NONSENSE_RULE_NAME = "nonsense";
 export const SIGNATURE_RULE_NAME = "signature";
 export const META_TYPE_RULE_NAME = "metaType";
 export const PARAMETER_RULE_NAME = "parameter";

package/src/substitutions.js

@@ -216,6 +216,16 @@ export default class Substitutions {
     return match;
   }
 
+  removeTrivialSubstitutions()  {
+    filter(this.array, (substitution) => {
+      const trivial = substitution.isTrivial();
+
+      if (!trivial) {
+        return true;
+      }
+    });
+  }
+
   clear() {
     clear(this.array);
 

package/src/utilities/subproof.js

@@ -1,34 +1,56 @@
 "use strict";
 
-import { nodeAsString, nodesAsString } from "./string";
-
 export function subproofStringFromSubproofNode(subproofNode, fileContext) {
-  const tokens = fileContext.getTokens(),
-        suppositionStatementNodes = suppositionStatementNodesFromSubproofNode(subproofNode),
-        lastStepStatementNode = lastStepStatementNodeFromSubproofNode(subproofNode),
-        suppositionStatementsString = nodesAsString(suppositionStatementNodes, tokens),
-        lastStepStatementString = nodeAsString(lastStepStatementNode, tokens),
-        subproofString = `[${suppositionStatementsString}]...${lastStepStatementString}`;
+  const suppositionStatementsOrNonsenseString = suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, fileContext),
+        lastStatementOrNonsenseString = lastStatementOrNonsenseStringFromSubproofNode(subproofNode, fileContext),
+        subproofString = `[${suppositionStatementsOrNonsenseString}]...${lastStatementOrNonsenseString}`;
 
   return subproofString;
 }
 
-function lastStepStatementNodeFromSubproofNode(subproofNode) {
+function suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, fileContext) {
+  const suppositionNodes = subproofNode.getSuppositionNodes(),
+        suppositionStatementsOrNonsenseString = suppositionNodes.reduce((suppositionStatementsOrNonsenseString, suppositionNode) => {
+          const suppositionOrStepNode = suppositionNode,  ///
+                statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, fileContext),
+                suppositionStatementOrNonsenseString = statementOrNonsenseString; ///
+
+          suppositionStatementsOrNonsenseString = (suppositionStatementsOrNonsenseString !== null) ?
+                                                    `${suppositionStatementsOrNonsenseString}, ${suppositionStatementOrNonsenseString}` :
+                                                      suppositionStatementOrNonsenseString; ///
+
+          return suppositionStatementsOrNonsenseString;
+        }, null);
+
+  return suppositionStatementsOrNonsenseString;
+}
+
+function lastStatementOrNonsenseStringFromSubproofNode(subproofNode, fileContext) {
   const lastStepNode = subproofNode.getLastStepNode(),
-        lastStepNodeStatementNode = lastStepNode.getStatementNode(),
-        lastStepStatementNode = lastStepNodeStatementNode;  ///
+        suppositionOrStepNode = lastStepNode, ///
+        statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, fileContext),
+        lastStatementOrNonsenseString = statementOrNonsenseString; ///
 
-  return lastStepStatementNode;
+  return lastStatementOrNonsenseString;
 }
 
-function suppositionStatementNodesFromSubproofNode(subproofNode) {
-  const suppositionNodes = subproofNode.getSuppositionNodes(),
-        suppositionNodeStatementNodes = suppositionNodes.map((suppositionNode) => {
-          const suppositionNodeStatementNode = suppositionNode.getStatementNode();
+function statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, fileContext) {
+  let statementOrNonsenseString;
 
-          return suppositionNodeStatementNode;
-        }),
-        suppositionStatementNodes = suppositionNodeStatementNodes;  ///
+  const nonsenseNode = suppositionOrStepNode.getNonsenseNode(),
+        statementNode = suppositionOrStepNode.getStatementNode();
 
-  return suppositionStatementNodes;
-}
+  if (false) {
+    ///
+  } else if (nonsenseNode !== null) {
+    const nonsenseString = fileContext.nodeAsString(nonsenseNode);
+
+    statementOrNonsenseString = nonsenseString; ///
+  } else if (statementNode !== null) {
+    const statementString = fileContext.nodeAsString(statementNode);
+
+    statementOrNonsenseString = statementString;  ///
+  }
+
+  return statementOrNonsenseString;
+}