occam-verify-cli 0.0.1066 → 0.0.1068

package/src/resolve/substitution.js

@@ -1,19 +0,0 @@
-"use strict";
-
-import resolveComplexSubstitutionAgainstSimpleSubstitution from "../resolve/complexSubstitutionAgainstSimpleSubstitution";
-
-export default function resolveSubstitution(substitution, substitutions, localContextA, localContextB) {
-  let complexSubstitutionResolved = false;
-
-  const metavariableNode = substitution.getMetavariableNode(),
-        simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
-
-  if (simpleSubstitution !== null) {
-    const complexSubstitution = substitution, ///
-          complexSubstitutionResolvedAgainstSimpleSubstitution = resolveComplexSubstitutionAgainstSimpleSubstitution(complexSubstitution, simpleSubstitution, substitutions, localContextA, localContextB);
-
-    complexSubstitutionResolved = complexSubstitutionResolvedAgainstSimpleSubstitution; ///
-  }
-
-  return complexSubstitutionResolved;
-}

package/src/resolve/substitutions.js

@@ -1,31 +0,0 @@
-"use strict";
-
-import LocalContext from "../context/local";
-import resolveSubstitution from "../resolve/substitution";
-
-export default function resolveSubstitutions(substitutions, fileContextA, localContextB) {
-  let substitutionsResolved = substitutions.areResolved();
-
-  if (!substitutionsResolved) {
-    const localContextA = LocalContext.fromFileContext(fileContextA),
-          metavariableNodes = substitutions.getMetavariableNodes();
-
-    substitutionsResolved = metavariableNodes.every((metavariableNode) => {
-      const complexSubstitutions = substitutions.findComplexSubstitutionsByMetavariableNode(metavariableNode),
-            complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
-              const substitution = complexSubstitution, ///
-                    complexSubstitutionResolved = resolveSubstitution(substitution, substitutions, localContextA, localContextB);
-
-              if (complexSubstitutionResolved) {
-                return true;
-              }
-            });
-
-      if (complexSubstitutionsResolved) {
-        return true;
-      }
-    });
-  }
-
-  return substitutionsResolved;
-}

package/src/unify/metavariableWithFrame.js

@@ -1,40 +0,0 @@
-"use strict";
-
-import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
-
-import { metavariableFromFrameNode } from "../utilities/unify";
-import {metavariableNameFromMetavariableNode} from "../utilities/name";
-
-export default function unifyMetavariableWithFrame(metavariableNodeA, frameNodeB, substitutions, localContextA, localContextB) {
-  let metavariableUnifiedWithFrame = false;
-
-  const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNodeA),
-        substitution = simpleSubstitution;  ///
-
-  if (substitution !== null) {
-    const frameNodeMatches = substitution.matchFrameNode(frameNodeB);
-
-    if (frameNodeMatches) {
-      metavariableUnifiedWithFrame = true;
-    }
-  } else {
-    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
-          metavariableA = localContextA.findMetavariableByMetavariableName(metavariableNameA),
-          metavariableB = metavariableFromFrameNode(frameNodeB, localContextB);
-
-    if (metavariableA === metavariableB) {
-      metavariableUnifiedWithFrame = true;
-    } else {
-      const frameNode = frameNodeB, ///
-            metavariableNode = metavariableNodeA, ///
-            frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB),
-            substitution = frameForMetavariableSubstitution;  ///
-
-      substitutions.addSubstitution(substitution, localContextA, localContextB);
-
-      metavariableUnifiedWithFrame = true;
-    }
-  }
-
-  return metavariableUnifiedWithFrame;
-}

package/src/unify/simpleSubstitutionStatementWithComplexSubstitutionStatement.js

@@ -1,27 +0,0 @@
-"use strict";
-
-import metaLevelUnifier from "../unifier/metaLevel";
-
-export default function unifyComplexSubstitutionStatementWithSimpleSubstitutionStatement(simpleSubstitutionStatementNode, complexSubstitutionStatementNode, substitutions, localContextA, localContextB) {
-  let simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement;
-
-  const simpleSubstitutionStatementString = localContextB.nodeAsString(simpleSubstitutionStatementNode),
-        complexSubstitutionStatementString = localContextB.nodeAsString(complexSubstitutionStatementNode);
-
-  localContextB.trace(`Unifying the simple substitution's '${simpleSubstitutionStatementString}' statement with the complex substitution's '${complexSubstitutionStatementString}' statement...`, simpleSubstitutionStatementNode);
-
-  const nodeA = complexSubstitutionStatementNode,  ///
-        nodeB = simpleSubstitutionStatementNode;  ///
-
-  localContextA = localContextB;  ///
-
-  const unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-  simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement = unifiedAtMetaLevel;  ///
-
-  if (simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement) {
-    localContextB.trace(`...unified the simple substitution's '${simpleSubstitutionStatementString}' statement with the complex substitution's '${complexSubstitutionStatementString}' statement.`, simpleSubstitutionStatementNode);
-  }
-
-  return simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement;
-}

