occam-verify-cli 0.0.1111 → 0.0.1112

package/src/index.js

@@ -1,39 +1,44 @@
 "use strict";
 
-import Type from "./type";
-import Term from "./term";
-import Rule from "./rule";
-import Label from "./label";
-import Axiom from "./axiom";
-import Lemma from "./lemma";
-import Frame from "./frame";
-import Proof from "./proof";
-import Premise from "./premise";
-import Theorem from "./theorem";
-import Equality from "./equality";
-import MetaType from "./metaType";
-import Subproof from "./subproof";
-import Variable from "./variable";
-import Statement from "./statement";
-import ProofStep from "./proofStep";
-import Judgement from "./judgement";
-import MetaLemma from "./metaLemma";
-import Consequent from "./consequent";
-import Conjecture from "./conjecture";
-import Combinator from "./combinator";
-import Conclusion from "./conclusion";
-import Derivation from "./derivation";
-import Declaration from "./declaration";
-import Constructor from "./constructor";
-import Supposition from "./supposition";
-import Metatheorem from "./metatheorem";
-import Metavariable from "./metavariable";
-import Substitution from "./substitution";
-import Substitutions from "./substitutions";
-import SubDerivation from "./subDerivation";
-import QualifiedStatement from "./statement/qualified";
-import UnqualifiedStatement from "./statement/unqualified";
-import StatementSubstitution from "./substitution/statement";
+import Type from "./dom/type";
+import Term from "./dom/term";
+import Rule from "./dom/rule";
+import Label from "./dom/label";
+import Axiom from "./dom/axiom";
+import Lemma from "./dom/lemma";
+import Frame from "./dom/frame";
+import Proof from "./dom/proof";
+import Error from "./dom/error";
+import Premise from "./dom/premise";
+import Theorem from "./dom/theorem";
+import Equality from "./dom/equality";
+import MetaType from "./dom/metaType";
+import Subproof from "./dom/subproof";
+import Variable from "./dom/variable";
+import ProofStep from "./dom/proofStep";
+import Reference from "./dom/reference";
+import Statement from "./dom/statement";
+import Judgement from "./dom/judgement";
+import MetaLemma from "./dom/metaLemma";
+import Consequent from "./dom/consequent";
+import Conjecture from "./dom/conjecture";
+import Conclusion from "./dom/conclusion";
+import Derivation from "./dom/derivation";
+import Declaration from "./dom/declaration";
+import Supposition from "./dom/supposition";
+import Metatheorem from "./dom/metatheorem";
+import Metavariable from "./dom/metavariable";
+import SubDerivation from "./dom/subDerivation";
+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";
+import MetavariableDeclaration from "./dom/declaration/metavariable";
+import ConstructorBracketedContext from "./context/bracketed/constructor";
 
 export { default as Log } from "./log";
 export { default as ReleaseContext } from "./context/release";

package/src/mixins/proofStep/unify.js

