occam-verify-cli 0.0.1245 → 0.0.1247

package/src/context/file.js

@@ -313,97 +313,60 @@ export default class FileContext {
     return fileContext;
   }
 
-  isMetavariableDeclared(metavariable, generalContext, specificContext) {
-    metavariable = this.findMetavariable(metavariable, generalContext, specificContext);  ///
-
-    const metavariableDeclared = (metavariable !== null);
-
-    return metavariableDeclared;
+  addType(type) {
+    this.types.push(type);
   }
 
-  isTypeDeclaredByTypeName(typeName) {
-    const type = this.findTypeByTypeName(typeName),
-          typeDeclared = (type !== null);
-
-    return typeDeclared;
+  addRule(rule) {
+    this.rules.push(rule);
   }
 
-  isVariableDeclaredByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
-          variableDeclared = (variable !== null);
-
-    return variableDeclared;
+  addAxiom(axiom) {
+    this.axioms.push(axiom);
   }
 
-  isMetavariableDeclaredByMetavariableName(metavariableName) {
-    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
-          metavariableDeclared = (metavariable !== null);
-
-    return metavariableDeclared;
+  addLemma(lemma) {
+    this.lemmas.push(lemma);
   }
 
-  isLabelPresentByMetavariableName(metavariableName) {
-    const label = this.findLabelByMetavariableName(metavariableName),
-          labelPresent = (label !== null);
-
-    return labelPresent;
+  addTheorem(theorem) {
+    this.theorems.push(theorem);
   }
 
-  isLabelPresentByMetavariableNode(metavariableNode) {
-    const label = this.findLabelByMetavariableNode(metavariableNode),
-          labelPresent = (label !== null);
-
-    return labelPresent;
+  addVariable(variable) {
+    this.variables.push(variable);
   }
 
-  findTypeByTypeName(typeName) {
-    let types = this.getTypes();
-
-    types.push(objectType);
-
-    const type = types.find((type) => {
-      const typeNameMatches = type.matchTypeName(typeName);
-
-      if (typeNameMatches) {
-        return true;
-      }
-    }) || null;
-
-    return type;
+  addMetaLemma(metaLemma) {
+    this.metaLemmas.push(metaLemma);
   }
 
-  findMetaTypeByMetaTypeName(metaTypeName) {
-    const metaTypes = this.getMetaTypes(),
-          metaType = metaTypes.find((metaType) => {
-            const metaTypeNameMatches = metaType.matchMetaTypeName(metaTypeName);
-
-            if (metaTypeNameMatches) {
-              return true;
-            }
-          }) || null;
+  addConjecture(conjecture) {
+    this.conjectures.push(conjecture);
+  }
 
-    return metaType;
+  addCombinator(combinator) {
+    this.combinators.push(combinator);
   }
 
-  findVariableByVariableName(variableName) {
-    const variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const variableNameMatches = variable.matchVariableName(variableName);
+  addConstructor(constructor) {
+    this.constructors.push(constructor);
+  }
 
-            if (variableNameMatches) {
-              return true;
-            }
-          }) || null;
+  addMetatheorem(metatheorem) {
+    this.metatheorems.push(metatheorem);
+  }
 
-    return variable;
+  addMetavariable(metavariable) {
+    this.metavariables.push(metavariable);
   }
 
-  findLabelByMetavariableName(metavariableName) {
+  findLabelByReference(reference, context) {
     const labels = this.getLabels(),
           label = labels.find((label) => {
-            const metavariableNameMatches = label.matchMetavariableName(metavariableName);
+            const metavariableUnified = label.unifyReference(reference, context);
 
-            if (metavariableNameMatches) {
+            if (metavariableUnified) {
               return true;
             }
           }) || null;
@@ -411,19 +374,6 @@ export default class FileContext {
     return label;
   }
 
-  findLabelByMetavariableNode(metavariableNode) {
-    const labels = this.getLabels(),
-      label = labels.find((label) => {
-        const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
-
-        if (metavariableNodeMatches) {
-          return true;
-        }
-      }) || null;
-
-    return label;
-  }
-
   findRuleByReference(reference) {
     const rules = this.getRules(),
           metavariableName = reference.getMetavariableName(),
@@ -509,14 +459,14 @@ export default class FileContext {
   }
 
   findMetaLemmasByReference(reference) {
-    const metaLemmas = this.getMetaLemmas();
+    const metaLemmas = this.getMetaLemmas(),
+          substitutions = Substitutions.fromNothing();
 
     filter(metaLemmas, (metaLemma) => {
       const context = this, ///
-            substitutions = Substitutions.fromNothing(),
-            referenceUnified = metaLemma.unifyReference(reference, substitutions, context);
+            metaLemmaUnified = reference.unifyMetaLemma(metaLemma, substitutions, context);
 
-      if (referenceUnified) {
+      if (metaLemmaUnified) {
         return true;
       }
     });
@@ -525,14 +475,14 @@ export default class FileContext {
   }
 
   findMetatheoremsByReference(reference) {
-    const metatheorems = this.getMetatheorems();
+    const metatheorems = this.getMetatheorems(),
+          substitutions = Substitutions.fromNothing();
 
-    filter(metatheorems, (metatheorem) => {
+  filter(metatheorems, (metatheorem) => {
       const context = this, ///
-            substitutions = Substitutions.fromNothing(),
-            referenceUnified = metatheorem.unifyReference(reference, substitutions, context);
+            metatheoremUnified = reference.unifyMetatheorem(metatheorem, substitutions, context);
 
-      if (referenceUnified) {
+      if (metatheoremUnified) {
         return true;
       }
     });
@@ -550,22 +500,93 @@ export default class FileContext {
     return axiomLemmaTheoremConjecture;
   }
 
-  findVariable(variable) {
-    const specificVariable = variable,  ///
-          variables = this.getVariables();
+  findMetavariable(metavariable, generalContext, specificContext) {
+    const specificMetavariable = metavariable,  ///
+          metavariables = this.getMetavariables();
+
+    metavariable = metavariables.find((metavariable) => {
+      const generalMetavariable = metavariable; ///
+
+      metavariable = specificMetavariable;  ///
+
+      const metavariableUnified = generalMetavariable.unifyMetavariable(metavariable, generalContext, specificContext);
+
+      if (metavariableUnified) {
+        return true;
+      }
+    }) || null;
+
+    return metavariable;
+  }
+
+  findTypeByTypeName(typeName) {
+    let types = this.getTypes();
+
+    types.push(objectType);
 
-    variable = variables.find((variable) => {
-      const generalVariable = variable,
-            generalVariableEqualToSpecificVariable = generalVariable.isEqualTo(specificVariable);
+    const type = types.find((type) => {
+      const typeNameMatches = type.matchTypeName(typeName);
 
-      if (generalVariableEqualToSpecificVariable) {
+      if (typeNameMatches) {
         return true;
       }
     }) || null;
 
+    return type;
+  }
+
+  findMetaTypeByMetaTypeName(metaTypeName) {
+    const metaTypes = this.getMetaTypes(),
+          metaType = metaTypes.find((metaType) => {
+            const metaTypeNameMatches = metaType.matchMetaTypeName(metaTypeName);
+
+            if (metaTypeNameMatches) {
+              return true;
+            }
+          }) || null;
+
+    return metaType;
+  }
+
+  findVariableByVariableName(variableName) {
+    const variables = this.getVariables(),
+          variable = variables.find((variable) => {
+            const variableNameMatches = variable.matchVariableName(variableName);
+
+            if (variableNameMatches) {
+              return true;
+            }
+          }) || null;
+
     return variable;
   }
 
+  findLabelByMetavariableName(metavariableName) {
+    const labels = this.getLabels(),
+          label = labels.find((label) => {
+            const metavariableNameMatches = label.matchMetavariableName(metavariableName);
+
+            if (metavariableNameMatches) {
+              return true;
+            }
+          }) || null;
+
+    return label;
+  }
+
+  findLabelByMetavariableNode(metavariableNode) {
+    const labels = this.getLabels(),
+          label = labels.find((label) => {
+            const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
+
+            if (metavariableNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return label;
+  }
+
   findJudgementByMetavariable(metavariable) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
@@ -596,96 +617,83 @@ export default class FileContext {
     return metavariable;
   }
 
-  findMetavariable(metavariable, generalContext, specificContext) {
-    const specificMetavariable = metavariable,  ///
-          metavariables = this.getMetavariables();
-
-    metavariable = metavariables.find((metavariable) => {
-      const generalMetavariable = metavariable; ///
-
-      metavariable = specificMetavariable;  ///
-
-      const metavariableUnified = generalMetavariable.unifyMetavariable(metavariable, generalContext, specificContext);
+  isMetavariablePresent(metavariable, generalContext, specificContext) {
+    metavariable = this.findMetavariable(metavariable, generalContext, specificContext);  ///
 
-      if (metavariableUnified) {
-        return true;
-      }
-    }) || null;
+    const metavariablePresent = (metavariable !== null);
 
-    return metavariable;
+    return metavariablePresent;
   }
 
-  isRulePresentByReference(reference) {
-    const rule = this.findRuleByReference(reference),
-          rulePresent = (rule !== null);
+  isTypePresentByTypeName(typeName) {
+    const type = this.findTypeByTypeName(typeName),
+          typeDeclared = (type !== null);
 
-    return rulePresent;
+    return typeDeclared;
   }
 
-  isAxiomPresentByReference(reference) {
-    const axiom = this.findAxiomByReference(reference),
-          axiomPresent = (axiom !== null);
+  isVariablePresentByVariableName(variableName) {
+    const variable = this.findVariableByVariableName(variableName),
+          variablePresent = (variable !== null);
 
-    return axiomPresent;
+    return variablePresent;
   }
 
-  isLemmaPresentByReference(reference) {
-    const lemma = this.findLemmaByReference(reference),
-          lemmaPresent = (lemma !== null);
+  isLabelPresentByMetavariableName(metavariableName) {
+    const label = this.findLabelByMetavariableName(metavariableName),
+          labelPresent = (label !== null);
 
-    return lemmaPresent;
+    return labelPresent;
   }
 
-  isTheoremPresentByReference(reference) {
-    const theorem = this.findTheoremByReference(reference),
-          theoremPresent = (theorem !== null);
+  isLabelPresentByMetavariableNode(metavariableNode) {
+    const label = this.findLabelByMetavariableNode(metavariableNode),
+          labelPresent = (label !== null);
 
-    return theoremPresent;
+    return labelPresent;
   }
 
-  isProcedurePresentByReference(reference) {
-    const procedure = this.findProcedureByReference(reference),
-          procedurePresent = (procedure !== null);
+  isMetavariablePresentByMetavariableName(metavariableName) {
+    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
+          metavariablePresent = (metavariable !== null);
 
-    return procedurePresent;
+    return metavariablePresent;
   }
 
-  isConjecturePresentByReference(reference) {
-    const conjecture = this.findConjectureByReference(reference),
-          conjecturePresent = (conjecture !== null);
-
-    return conjecturePresent;
-  }
+  isLabelPresentByReference(reference) {
+    const labels = this.getLabels(),
+          labelPresent = labels.some((label) => {
+            const context = this, ///
+                  substitutions = Substitutions.fromNothing(),
+                  labelUnified = reference.unifyLabel(label, substitutions, context);
 
-  isAxiomLemmaTheoremConjecturePresentByReference(reference) {
-    const axiomLemmaTheoremConjecture = this.findAxiomLemmaTheoremConjectureByReference(reference),
-          axiomLemmaTheoremConjecturePresent = (axiomLemmaTheoremConjecture !== null);
+            if (labelUnified) {
+              return true;
+            }
+          });
 
-    return axiomLemmaTheoremConjecturePresent;
+    return labelPresent;
   }
 
-  areMetaLemmasPresentByReference(reference) {
-    const metaLemmas = this.findMetaLemmasByReference(reference),
-          metaLemmasLength = metaLemmas.length,
-          metaLemmasPresent = (metaLemmasLength > 0);
+  isProcedurePresentByReference(reference) {
+    const procedure = this.findProcedureByReference(reference),
+          procedurePresent = (procedure !== null);
 
-    return metaLemmasPresent;
+    return procedurePresent;
   }
 
-  areMetatheoremsPresentByReference(reference) {
-    const metatheorems = this.findMetatheoremsByReference(reference),
-          metatheoremsLength = metatheorems.length, ///
-          metatheoremsPresent = (metatheoremsLength > 0);
-
-    return metatheoremsPresent;
-  }
+  isMetavariablePresentByReference(reference) {
+    const metavariables = this.getMetavariables(),
+          metavariablePresent = metavariables.some((metavariable) => {
+            const context = this, ///
+                  metavariableUnified = reference.unifyMetavariable(metavariable, context);
 
-  areMetaLemmasMetaTheoremsPresentByReference(reference) {
-    const metaLemmasPresent = this.areMetaLemmasPresentByReference(reference),
-          metatheoremsPresent = this.areMetatheoremsPresentByReference(reference),
-          metaLemmasMetaTheoremsPresent = (metaLemmasPresent || metatheoremsPresent);
+            if (metavariableUnified) {
+              return true;
+            }
+          });
 
-    return metaLemmasMetaTheoremsPresent;
+    return metavariablePresent;
   }
 
   nodeAsString(node, tokens = null) {
@@ -730,54 +738,6 @@ export default class FileContext {
 
   tokensAsString(tokens) { return tokensAsString(tokens); }
 
-  addType(type) {
-    this.types.push(type);
-  }
-
-  addRule(rule) {
-    this.rules.push(rule);
-  }
-
-  addAxiom(axiom) {
-    this.axioms.push(axiom);
-  }
-
-  addLemma(lemma) {
-    this.lemmas.push(lemma);
-  }
-
-  addTheorem(theorem) {
-    this.theorems.push(theorem);
-  }
-
-  addVariable(variable) {
-    this.variables.push(variable);
-  }
-
-  addMetaLemma(metaLemma) {
-    this.metaLemmas.push(metaLemma);
-  }
-
-  addConjecture(conjecture) {
-    this.conjectures.push(conjecture);
-  }
-
-  addCombinator(combinator) {
-    this.combinators.push(combinator);
-  }
-
-  addConstructor(constructor) {
-    this.constructors.push(constructor);
-  }
-
-  addMetatheorem(metatheorem) {
-    this.metatheorems.push(metatheorem);
-  }
-
-  addMetavariable(metavariable) {
-    this.metavariables.push(metavariable);
-  }
-
   findFile(filePath) { return this.releaseContext.findFile(filePath); }
 
   trace(message) { this.releaseContext.trace(message, this.filePath); }