package/src/verify/declaration.js

@@ -1,113 +0,0 @@
-"use strict";
-
-import shim from "../shim";
-import Reference from "../reference";
-import Declaration from "../declaration"
-import verifyMetavariableGivenMetaType from "../verify/metavariableGivenMetaType";
-
-import { nodeQuery } from "../utilities/query";
-import { referenceMetaType } from "../metaType";
-
-const statementNodeQuery = nodeQuery("/declaration/statement"),
-      metavariableNodeQuery = nodeQuery("/declaration/reference/metavariable"); ///
-
-const verifyDeclarationFunctions = [
-  verifyDerivedDeclaration,
-  verifyStatedDeclaration
-];
-
-export default function verifyDeclaration(declarationNode, declarations, stated, localContext) {
-  let declarationVerified;
-
-  const declarationString = localContext.nodeAsString(declarationNode);
-
-  localContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
-
-  declarationVerified = verifyDeclarationFunctions.some((verifyDeclarationFunction) => {
-    const declarationVerified = verifyDeclarationFunction(declarationNode, declarations, stated, localContext);
-
-    if (declarationVerified) {
-      return true;
-    }
-  });
-
-  if (declarationVerified) {
-    localContext.debug(`...verified the '${declarationString}' declaration.`, declarationNode);
-  }
-
-  return declarationVerified;
-}
-
-function verifyDerivedDeclaration(declarationNode, declarations, stated, localContext) {
-  let derivedDeclarationVerified;
-
-  if (!stated) {
-    const declarationString = localContext.nodeAsString(declarationNode);
-
-    localContext.trace(`Verifying the '${declarationString}' derived declaration...`, declarationNode);
-
-    const metaType = referenceMetaType, ///
-          metavariableNode = metavariableNodeQuery(declarationNode),
-          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
-
-    if (metavariableVerifiedGivenMetaType) {
-      const { verifyStatement } = shim,
-            stated = true,
-            assignments = null,
-            statementNode = statementNodeQuery(declarationNode),
-            statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-      if (statementVerified) {
-        const reference = Reference.fromMetavariableNode(metavariableNode),
-              declaration = Declaration.fromReferenceAndStatementNode(reference, statementNode);
-
-        declarations.push(declaration);
-
-        derivedDeclarationVerified = true;
-      }
-    }
-
-    if (derivedDeclarationVerified) {
-      localContext.debug(`...verified the '${declarationString}' derived declaration.`, declarationNode);
-    }
-  }
-
-  return derivedDeclarationVerified;
-}
-
-function verifyStatedDeclaration(declarationNode, declarations, stated, localContext) {
-  let statedDeclarationVerified = false;
-
-  if (stated) {
-    const declarationString = localContext.nodeAsString(declarationNode);
-
-    localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
-
-    const metaType = referenceMetaType, ///
-          metavariableNode = metavariableNodeQuery(declarationNode),
-          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
-
-    if (metavariableVerifiedGivenMetaType) {
-      const { verifyStatement } = shim,
-            stated = true,
-            assignments = null,
-            statementNode = statementNodeQuery(declarationNode),
-            statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-      if (statementVerified) {
-        const reference = Reference.fromMetavariableNode(metavariableNode),
-              declaration = Declaration.fromReferenceAndStatementNode(reference, statementNode);
-
-        declarations.push(declaration);
-
-        statedDeclarationVerified = true;
-      }
-    }
-
-    if (statedDeclarationVerified) {
-      localContext.debug(`...verified the '${declarationString}' stated declaration.`, declarationNode);
-    }
-  }
-
-  return statedDeclarationVerified;
-}

package/src/verify/frame.js