@@ -0,0 +1,115 @@
+"use strict";
+
+import StatementSubstitution from "../../substitution/statement";
+
+function unifyAWithRule(statement, reference, substitutions, context) {
+  let unifiedWithRule = false;
+
+  if (reference !== null) {
+    const rule = context.findRuleByReference(reference);
+
+    if (rule !== null) {
+      const ruleString = rule.getString(),
+            statementString = statement.getString();
+
+      context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule...`);
+
+      const proofSteps = context.getProofSteps(),
+            statementAndProofStepsUnified = rule.unifyStatementAndProofSteps(statement, proofSteps, context);
+
+      unifiedWithRule = statementAndProofStepsUnified;  ///
+
+      if (unifiedWithRule) {
+        context.debug(`...unified the '${statementString}' statement with the '${ruleString}' rule.`);
+      }
+    }
+  }
+
+  return unifiedWithRule;
+}
+
+function unifyAWithReference(statement, reference, substitutions, context) {
+  let unifiedWithReference = false;
+
+  if (reference !== null) {
+    const metavariableVerified = reference.verifyMetavariable(context);
+
+    if (metavariableVerified) {
+      const statementString = statement.getString(),
+            referenceString = reference.getString();
+
+      context.trace(`Unifying the '${statementString}' statement with the '${referenceString}' reference...`);
+
+      const metavariable = reference.getMetavariable(),
+            statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
+            substitution = statementSubstitution; ///
+
+      substitutions.addSubstitution(substitution, context);
+
+      unifiedWithReference = true;
+
+      if (unifiedWithReference) {
+        context.debug(`...unified the '${statementString}' statement with the '${referenceString}' reference.`);
+      }
+    }
+  }
+
+  return unifiedWithReference;
+}
+
+function unifyAWithAxiomLemmaTheoremOrConjecture(statement, reference, substitutions, context) {
+  let unifiedWithAxiomLemmaTheoremOrConjecture = false;
+
+  if (reference !== null) {
+    const axiomLemmaTheoremConjecture = context.findAxiomLemmaTheoremConjectureByReference(reference);
+
+    if (axiomLemmaTheoremConjecture !== null) {
+      const statementString = statement.getString(),
+            axiomLemmaTheoremConjectureString = reference.getString();
+
+      context.trace(`Unifying the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`);
+
+      const proofSteps = context.getProofSteps(),
+            statementAndProofStepsUnified = axiomLemmaTheoremConjecture.unifyStatementAndProofSteps(statement, proofSteps, context);
+
+      if (statementAndProofStepsUnified) {
+        const metavariable = reference.getMetavariable(),
+              statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
+              substitution = statementSubstitution; ///
+
+        substitutions.addSubstitution(substitution, context);
+
+        unifiedWithAxiomLemmaTheoremOrConjecture = true;
+      }
+
+      if (unifiedWithAxiomLemmaTheoremOrConjecture) {
+        context.debug(`...unified the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`);
+      }
+    }
+  }
+
+  return unifiedWithAxiomLemmaTheoremOrConjecture;
+}
+
+function unifyWithProofSteps(statement, reference, substitutions, context) {
+  let unifiedWithProofSteps = false;
+
+  if (reference === null) {
+    const proofSteps = context.getProofSteps(),
+          statementUnifiedWithProofSteps = statement.unifyWithProofSteps(proofSteps, context);
+
+    unifiedWithProofSteps = statementUnifiedWithProofSteps; ///
+  }
+
+  return unifiedWithProofSteps;
+}
+
+const unifyMixins = [
+  unifyAWithRule,
+  unifyAWithReference,
+  unifyAWithAxiomLemmaTheoremOrConjecture,
+  unifyWithProofSteps
+];
+
+export default unifyMixins;
+

package/src/mixins/statement/verify.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import BracketedCombinator from "../../combinator/bracketed";
+
 import { equalityFromStatement,
          judgementFromStatement,
          metavariableFromStatement,
@@ -162,6 +164,34 @@ function verifyAsSubproofAssertion(statement, assignments, stated, context) {
   return verifiedAsSubproofAssertion;
 }
 
+function unifyWithBracketedCombinator(statement, assignments, stated, context) {
+  stated = true;  ///
+
+  assignments = null; ///
+
+  const bracketedCombinator = BracketedCombinator.fromNothing(),
+        unifiedWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
+
+  return unifiedWithBracketedCombinator;
+}
+
+function unifyWithCombinators(statement, assignments, stated, context) {
+  stated = true;  ///
+
+  assignments = null; ///
+
+  const combinators = context.getCombinators(),
+        unifiedWithCombinators = combinators.some((combinator) => {
+          const unifiedWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
+
+          if (unifiedWithCombinator) {
+            return true;
+          }
+        });
+
+  return unifiedWithCombinators;
+}
+
 const verifyMixins = [
   verifyAsMetavariable,
   verifyAsEquality,
@@ -169,7 +199,9 @@ const verifyMixins = [
   verifyAsTypeAssertion,
   verifyAsDefinedAssertion,
   verifyAsSubproofAssertion,
-  verifyAsContainedAssertion
+  verifyAsContainedAssertion,
+  unifyWithBracketedCombinator,
+  unifyWithCombinators
 ];
 
 export default verifyMixins;

package/src/mixins/term/verify.js

@@ -1,6 +1,8 @@
 "use strict";
 
-import shim from "../../shim";
+import dom from "../../dom";
+
+import BracketedConstructor from "../../constructor/bracketed";
 
 import { nodeQuery } from "../../utilities/query";
 
@@ -9,7 +11,7 @@ const variableNodeQuery = nodeQuery("/term/variable!");
 function verifyTermAsVariable(term, localContext, verifyAhead) {
   let termVerifiedAsVariable = false;
 
-  const { Variable } = shim,
+  const { Variable } = dom,
         context = localContext, ///
         termNode = term.getNode(),
         variableNode = variableNodeQuery(termNode),
@@ -42,8 +44,36 @@ function verifyTermAsVariable(term, localContext, verifyAhead) {
   return termVerifiedAsVariable;
 }
 
+function unifyWithBracketedConstructor(term, context, verifyAhead) {
+  let unifiedWithBracketedConstructor;
+
+  const bracketedConstructor = BracketedConstructor.fromNothing();
+
+  unifiedWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, verifyAhead);
+
+  return unifiedWithBracketedConstructor;
+}
+
+function unifyWithConstructors(term, context, verifyAhead) {
+  let unifiedWithConstructors;
+
+  const constructors = context.getConstructors();
+
+  unifiedWithConstructors = constructors.some((constructor) => {
+    const unifiedWithConstructor = constructor.unifyTerm(term, context, verifyAhead);
+
+    if (unifiedWithConstructor) {
+      return true;
+    }
+  });
+
+  return unifiedWithConstructors;
+}
+
 const verifyMixins = [
-  verifyTermAsVariable
+  verifyTermAsVariable,
+  unifyWithBracketedConstructor,
+  unifyWithConstructors
 ];
 
 export default verifyMixins;

package/src/substitution/frame.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import Substitution from "../substitution";
 import FrameSubstitutionNodeAndTokens from "../nodeAndTokens/substitution/frame";
 
@@ -40,7 +40,7 @@ export default class FrameSubstitution extends Substitution {
             metavariableNode = metavariableNodeQuery(frameSubstitutionNode);
 
       if ((frameNode !== null) && (metavariableNode !== null)) {
-        const { Frame, Metavariable } = shim,
+        const { Frame, Metavariable } = dom,
               frame = Frame.fromFrameNode(frameNode, context),
               metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
               node = frameSubstitutionNode,  ///

package/src/substitution/statement.js

@@ -1,15 +1,14 @@
 "use strict";
 
-import shim from "../shim";
 import Substitution from "../substitution";
+import Substitutions from "../substitutions";
 import StatementSubstitutionNodeAndTokens from "../nodeAndTokens/substitution/statement";
 
 import { unifySubstitution } from "../utilities/unification";
 import { stripBracketsFromStatement } from "../utilities/verification";
-import { stripBracketsFromStatementNode } from "../utilities/brackets";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
-class StatementSubstitution extends Substitution {
+export default class StatementSubstitution extends Substitution {
   constructor(string, node, tokens, resolved, statement, metavariable, substitution) {
     super(string, node, tokens);
 
@@ -35,17 +34,27 @@ class StatementSubstitution extends Substitution {
     return this.substitution;
   }
 
-  isStatementEqualTo(statement) { return this.statement.isEqualTo(statement); }
+  isStatementEqualTo(statement, context) {
+    statement = stripBracketsFromStatement(statement, context); ///
+
+    const statementEqualTo = this.statement.isEqualTo(statement);
+
+    return statementEqualTo;
+  }
 
   isMetavariableEqualTo(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
   isSubstitutionEqualTo(substitution) {
-    let substitutionEqualTo = false;
-
-    if (this.substitution === null) {
-      if (substitution === null) {
-        substitutionEqualTo = true;
-      }
+    let substitutionEqualTo;
+
+    if (false) {
+      ///
+    } else if ((substitution === null) && (this.substitution === null)) {
+      substitutionEqualTo = true;
+    } else if ((substitution !== null) && (this.substitution === null)) {
+      substitutionEqualTo = false;
+    } else if ((substitution === null) && (this.substitution !== null)) {
+      substitutionEqualTo = false;
     } else {
       substitutionEqualTo = this.substitution.isEqualTo(substitution);
     }
@@ -123,8 +132,7 @@ class StatementSubstitution extends Substitution {
   unifyStatement(statement, generalContext, specificContext) {
     let specificSubstitution = null;
 
-    const { Substitutions } = shim,
-          substitutions = Substitutions.fromNothing(),
+    const substitutions = Substitutions.fromNothing(),
           statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
@@ -198,12 +206,6 @@ class StatementSubstitution extends Substitution {
   }
 }
 
-Object.assign(shim, {
-  StatementSubstitution
-});
-
-export default StatementSubstitution;
-
 function stringFromStatementAndMetavariable(statement, metavariable) {
   const statementString = statement.getString(),
         metavariableString = metavariable.getString(),

package/src/substitution/term.js

@@ -1,10 +1,11 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../dom";
 import Substitution from "../substitution";
 import TermSubstitutionNodeAndTokens from "../nodeAndTokens/substitution/term";
 
 import { nodeQuery } from "../utilities/query";
+import { stripBracketsFromTerm } from "../utilities/verification";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
 
 const termNodeQuery = nodeQuery("/termSubstitution/term[0]"),
@@ -27,11 +28,17 @@ export default class TermSubstitution extends Substitution {
     return this.variable;
   }
 
-  isTermEqualTo(term) { return this.term.isEqualTo(term); }
+  isTermEqualTo(term, context) {
+    term = stripBracketsFromTerm(term); ///
+
+    const termEqualTo = this.term.isEqualTo(term);
+
+    return termEqualTo;
+  }
 
   isVariableEqualTo(variable) { return this.variable.isEqualTo(variable); }
 
-  unifyWithEquivalence(equivalence, substitutions, generalContext, specificContext) {
+  unifyWithEquivalence(equivalence) {
     let unifiedWithEquivalence;
 
     const termNode = this.term.getNode(),
@@ -59,7 +66,7 @@ export default class TermSubstitution extends Substitution {
             variableNode = variableNodeQuery(termSubstitutionNode);
 
       if ((termNode !== null) && (variableNode !== null)) {
-        const { Term, Variable } = shim,
+        const { Term, Variable } = dom,
               term = Term.fromTermNode(termNode, context),
               variable = Variable.fromVariableNode(variableNode, context),
               node = termSubstitutionNode,  ///
@@ -78,7 +85,7 @@ export default class TermSubstitution extends Substitution {
 
     termNode = stripBracketsFromTermNode(termNode); ///
 
-    const { Term } = shim;
+    const { Term } = dom;
 
     term = Term.fromTermNode(termNode, context);
 

package/src/substitution.js

@@ -1,8 +1,6 @@
 "use strict";
 
-import shim from "./shim";
-
-class Substitution {
+export default class Substitution {
   constructor(string, node, tokens) {
     this.string = string;
     this.node = node;
@@ -71,13 +69,8 @@ class Substitution {
   }
 
   isEqualTo(substitution) {
-    let equalTo = false;
-
-    if (substitution !== null) {
-      const substitutionString = substitution.getString();
-
-      equalTo = (substitutionString === this.string);
-    }
+    const substitutionString = substitution.getString(),
+          equalTo = (substitutionString === this.string);
 
     return equalTo;
   }
@@ -124,27 +117,9 @@ class Substitution {
     return resolved;
   }
 
-  unifyWithEquivalence(equivalence, substitutions, generalContext, specificContext) {
+  unifyWithEquivalence(equivalence) {
     let unifiedWithEquivalence = false;
 
     return unifiedWithEquivalence;
   }
-
-  unifyWithEquivalences(equivalences, substitutions, generalContext, specificContext) {
-    const unifiedWithEquivalences = equivalences.some((equivalence) => {
-      const substitutionUnifiedWithEquivalence = this.unifyWithEquivalence(equivalence, substitutions, generalContext, specificContext);
-
-      if (substitutionUnifiedWithEquivalence) {
-        return true;
-      }
-    });
-
-    return unifiedWithEquivalences;
-  }
 }
-
-Object.assign(shim, {
-  Substitution
-});
-
-export default Substitution;

package/src/substitutions.js

@@ -1,14 +1,12 @@
 "use strict";
 
-import shim from "./shim";
-
 import { arrayUtilities } from "necessary";
 
 import { EMPTY_STRING } from "./constants";
 
 const { find, first, clear, prune, filter, compress } = arrayUtilities;
 
-class Substitutions {
+export default class Substitutions {
   constructor(array, savedArray) {
     this.array = array;
     this.savedArray = savedArray;
@@ -75,13 +73,6 @@ class Substitutions {
     return substitutions;
   }
 
-  filterSubstitution(callback) {
-    const array = this.array.filter(callback),
-          substitutions = Substitutions.fromArray(array);
-
-    return substitutions;
-  }
-
   findSubstitutionByVariable(variable) {
     const substitution = this.findSubstitution((substitution) => {
       const substitutionVariable = substitution.getVariable();
@@ -98,18 +89,6 @@ class Substitutions {
     return substitution;
   }
 
-  findSubstitutionByMetavariable(metavariable) {
-    const substitution = this.findSubstitution((substitution) => {
-      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualTo(metavariable);
-
-      if (substitutionMetavariableEqualToMetavariable) {
-        return true;
-      }
-    });
-
-    return substitution;
-  }
-
   findSubstitutionsByMetavariable(metavariable) {
     const substitutions = this.findSubstitutions((substitution) => {
       const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualTo(metavariable);
@@ -123,54 +102,54 @@ class Substitutions {
   }
 
   findSimpleSubstitutionByMetavariable(metavariable) {
-    const substitutions = this.findSubstitutionsByMetavariable(metavariable),
-          simpleSubstitutions = substitutions.filterSubstitution((substitution) => {
-            const substitutionSimple = substitution.isSimple();
+    const simpleSubstitution = this.findSubstitution((substitution) => {
+      const substitutionSimple = substitution.isSimple();
 
-            if (substitutionSimple) {
-              return true;
-            }
-          }),
-          firstSimpleSubstitution = simpleSubstitutions.getFirstSubstitution(),
-          simpleSubstitution = firstSimpleSubstitution; ///
+      if (substitutionSimple) {
+        const simpleSubstitution = substitution,  ///
+              simpleSubstitutionMetavariableEqualToMetavariable = simpleSubstitution.isMetavariableEqualTo(metavariable);
+
+        if (simpleSubstitutionMetavariableEqualToMetavariable) {
+          return true;
+        }
+      }
+    });
 
     return simpleSubstitution;
   }
 
   findComplexSubstitutionsByMetavariable(metavariable) {
-    const substitutions = this.findSubstitutionsByMetavariable(metavariable),
-          complexSubstitutions = substitutions.filterSubstitution((substitution) => {
-            const substitutionComplex = substitution.isComplex();
+    const complexSubstitutions = this.findSubstitutions((substitution) => {
+      const substitutionComplex = substitution.isComplex();
 
-            if (substitutionComplex) {
-              return true;
-            }
-          });
+      if (substitutionComplex) {
+        const complexSubstitution = substitution, ///
+              complexSubstitutionMetavariableEqualToMetavariable = complexSubstitution.isMetavariableEqualTo(metavariable);
+
+        if (complexSubstitutionMetavariableEqualToMetavariable) {
+          return true;
+        }
+      }
+    });
 
     return complexSubstitutions;
   }
 
   findSubstitutionByMetavariableAndSubstitution(metavariable, substitution) {
-    const substitutionA = substitution, ///
-          substitutions = this.findSubstitutions((substitution) => {
-            const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualTo(metavariable);
-
-            if (substitutionMetavariableEqualToMetavariable) {
-              const substitutionSubstitution = substitution.getSubstitution();
+    const substitutionA = substitution; ///
 
-              if (substitutionSubstitution !== null) {
-                const substitutionB = substitution, ///
-                      substitutionBSubstitutionEqualToSubstitutionB = substitutionB.isSubstitutionEqualTo(substitutionA);
+    substitution = this.findSubstitution((substitution) => {  ///
+      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualTo(metavariable);
 
-                if (substitutionBSubstitutionEqualToSubstitutionB) {
-                  return true;
-                }
-              }
-            }
-          }),
-          firstSubstitution = substitutions.getFirstSubstitution();
+      if (substitutionMetavariableEqualToMetavariable) {
+        const substitutionB = substitution, ///
+              substitutionBSubstitutionEqualToSubstitutionA = substitutionB.isSubstitutionEqualTo(substitutionA);
 
-    substitution = firstSubstitution; ///
+        if (substitutionBSubstitutionEqualToSubstitutionA) {
+          return true;
+        }
+      }
+    });
 
     return substitution;
   }
@@ -221,19 +200,6 @@ class Substitutions {
     context.trace(`Removed the ${substitutionString} substitution.`);
   }
 
-  unifyWithEquivalences(equivalences, context) {
-    const unifiedWithEquivalences = this.everySubstitution((substitution) => {
-      const substitutions = this, ///
-            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, context);
-
-      if (substitutionUnifiedWithEquivalence) {
-        return true;
-      }
-    });
-
-    return unifiedWithEquivalences;
-  }
-
   clear() {
     clear(this.array);
 
@@ -248,7 +214,7 @@ class Substitutions {
             complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
               let resolved;
 
-              const substitutions = this,
+              const substitutions = this, ///
                     substitution = complexSubstitution; ///
 
               resolved = substitution.isResolved();
@@ -346,10 +312,6 @@ class Substitutions {
   }
 }
 
-Object.assign(shim, {
-  Substitutions
-});
-
 function leftDifference(arrayA, arrayB) {
   filter(arrayA, (elementA) => {
     const arrayBIncludesElementA = arrayB.includes(elementA);