occam-verify-cli 1.0.814 → 1.0.817

package/src/context/file/nominal.js

@@ -11,22 +11,14 @@ import { verifyFile } from "../../process/verify";
 import { baseTypeFromNothing } from "../../utilities/type";
 import { findMetaTypeByMetaTypeName } from "../../metaTypes";
 import { typesFromJSON,
-         rulesFromJSON,
-         axiomsFromJSON,
+         lemmasFromJSON,
          typesToTypesJSON,
-         rulesToRulesJSON,
-         theoremsFromJSON,
-         lemmasFromNothing,
-         axiomsToAxiomsJSON,
-         conjecturesFromJSON,
+         metaLemmasFromJSON,
          combinatorsFromJSON,
          typePrefixesFromJSON,
          constructorsFromJSON,
          metatheoremsFromJSON,
-         metaLemmasFromNothing,
-         theoremsToTheoremsJSON,
          declaredVariablesFromJSON,
-         conjecturesToConjecturesJSON,
          combinatorsToCombinatorsJSON,
          declaredMetavariablesFromJSON,
          typePrefixesToTypePrefixesJSON,
@@ -811,40 +803,33 @@ export default class NominalFileContext extends FileContext {
 
     typesFromJSON(json, this.types, fileContext);
 
-    this.lemmas = lemmasFromNothing();
-    this.metaLemmas = metaLemmasFromNothing();
+    this.lemmas = lemmasFromJSON(json, fileContext);
+    this.metaLemmas = metaLemmasFromJSON(json, fileContext);
 
     this.declaredMetavariables = declaredMetavariablesFromJSON(json, fileContext);
     this.declaredVariables = declaredVariablesFromJSON(json, fileContext);
-
-    this.rules = rulesFromJSON(json, fileContext);
-    this.axioms = axiomsFromJSON(json, fileContext);
-    this.theorems = theoremsFromJSON(json, fileContext);
-    this.conjectures = conjecturesFromJSON(json, fileContext);
-    this.combinators = combinatorsFromJSON(json, fileContext);
     this.typePrefixes = typePrefixesFromJSON(json, fileContext);
+    this.combinators = combinatorsFromJSON(json, fileContext);
     this.constructors = constructorsFromJSON(json, fileContext);
     this.metatheorems = metatheoremsFromJSON(json, fileContext);
+
+    // this.rules = rulesFromJSON(json, fileContext);
+    // this.axioms = axiomsFromJSON(json, fileContext);
+    // this.theorems = theoremsFromJSON(json, fileContext);
+    // this.conjectures = conjecturesFromJSON(json, fileContext);
   }
 
   toJSON() {
     const typesJSON = typesToTypesJSON(this.types),
-          rulesJSON = rulesToRulesJSON(this.rules),
-          axiomsJSON = axiomsToAxiomsJSON(this.axioms),
-          theoremsJSON = theoremsToTheoremsJSON(this.theorems),
-          conjecturesJSON = conjecturesToConjecturesJSON(this.conjectures),
           combinatorsJSON = combinatorsToCombinatorsJSON(this.combinators),
           typePrefixesJSON = typePrefixesToTypePrefixesJSON(this.typePrefixes),
           constructorsJSON = constructorsToConstructorsJSON(this.constructors),
           metatheoremsJSON = metatheoremsToMetatheoremsJSON(this.metatheorems),
           declaredVariablesJSON = declaredVariablesToDeclaredVariablesJSON(this.declaredVariables),
           declaredMetavariablesJSON = declaredMetavariablesToDeclaredMetavariablesJSON(this.declaredMetavariables),
+          fileContent = this.fileContent,
           filePath = this.filePath,
           types = typesJSON,  ///
-          rules = rulesJSON,  ///
-          axioms = axiomsJSON,  ///
-          theorems = theoremsJSON,  ///
-          conjectures = conjecturesJSON,  ///
           combinators = combinatorsJSON,  ///
           typePrefixes = typePrefixesJSON,  ///
           constructors = constructorsJSON,  ///
@@ -852,12 +837,9 @@ export default class NominalFileContext extends FileContext {
           declaredVariables = declaredVariablesJSON,  ///
           declaredMetavariables = declaredMetavariablesJSON,  ///
           json = {
+            fileContent,
             filePath,
             types,
-            rules,
-            axioms,
-            theorems,
-            conjectures,
             combinators,
             typePrefixes,
             constructors,

package/src/context/liminal.js

@@ -198,9 +198,9 @@ export default class LiminalContext extends Context {
 
   findSubstitutionByVariableNode(variableNode) {
     const substitution = this.findSubstitution((substitution) => {
-      const substitutionComparesToVariableNode = substitution.compareVariableNode(variableNode);
+      const variableNodeMatches = substitution.matchVariableNode(variableNode);
 
-      if (substitutionComparesToVariableNode) {
+      if (variableNodeMatches) {
         return true;
       }
     }) || null;

package/src/context.js

@@ -463,7 +463,7 @@ export default class Context extends ContextBase {
 
   isJudgementPresentByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-      judgementPresent = context.isJudgementPresentByMetavariableNode(metavariableNode);
+          judgementPresent = context.isJudgementPresentByMetavariableNode(metavariableNode);
 
     return judgementPresent;
   }

package/src/element/assertion/defined.js

@@ -5,6 +5,7 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiateDefinedAssertion } from "../../process/instantiate";
+import { separateGroundedTermsAndDefinedVariables } from "../../utilities/equivalences";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
 import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode, definedAssertionFromStatementNode } from "../../utilities/element";
 
@@ -101,10 +102,10 @@ export default define(class DefinedAssertion extends Assertion {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
         const term = this.term.validate(context, (term) => {
-                const validatesForwards = true;
+          const validatesForwards = true;
 
-                return validatesForwards;
-              });
+          return validatesForwards;
+        });
 
         if (term !== null) {
           this.term = term; ///
@@ -257,7 +258,7 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
       validatesWhenDerived = true;
     }
 
-    if (negated && !variableDefined) {
+    if (negated && !declaredDariableDefined) {
       validatesWhenDerived = true;
     }
   }
@@ -265,13 +266,13 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
   if (frame!== null) {
     const metavariableName = frame.getMetavariableName(),
           declaredMetavariable = context.findDeclaredMetavariableByMetavariableName(metavariableName),
-          metavariableDefined = isMetavariableDefined(declaredMetavariable, context);
+          declaredMetavariableDefined = isMetavariableDefined(declaredMetavariable, context);
 
-    if (!negated && metavariableDefined) {
+    if (!negated && declaredMetavariableDefined) {
       validatesWhenDerived = true;
     }
 
-    if (negated && !metavariableDefined) {
+    if (negated && !declaredMetavariableDefined) {
       validatesWhenDerived = true;
     }
   }
@@ -284,7 +285,7 @@ function isVariableDefined(variable, context) {
         groundedTerms = [],
         definedVariables = [];
 
-  equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
+  separateGroundedTermsAndDefinedVariables(equivalences, groundedTerms, definedVariables, context);
 
   const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
           const definedVariableComparesToVariable = definedVariable.compareVariable(variable);

package/src/element/rule.js

@@ -6,6 +6,7 @@ import { Element, asynchronousUtilities } from "occam-languages";
 import { define } from "../elements";
 import { enclose } from "../utilities/context";
 import { labelsFromJSON, premisesFromJSON, conclusionFromJSON, labelsToLabelsJSON, premisesToPremisesJSON, conclusionToConclusionJSON } from "../utilities/json";
+import {rulsStringFromLabelsPremisesAndConclusion} from "../utilities/string";
 
 const { reverse } = arrayUtilities,
       { asyncExtract, asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
@@ -343,6 +344,7 @@ export default define(class Rule extends Element {
           labels = labelsFromJSON(json, context),
           premises = premisesFromJSON(json, context),
           conclusion = conclusionFromJSON(json, context),
+          ruleString = rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion),
           rule = new Rule(context, string, node, proof, labels, premises, conclusion);
 
     return rule;

package/src/element/signature.js

@@ -169,9 +169,9 @@ export default define(class Signature extends Element {
     const array = substitutions.getArray(),
           compares = compare(this.terms, array, (term, substitution) => {
             const substitutionTerm = substitution.getTerm(),
-                  substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);
+                  substitutionTermComparesToTerm = substitutionTerm.compareTerm(term);
 
-            if (substitutionTermEqualToTerm) {
+            if (substitutionTermComparesToTerm) {
               return true;
             }
           });
@@ -198,9 +198,9 @@ export default define(class Signature extends Element {
     const array = substitutions.getArray(),
           correlates = correlate(this.terms, array, (term, substitution) => {
             const substitutionTerm = substitution.getTerm(),
-                  substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);
+                  substitutionTermComparesToTerm = substitutionTerm.compareTerm(term);
 
-            if (substitutionTermEqualToTerm) {
+            if (substitutionTermComparesToTerm) {
               return true;
             }
           });

package/src/element/substitution/term.js

@@ -49,8 +49,8 @@ export default define(class TermSubstitution extends Substitution {
   getVariableNode() { return this.targetTerm.getVariableNode(); }
 
   isTrivial() {
-    const targetTermEqualToReplacementTerm = this.targetTerm.isEqualTo(this.replacementTerm),
-          trivial = targetTermEqualToReplacementTerm; ///
+    const targetTermComparesToReplacementTerm = this.targetTerm.compareTerm(this.replacementTerm),
+          trivial = targetTermComparesToReplacementTerm; ///
 
     return trivial;
   }
@@ -60,8 +60,8 @@ export default define(class TermSubstitution extends Substitution {
   compareTerm(term, context) {
     term = stripBracketsFromTerm(term, context); ///
 
-    const termEqualToReplacementTerm = this.replacementTerm.isEqualTo(term),
-          comparedToTerm = termEqualToReplacementTerm; ///
+    const replacementTermComparesToTerm = this.replacementTerm.compareTerm(term),
+          comparedToTerm = replacementTermComparesToTerm; ///
 
     return comparedToTerm;
   }

package/src/element/substitution.js

@@ -100,6 +100,18 @@ export default class Substitution extends Element {
     return simple;
   }
 
+  matchVariableNode(variableNode) {
+    const variableNodeMatches = false;
+
+    return variableNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = false;
+
+    return metavariableNodeMatches;
+  }
+
   matchSubstitutionNode(substitutionNode) {
     const node = substitutionNode, ///
           nodeMatches = this.matchNode(node),
@@ -108,6 +120,7 @@ export default class Substitution extends Element {
     return substitutionNodeMatches;
   }
 
+
   findValidSubstitution(context) {
     const substitutionNode = this.getSubstitutionNode(),
           substitution = context.findSubstitutionBySubstitutionNode(substitutionNode),

package/src/element/term.js

@@ -34,6 +34,13 @@ export default define(class Term extends Element {
     return termNode;
   }
 
+  getVariableNode() {
+    const termNode = this.getTermNode(),
+          variableNode = termNode.getVariableNode();
+
+    return variableNode;
+  }
+
   getVariableIdentifier() {
     const termNode = this.getTermNode(),
           variableIdentifier = termNode.getVariableIdentifier();
@@ -93,6 +100,27 @@ export default define(class Term extends Element {
     return termNodeMatches;
   }
 
+  matchVariableNode(variableNode) {
+    let varialbeNodeMatches = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const variableNodeA = variableNode; ///
+
+      variableNode = this.getVariableNode();
+
+      const variableNodeB = variableNode, ///
+            variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);
+
+      if (variableNodeAMatchesVariableNodeB) {
+        varialbeNodeMatches = true; ///
+      }
+    }
+
+    return varialbeNodeMatches;
+  }
+
   compareTerm(term) {
     const termNode = term.getNode(),
           termNodeMatches = this.matchNode(termNode),

package/src/element/variable.js

@@ -137,7 +137,7 @@ export default define(class Variable extends Element {
 
       context = generalContext;  ///
 
-      const variableNode = variable.getIdentifier();
+      const variableNode = variable.getNode();
 
       variable = context.findVariableByVariableNode(variableNode);
 

package/src/node/term.js

@@ -5,6 +5,20 @@ import { NonTerminalNode } from "occam-languages";
 import { ARGUMENT_RULE_NAME, VARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class TermNode extends NonTerminalNode {
+  getVariableIdentifier() {
+    let variableIdentifier = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const variableNode = this.getVariableNode();
+
+      variableIdentifier = variableNode.getVariableIdentifier();
+    }
+
+    return variableIdentifier;
+  }
+
   isSingular() {
     let singular = false;
 

package/src/utilities/equivalences.js

@@ -66,7 +66,7 @@ export function separateGroundedTermsAndDefinedVariables(equivalences, groundedT
 
   separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context);
 
-  const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.getLength();
+  const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
 
   if (initiallyGroundedEquivalencesLength > 0) {
     groundedEquivalences = initiallyGroundedEquivalences; ///
@@ -97,7 +97,7 @@ export function separateGroundedTermsAndDefinedVariables(equivalences, groundedT
 
       push(groundedEquivalences, implicitlyGroundedEquivalences);
 
-      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.getLength();  ///
+      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;  ///
     }
   }
 }

package/src/utilities/json.js

@@ -2,19 +2,6 @@
 
 import elements from "../elements";
 import EphemeralContext from "../context/ephemeral";
-import Substitution from "../element/substitution";
-
-export function lemmasFromNothing() {
-  const lemmas = [];
-
-  return lemmas;
-}
-
-export function metaLemmasFromNothing() {
-  const metaLemmas = [];
-
-  return metaLemmas;
-}
 
 export function nameFromJSON(json, context) {
   let { name } = json;
@@ -86,6 +73,12 @@ export function frameFromJSON(json, context) {
   return frame;
 }
 
+export function lemmasFromJSON(json, context) {
+  const lemmas = [];
+
+  return lemmas;
+}
+
 export function negatedFromJSON(json, context) {
   const { negated } = json;
 
@@ -186,6 +179,12 @@ export function conclusionFromJSON(json, context) {
   return conclusion;
 }
 
+export function metaLemmasFromJSON(json, context) {
+  const metaLemmas = [];
+
+  return metaLemmas;
+}
+
 export function provisionalFromJSON(json, context) {
   const { provisional } = json;
 
@@ -268,22 +267,6 @@ export function termsFromJSON(json, context) {
   return terms;
 }
 
-export function rulesFromJSON(json, context) {
-  let { rules } = json;
-
-  const { Rule } = elements,
-        rulesJSON = rules; ///
-
-  rules = rulesJSON.map((ruleJSON) => {
-    const json = ruleJSON,  ///
-          rule = Rule.fromJSON(json, context);
-
-    return rule;
-  });
-
-  return rules;
-}
-
 export function framesFromJSON(json, context) {
   let { frames } = json;
 
@@ -316,22 +299,6 @@ export function labelsFromJSON(json, context) {
   return labels;
 }
 
-export function axiomsFromJSON(json, context) {
-  let { axioms } = json;
-
-  const { Axiom } = elements,
-        axiomsJSON = axioms; ///
-
-  axioms = axiomsJSON.map((axiomJSON) => {
-    const json = axiomJSON,  ///
-          axiom = Axiom.fromJSON(json, context);
-
-    return axiom;
-  });
-
-  return axioms;
-}
-
 export function premisesFromJSON(json, context) {
   let { premises } = json;
 
@@ -348,22 +315,6 @@ export function premisesFromJSON(json, context) {
   return premises;
 }
 
-export function theoremsFromJSON(json, context) {
-  let { theorems } = json;
-
-  const { Theorem } = elements,
-        theoremsJSON = theorems; ///
-
-  theorems = theoremsJSON.map((theoremJSON) => {
-    const json = theoremJSON,  ///
-          theorem = Theorem.fromJSON(json, context);
-
-    return theorem;
-  });
-
-  return theorems;
-}
-
 export function variablesFromJSON(json, context) {
   let { variables } = json;
 
@@ -529,22 +480,6 @@ export function referencesFromJSON(json, context) {
   return references;
 }
 
-export function conjecturesFromJSON(json, context) {
-  let { conjectures } = json;
-
-  const { Conjecture } = elements,
-        conjecturesJSON = conjectures; ///
-
-  conjectures = conjecturesJSON.map((conjectureJSON) => {
-    const json = conjectureJSON,  ///
-          conjecture = Conjecture.fromJSON(json, context);
-
-    return conjecture;
-  });
-
-  return conjectures;
-}
-
 export function combinatorsFromJSON(json, context) {
   let { combinators } = json;
 
@@ -922,16 +857,6 @@ export function typesToTypesJSON(types) {
   return typesJSON;
 }
 
-export function rulesToRulesJSON(rules) {
-  const rulesJSON = rules.map((rule) => {
-    const ruleJSON = rule.toJSON();
-
-    return ruleJSON;
-  });
-
-  return rulesJSON;
-}
-
 export function labelsToLabelsJSON(labels) {
   const labelsJSON = labels.map((label) => {
     const labelJSON = label.toJSON();
@@ -952,16 +877,6 @@ export function framesToFramesJSON(frames) {
   return framesJSON;
 }
 
-export function axiomsToAxiomsJSON(axioms) {
-  const axiomsJSON = axioms.map((axiom) => {
-    const axiomJSON = axiom.toJSON();
-
-    return axiomJSON;
-  });
-
-  return axiomsJSON;
-}
-
 export function premisesToPremisesJSON(premises) {
   const premisesJSON = premises.map((premise) => {
     const premiseJSON = premise.toJSON();
@@ -972,16 +887,6 @@ export function premisesToPremisesJSON(premises) {
   return premisesJSON;
 }
 
-export function theoremsToTheoremsJSON(theorems) {
-  const theoremsJSON = theorems.map((theorem) => {
-    const theoremJSON = theorem.toJSON();
-
-    return theoremJSON;
-  });
-
-  return theoremsJSON;
-}
-
 export function variablesToVariablesJSON(variables) {
   const variablesJSON = variables.map((variable) => {
     const variableJSON = variable.toJSON();
@@ -1082,16 +987,6 @@ export function referencesToReferencesJSON(references) {
   return referencesJSON;
 }
 
-export function conjecturesToConjecturesJSON(conjectures) {
-  const conjecturesJSON = conjectures.map((conjecture) => {
-    const conjectureJSON = conjecture.toJSON();
-
-    return conjectureJSON;
-  });
-
-  return conjecturesJSON;
-}
-
 export function combinatorsToCombinatorsJSON(combinators) {
   const combinatorsJSON = combinators.map((combinator) => {
     const combinatorJSON = combinator.toJSON();