@@ -1,157 +0,0 @@
-"use strict";
-
-import Frame from "../frame";
-import verifyDeclaration from "../verify/declaration";
-import verifyMetavariableGivenMetaType from "./metavariableGivenMetaType";
-
-import { frameMetaType } from "../metaType";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../utilities/name";
-
-const metavariableNodeQuery = nodeQuery("/frame/metavariable"),
-      declarationNodesQuery = nodesQuery("/frame/declaration"),
-      metavariableNodesQuery = nodesQuery("/frame/metavariable");
-
-const verifyFrameFunctions = [
-  verifyDerivedFrame,
-  verifyStatedFrame
-];
-
-export default function verifyFrame(frameNode, frames, stated, localContext) {
-  let frameVerified;
-
-  const frameString = localContext.nodeAsString(frameNode);
-
-  localContext.trace(`Verifying the '${frameString}' frame...`);
-
-  frameVerified = verifyFrameFunctions.some((verifyFrameFunction) => {
-    const frameVerified = verifyFrameFunction(frameNode, frames, stated, localContext);
-
-    if (frameVerified) {
-      return true;
-    }
-  });
-
-  if (frameVerified) {
-    localContext.debug(`...verified the '${frameString}' frame.`);
-  }
-
-  return frameVerified;
-}
-
-function verifyDerivedFrame(frameNode, frames, stated, localContext) {
-  let derivedFrameVerified;
-
-  if (!stated) {
-    const frameString = localContext.nodeAsString(frameNode);
-
-    localContext.trace(`Verifying the '${frameString}' derived frame...`);
-
-    const declarations = [],
-          declarationNodes = declarationNodesQuery(frameNode),
-          declarationsVerified = declarationNodes.every((declarationNode) => {
-            const declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
-
-            if (declarationVerified) {
-              return true;
-            }
-          });
-
-    if (declarationsVerified) {
-      const metavariableNodes = metavariableNodesQuery(frameNode),
-            metavariablesVerified = metavariableNodes.every((metavariableNode) => {
-              const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
-
-              if (metavariableVerified) {
-                return true;
-              }
-            });
-
-      if (metavariablesVerified) {
-        const frame = Frame.fromDeclarations(declarations);
-
-        frames.push(frame);
-
-        derivedFrameVerified = true; ///
-      }
-    }
-
-    if (derivedFrameVerified) {
-      localContext.debug(`...verified the '${frameString}' derived frame.`);
-    }
-  }
-
-  return derivedFrameVerified;
-}
-
-function verifyStatedFrame(frameNode, frames, stated, localContext) {
-  let statedFrameVerified;
-
-  if (stated) {
-    const frameString = localContext.nodeAsString(frameNode);
-
-    localContext.trace(`Verifying the '${frameString}' stated frame...`);
-
-    const declarationNodes = declarationNodesQuery(frameNode),
-          declarationNodesLength = declarationNodes.length;
-
-    if (declarationNodesLength === 0) {
-      const metavariableNode = metavariableNodeQuery(frameNode);
-
-      if (metavariableNode !== null) {
-        const metaType = frameMetaType, ///
-              metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
-
-        if (metavariableVerifiedGivenMetaType) {
-          const frame = Frame.fromMetavariableNode(metavariableNode);
-
-          frames.push(frame);
-
-          statedFrameVerified = true;
-        }
-      } else {
-        localContext.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);
-      }
-    } else {
-      localContext.trace(`The '${frameString}' stated frame cannot have declarations.`);
-    }
-
-    if (statedFrameVerified) {
-      localContext.debug(`...verified the '${frameString}' stated frame.`);
-    }
-  }
-
-  return statedFrameVerified;
-}
-
-function verifyMetavariable(metavariableNode, declarations, localContext) {
-  let metavariableVerified = false;
-
-  const metavariableString = localContext.nodeAsString(metavariableNode);
-
-  localContext.trace(`Verifying the '${metavariableString}' metavariable...`);
-
-  const metaType = frameMetaType, ///
-        metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
-
-  if (metavariableVerifiedGivenMetaType) {
-    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          judgement = localContext.findJudgementByMetavariableName(metavariableName);
-
-    if (judgement !== null) {
-      const declaration = judgement.getDeclaration();
-
-      declarations.push(declaration);
-
-      metavariableVerified = true;
-    } else {
-      localContext.trace(`There is no judgement for the '${metavariableString}' metavariable.`);
-    }
-  }
-
-  if (metavariableVerified) {
-    localContext.debug(`...verified the '${metavariableString}' metavariable.`);
-  }
-
-  return metavariableVerified;
-}

package/src/verify/judgement.js

