occam-verify-cli 0.0.1248 → 0.0.1249

package/src/dom/frame.js

@@ -4,6 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
 
+import { S, NOTHING } from "../constants";
 import { domAssigned } from "../dom";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -70,6 +71,64 @@ export default domAssigned(class Frame {
     return equalTo;
   }
 
+  matchSubstitution(substitution, context) {
+    let substitutionMatches = false;
+
+    const frameString = this.string,  ///
+          substitutionString = substitution.getString();
+
+    context.trace(`Matching the '${substitutionString}' substitution with the '${frameString}' frame...`);
+
+    if (!substitutionMatches) {
+      substitutionMatches = this.declarations.some((declaration) => {
+        const substitutionMatchesDeclaration = declaration.matchSubstitution(substitution, context);
+
+        if (substitutionMatchesDeclaration) {
+          return true;
+        }
+      });
+    }
+
+    if (!substitutionMatches) {
+      substitutionMatches = this.metavariables.some((metavariable) => {
+        const substitutionMatchesMetavariable = metavariable.matchSubstitution(substitution, context);
+
+        if (substitutionMatchesMetavariable) {
+          return true;
+        }
+      });
+    }
+
+    if (substitutionMatches) {
+      context.debug(`...matched the '${substitutionString}' substitutions with the '${frameString}' frame.`);
+    }
+
+    return substitutionMatches;
+  }
+
+  matchSubstitutions(substitutions, context) {
+    let substitutionsMatch;
+
+    const frameString = this.string,  ///
+          substitutionsString = substitutions.asString();
+
+    context.trace(`Matching the '${substitutionsString}' substitutions with the '${frameString}' frame...`);
+
+    substitutionsMatch = substitutions.everySubstitution((substitution) => {
+      const substitutionMatches = this.matchSubstitution(substitution, context);
+
+      if (substitutionMatches) {
+        return true;
+      }
+    });
+
+    if (substitutionsMatch) {
+      context.debug(`...matched the '${substitutionsString}' substitutions with the '${frameString}' frame.`);
+    }
+
+    return substitutionsMatch;
+  }
+
   verify(assignments, stated, context) {
     let verified = false;
 
@@ -89,7 +148,7 @@ export default domAssigned(class Frame {
         if (stated) {
           verifiedWhenStated = this.verifyWhenStated(assignments, context);
         } else {
-          verifiedWhenDerived = this.verifyWhenDerived(assignments, context);
+          verifiedWhenDerived = this.verifyWhenDerived(context);
         }
 
         if (verifiedWhenStated || verifiedWhenDerived) {
@@ -105,53 +164,6 @@ export default domAssigned(class Frame {
     return verified;
   }
 
-  verifyDeclarations(assignments, stated, context) {
-    let declarationsVerified;
-
-    const frameString = this.string,  ///
-          declarationsString = declarationsStringFromDeclarations(this.declarations);
-
-    context.trace(`Verifying the '${frameString}' frame's '${declarationsString}' declarations...`);
-
-    stated = true;  ///
-
-    assignments = null; ///
-
-    declarationsVerified = this.declarations.every((declaration) => {
-      const frame = null, ///
-            declarationVerified = declaration.verify(frame, assignments, stated, context);
-
-      return declarationVerified;
-    });
-
-    if (declarationsVerified) {
-      context.debug(`...verified the '${frameString}' frame's '${declarationsString}' declarations.`);
-    }
-
-    return declarationsVerified;
-  }
-
-  verifyMetavariables(assignments, stated, context) {
-    let metavariablesVerified;
-
-    const frameString = this.string,  ///
-          metavariablesString = metavariablesStringFromDeclarations(this.metavariables);
-
-    context.trace(`Verifying the '${frameString}' frame's '${metavariablesString}' metavariables...`);
-
-    metavariablesVerified = this.metavariables.every((metavariable) => {
-      const metavariableVerified = metavariable.verify(context);
-
-      return metavariableVerified;
-    });
-
-    if (metavariablesVerified) {
-      context.debug(`...verified the '${frameString}' frame's '${metavariablesString}' metavariables.`);
-    }
-
-    return metavariablesVerified;
-  }
-
   verifyWhenStated(assignments, context) {
     let verifiedWhenStated = false;
 
@@ -180,7 +192,7 @@ export default domAssigned(class Frame {
     return verifiedWhenStated;
   }
 
-  verifyWhenDerived(assignments, context) {
+  verifyWhenDerived(context) {
     let verifiedWhenDerived;
 
     const frameString = this.string;  ///
@@ -196,114 +208,88 @@ export default domAssigned(class Frame {
     return verifiedWhenDerived;
   }
 
-  verifyGivenMetaType(metaType, assignments, stated, context) {
-    let verifiedGivenMetaType = false;
-
-    const frameString = this.string,  ///
-          metaTypeString = metaType.getString();
-
-    context.trace(`Verifying the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
-
-    const metaTypeName = metaType.getName();
-
-    if (metaTypeName === FRAME_META_TYPE_NAME) {
-      const verified = this.verify(assignments, stated, context)
-
-      verifiedGivenMetaType = verified; ///
-    }
-
-    if (verifiedGivenMetaType) {
-      context.debug(`...verified the '${frameString}' frame given the '${metaTypeString}' meta-type.`);
-    }
-
-    return verifiedGivenMetaType;
-  }
+  verifyDeclarations(assignments, stated, context) {
+    let declarationsVerified = true;  ///
 
-  unifySubstitution(substitution, context) {
-    let substitutionUnified = false;
+    const declarationsLength = this.declarations.length;
 
-    const frameString = this.string,  ///
-          substitutionString = substitution.getString();
+    if (declarationsLength > 0) {
+      const sOrNothing = (declarationsLength > 1) ?
+                           S :
+                             NOTHING,
+            frameString = this.string,  ///
+            declarationsString = declarationsStringFromDeclarations(this.declarations);
 
-    context.trace(`Unifying the '${substitutionString}' substitution with the '${frameString}' frame...`)
+      context.trace(`Verifying the '${frameString}' frame's '${declarationsString}' declaration${sOrNothing}...`);
 
-    if (!substitutionUnified) {
-      substitutionUnified = this.declarations.some((declaration) => {
-        const substitutionUnified = declaration.unifySubstitution(substitution, context);
+      stated = true;  ///
 
-        if (substitutionUnified) {
-          return true;
-        }
-      });
-    }
+      assignments = null; ///
 
-    if (!substitutionUnified) {
-      substitutionUnified = this.metavariables.some((metavariable) => {
-        const substitutionUnified = metavariable.unifySubstitution(substitution, context);
+      declarationsVerified = this.declarations.every((declaration) => {
+        const frame = null, ///
+              declarationVerified = declaration.verify(frame, assignments, stated, context);
 
-        if (substitutionUnified) {
-          return true;
-        }
+        return declarationVerified;
       });
-    }
 
-    if (substitutionUnified) {
-      context.debug(`...unified the '${substitutionString}' substitution with the '${frameString}' frame...`)
+      if (declarationsVerified) {
+        context.debug(`...verified the '${frameString}' frame's '${declarationsString}' declaration${sOrNothing}.`);
+      }
     }
 
-    return substitutionUnified;
+    return declarationsVerified;
   }
 
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnified;
+  verifyMetavariables(assignments, stated, context) {
+    let metavariablesVerified = true;
 
-    const frameString = this.string,  ///
-          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+    const metavariablesLength = this.metavariables.length;
 
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame...`);
+    if (metavariablesLength > 0) {
+      const sOrNothing = (metavariablesLength > 1) ?
+                           S :
+                             NOTHING,
+            frameString = this.string,  ///
+            metavariablesString = metavariablesStringFromDeclarations(this.metavariables);
 
-    const substitutions = metaLemmaMetatheorem.getSubstitutions(),
-          substitutionsUnified = substitutions.everySubstitution((substitution) => {
-            const substitutionUnified = this.unifySubstitution(substitution, context);
+      context.trace(`Verifying the '${frameString}' frame's '${metavariablesString}' metavariable${sOrNothing}...`);
 
-            if (substitutionUnified) {
-              return true;
-            }
-          });
+      metavariablesVerified = this.metavariables.every((metavariable) => {
+        const metavariableVerified = metavariable.verify(context);
 
-    metaLemmaMetatheoremUnified = substitutionsUnified; ///
+        return metavariableVerified;
+      });
 
-    if (metaLemmaMetatheoremUnified) {
-      context.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame.`);
+      if (metavariablesVerified) {
+        context.debug(`...verified the '${frameString}' frame's '${metavariablesString}' metavariable${sOrNothing}.`);
+      }
     }
 
-    return metaLemmaMetatheoremUnified;
+    return metavariablesVerified;
   }
 
-  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context) {
-    let axiomLemmaTheoremOrConjectureUnified;
+  verifyGivenMetaType(metaType, assignments, stated, context) {
+    let verifiedGivenMetaType = false;
 
     const frameString = this.string,  ///
-          axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
+          metaTypeString = metaType.getString();
 
-    context.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame...`);
+    context.trace(`Verifying the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
 
-    const substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(),
-          substitutionsUnified = substitutions.everySubstitution((substitution) => {
-            const substitutionUnified = this.unifySubstitution(substitution, context);
+    const metaTypeName = metaType.getName();
 
-            if (substitutionUnified) {
-              return true;
-            }
-          });
+    if (metaTypeName === FRAME_META_TYPE_NAME) {
+      const verified = this.verify(assignments, stated, context)
 
-    axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///
+      verifiedGivenMetaType = verified; ///
+    }
 
-    if (axiomLemmaTheoremOrConjectureUnified) {
-      context.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame.`);
+    if (verifiedGivenMetaType) {
+      context.debug(`...verified the '${frameString}' frame given the '${metaTypeString}' meta-type.`);
     }
 
-    return axiomLemmaTheoremOrConjectureUnified;
+    return verifiedGivenMetaType;
   }
 
   static name = "Frame";

package/src/dom/judgement.js

@@ -53,7 +53,9 @@ export default domAssigned(class Judgement {
           verifiedWhenDerived = this.verifyWhenDerived(context);
         }
 
-        verified = (verifiedWhenStated || verifiedWhenDerived);
+        if (verifiedWhenStated || verifiedWhenDerived) {
+          verified = true;
+        }
       }
     }
 

package/src/dom/label.js

@@ -34,9 +34,22 @@ export default domAssigned(class Label {
     return metavariableNode;
   }
 
-  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
+  matchReference(reference) {
+    const metavariable = reference.getMetavariable(),
+          metavariableMatches = this.matchMetavariable(metavariable),
+          referenceMatches = metavariableMatches; ///
+
+    return referenceMatches;
+  }
+
+  matchMetavariable(metavariable) {
+    const matches = this.metavariable.match(metavariable),
+          metavariableMatches = matches;  ///
 
-  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+    return metavariableMatches;
+  }
+
+  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 
   verify(nameOnly) {
     let verified = false;
@@ -52,9 +65,9 @@ export default domAssigned(class Label {
 
       labelPresent = this.fileContext.isLabelPresentByMetavariableName(metavariableName);
     } else {
-      const metavariableNode = this.getMetavariableNode();
+      const metavariable = this.getMetavariable();
 
-      labelPresent = this.fileContext.isLabelPresentByMetavariableNode(metavariableNode);
+      labelPresent = this.fileContext.isLabelPresentByMetavariable(metavariable);
     }
 
     if (labelPresent) {

package/src/dom/metavariable.js

@@ -70,12 +70,6 @@ export default domAssigned(class Metavariable {
     return metavariableNameMatches;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = metavariableNode.match(this.node);
-
-    return metavariableNodeMatches;
-  }
-
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
   isEqualTo(metavariable) {
@@ -85,13 +79,21 @@ export default domAssigned(class Metavariable {
     return equalTo;
   }
 
-  unifySubstitution(substitution, context) {
-    let substitutionUnified = false;
+  match(metavariable) {
+    const metavariableNode = metavariable.getNode(),
+          metavariableNodeMatchesNode = this.node.match(metavariableNode),
+          matches = metavariableNodeMatchesNode;  ///
+
+    return matches;
+  }
+
+  matchSubstitution(substitution, context) {
+    let substitutionMatched = false;
 
     const metavariableString = this.string,  ///
           substitutionString = substitution.getString();
 
-    context.trace(`Unifying the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
+    context.trace(`Matching the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
 
     const metavariable = this, ///
           judgement = context.findJudgementByMetavariable(metavariable);
@@ -99,14 +101,16 @@ export default domAssigned(class Metavariable {
     if (judgement !== null) {
       const declaration = judgement.getDeclaration();
 
-      substitutionUnified = declaration.unifySubstitution(substitution, context);
+      substitutionMatched = declaration.matchSubstitution(substitution, context);
+    } else {
+      context.debug(`The '${metavariableString}' metavariable does not have a judgement.`);
     }
 
-    if (substitutionUnified) {
-      context.debug(`...unified the '${substitutionString}' substitution with the '${metavariableString}' metavariable.`);
+    if (substitutionMatched) {
+      context.debug(`...matched the '${substitutionString}' substitution with the '${metavariableString}' metavariable.`);
     }
 
-    return substitutionUnified;
+    return substitutionMatched;
   }
 
   unifyFrame(frame, substitutions, generalContext, specificContext) {

package/src/dom/reference.js

@@ -2,12 +2,13 @@
 
 import dom from "../dom";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { referenceMetaType } from "../dom/metaType";
+import { unifyMetavariableIntrinsically } from "../utilities/unification";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
-import { unifyLabelWithReference, unifyMetavariableWithReference } from "../utilities/unification";
 
 const proofStepReferenceNodeQuery = nodeQuery("/proofStep/reference"),
       procedureCallReferenceNodeQuery = nodeQuery("/procedureCall/reference"),
@@ -38,9 +39,14 @@ export default domAssigned(class Reference {
     return metavariableNode;
   }
 
-  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
+  matchMetavariable(metavariable) {
+    const matches = this.metavariable.match(metavariable),
+          metavariableMatches = matches;  ///
+
+    return metavariableMatches;
+  }
 
-  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 
   verify(context) {
     let verified = false;
@@ -80,7 +86,7 @@ export default domAssigned(class Reference {
     return metavariableVerified;
   }
 
-  unifyLabel(label, context) {
+  unifyLabel(label, substitutions, context) {
     let labelUnified;
 
     const reference = this, ///
@@ -89,9 +95,15 @@ export default domAssigned(class Reference {
 
     context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
-    const labelUnifiedWithReference = unifyLabelWithReference(label, reference,  context);
+    const fileContext = label.getFileContext(),
+          generalContext = context, ///
+          specificContext = fileContext,  ///
+          labelMetavariable = label.getMetavariable(),
+          generalMetavariable = this.metavariable,  ///
+          specificMetavariable = labelMetavariable, ///
+          metavariableUnifiedIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
 
-    labelUnified = labelUnifiedWithReference; ///
+    labelUnified = metavariableUnifiedIntrinsically; ///
 
     if (labelUnified) {
       context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
@@ -100,66 +112,52 @@ export default domAssigned(class Reference {
     return labelUnified;
   }
 
-  unifyMetaLemma(metaLemma, context) {
-    let metaLemmaUnified;
+  unifyMetavariable(metavariable, context) {
+    let metavariableUnified;
 
     const reference = this, ///
-          referenceString = reference.getString(),
-          metaLemmaString = metaLemma.getString();
+          metavariableString = metavariable.getString(),
+          referenceString = reference.getString();
 
-    context.trace(`Unifying the '${metaLemmaString}' meta-lemma with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const label = metaLemma.getLabel(),
-          labelUnified = this.unifyLabel(label, context);
+    const fileContext = context.getFileContext(),
+          substitutions = Substitutions.fromNothing(),
+          generalContext = context, ///
+          specificContext = fileContext,  ///
+          generalMetavariable = this.metavariable,  ///
+          specificMetavariable = metavariable, ///
+          metavariableUnifiedIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
 
-    metaLemmaUnified = labelUnified;  ///
+    metavariableUnified = metavariableUnifiedIntrinsically; ///
 
-    if (metaLemmaUnified) {
-      context.trace(`...unified the '${metaLemmaString}' meta-lemma with the '${referenceString}' reference.`);
+    if (metavariableUnified) {
+      context.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
     }
 
-    return metaLemmaUnified;
+    return metavariableUnified;
   }
 
-  unifyMetatheorem(metatheorem, context) {
-    let metatheoremUnified;
+  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
+    let metaLemmaMetatheoremUnified;
 
     const reference = this, ///
           referenceString = reference.getString(),
-          metatheoremString = metatheorem.getString();
+          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
 
-    context.trace(`Unifying the '${metatheoremString}' metatheorem with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference...`);
 
-    const label = metatheorem.getLabel(),
-          labelUnified = this.unifyLabel(label, context);
+    const label = metaLemmaMetatheorem.getLabel(),
+          substitutions = Substitutions.fromNothing(),
+          labelUnified = this.unifyLabel(label, substitutions, context);
 
-    metatheoremUnified = labelUnified;  ///
+    metaLemmaMetatheoremUnified = labelUnified;  ///
 
-    if (metatheoremUnified) {
-      context.trace(`...unified the '${metatheoremString}' metatheorem with the '${referenceString}' reference.`);
+    if (metaLemmaMetatheoremUnified) {
+      context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference.`);
     }
 
-    return metatheoremUnified;
-  }
-
-  unifyMetavariable(metavariable, context) {
-    let metavariableUnified;
-
-    const reference = this, ///
-          metavariableString = metavariable.getString(),
-          referenceString = reference.getString();
-
-    context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
-
-    const metavariableUnifiedWithReference = unifyMetavariableWithReference(metavariable, reference,  context);
-
-    metavariableUnified = metavariableUnifiedWithReference; ///
-
-    if (metavariableUnified) {
-      context.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
-    }
-
-    return metavariableUnified;
+    return metaLemmaMetatheoremUnified;
   }
 
   toJSON() {

package/src/dom/rule.js

@@ -57,8 +57,6 @@ export default domAssigned(class Rule {
     return this.proof;
   }
 
-  matchStatementNode(statementNode) { return this.conclusion.matchStatementNode(statementNode); }
-
   matchMetavariableName(metavariableName) {
     const metavariableNameMatches = this.labels.some((label) => {
       const metavariableNameMatches = label.matchMetavariableName(metavariableName);
@@ -230,8 +228,7 @@ export default domAssigned(class Rule {
           labels = labelsFromJSON(json, fileContext),
           premises = premisesFromJSON(json, fileContext),
           conclusion = conclusionFromJSON(json, fileContext),
-          labelsString = labelsStringFromLabels(labels),
-          string = labelsString;  ///
+          string = stringFromLabelsAndConclusion(labels, conclusion);
 
     rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
@@ -243,8 +240,7 @@ export default domAssigned(class Rule {
           premises = premisesFromRuleNode(ruleNode, fileContext),
           conclusion = conclusionFromRuleNode(ruleNode, fileContext),
           proof = proofFromRuleNode(ruleNode, fileContext),
-          labelsString = labelsStringFromLabels(labels),
-          string = labelsString,  ///
+          string = stringFromLabelsAndConclusion(labels, conclusion),
           rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
     return rule;
@@ -289,4 +285,12 @@ function conclusionFromRuleNode(ruleNode, fileContext) {
         conclusion = Conclusion.fromConclusionNode(conclusionNode, fileContext);
 
   return conclusion;
-}
+}
+
+function stringFromLabelsAndConclusion(labels, conclusion) {
+  const conclusionString = conclusion.getString(),
+        labelsString = labelsStringFromLabels(labels),
+        string = `${labelsString} :: ${conclusionString}`;
+
+  return string;
+}