@@ -1,127 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import Judgement from "../judgement";
-import verifyFrame from "../verify/frame";
-import verifyDeclaration from "./declaration";
-import JudgementAssignment from "../assignment/judgement";
-
-import { nodeQuery } from "../utilities/query";
-
-const { first } = arrayUtilities;
-
-const frameNodeQuery = nodeQuery("/judgement/frame"),
-      declarationNodeQuery = nodeQuery("/judgement/declaration");
-
-const verifyJudgementFunctions = [
-  verifyDerivedJudgement,
-  verifyStatedJudgement
-];
-
-export default function verifyJudgement(judgementNode, assignments, stated, localContext) {
-  let judgementVerified;
-
-  const judgementString = localContext.nodeAsString(judgementNode);
-
-  localContext.trace(`Verifying the '${judgementString}' judgement...`, judgementNode);
-
-  judgementVerified = verifyJudgementFunctions.some((verifyJudgementFunction) => {
-    const judgementVerified = verifyJudgementFunction(judgementNode, assignments, stated, localContext);
-
-    if (judgementVerified) {
-      return true;
-    }
-  });
-
-  if (judgementVerified) {
-    localContext.debug(`...verified the '${judgementString}' judgement.`, judgementNode);
-  }
-
-  return judgementVerified;
-}
-
-function verifyDerivedJudgement(judgementNode, assignments, stated, localContext) {
-  let derivedJudgementVerified = false;
-
-  if (!stated) {
-    const judgementString = localContext.nodeAsString(judgementNode);
-
-    localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
-
-    const declarations = [],
-          declarationNode = declarationNodeQuery(judgementNode),
-          declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
-
-    if (declarationVerified) {
-      const firstDeclaration = first(declarations),
-            declaration = firstDeclaration, ///
-            metavariableNode = declaration.getMetavariableNode(),
-            metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
-            metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
-            metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
-
-      if (metaLemmaMetatheorem !== null) {
-        const frames = [],
-              frameNode = frameNodeQuery(judgementNode),
-              frameVerified = verifyFrame(frameNode, frames, stated, localContext);
-
-        if (frameVerified) {
-          const firstFrame = first(frames),
-                frame = firstFrame, ///
-                metaLemmaMetatheoremUnified = frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
-
-          derivedJudgementVerified = metaLemmaMetatheoremUnified; ///
-        }
-      }
-    }
-
-    if (derivedJudgementVerified) {
-      localContext.debug(`...verified the '${judgementString}' derived judgement.`, judgementNode);
-    }
-  }
-
-  return derivedJudgementVerified;
-}
-
-function verifyStatedJudgement(judgementNode, assignments, stated, localContext) {
-  let statedJudgementVerified = false;
-
-  if (stated) {
-    const judgementString = localContext.nodeAsString(judgementNode);
-
-    localContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
-
-    const frames = [],
-          frameNode = frameNodeQuery(judgementNode),
-          frameVerified = verifyFrame(frameNode, frames, stated, localContext);
-
-    if (frameVerified) {
-      const declarations = [],
-            declarationNode = declarationNodeQuery(judgementNode),
-            declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
-
-      if (declarationVerified) {
-        if (assignments !== null) {
-          const firstDeclaration = first(declarations),
-                firstFrame = first(frames),
-                frame = firstFrame,
-                declaration = firstDeclaration, ///
-                judgement = Judgement.fromJudgementNodeFrameAndDeclaration(judgementNode, frame, declaration),
-                judgementAssignment = JudgementAssignment.fromJudgement(judgement),
-                assignment = judgementAssignment;
-
-          assignments.push(assignment);
-        }
-
-        statedJudgementVerified = true;
-      }
-    }
-
-    if (statedJudgementVerified) {
-      localContext.debug(`...verified the '${judgementString}' stated judgement.`, judgementNode);
-    }
-  }
-
-  return statedJudgementVerified;
-}

package/src/verify/metavariableGivenMetaType.js

@@ -1,45 +0,0 @@
-"use strict";
-
-import metavariableUnifier from "../unifier/metavariable";
-
-import { metavariableNameFromMetavariableNode } from "../utilities/name";
-
-export default function verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext) {
-  let metavariableVerifiedGivenMetaType = false;
-
-  const metaTypeName = metaType.getName(),
-        metavariableString = localContext.nodeAsString(metavariableNode);
-
-  localContext.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeName}' meta-type...`, metavariableNode);
-
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-
-  if (metavariable !== null) {
-    const metavariableMetaType = metavariable.getMetaType();
-
-    if (metavariableMetaType === metaType) {
-      const metavariableNodeA = metavariableNode; ///
-
-      metavariableNode = metavariable.getNode();
-
-      const metavariableNodeB = metavariableNode; ///
-
-      const metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
-
-      metavariableVerifiedGivenMetaType = metavariableUnified;  ///
-    } else {
-      const metavariableMetaTypeName = metavariableMetaType.getName();
-
-      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metavariableMetaTypeName}' when it should be '${metaTypeName}'.`, metavariableNode);
-    }
-  } else {
-    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
-  }
-
-  if (metavariableVerifiedGivenMetaType) {
-    localContext.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeName}' meta-type.`, metavariableNode);
-  }
-
-  return metavariableVerifiedGivenMetaType;
-}