occam-verify-cli 1.0.587 → 1.0.603

package/src/context/scoped.js

@@ -186,15 +186,10 @@ class ScopedContext extends Context {
   findJudgementByMetavariable(metavariable) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementSingular = judgement.isSingular();
+            const judgementMetavariableComparesToMetavariable = judgement.compareMetavariable(metavariable);
 
-            if (judgementSingular) {
-              const judgementMetavariable = judgement.getMetavariable(),
-                    judgementMetavariableEqualToMetavariable = judgementMetavariable.isEqualTo(metavariable);
-
-              if (judgementMetavariableEqualToMetavariable) {
-                return true;
-              }
+            if (judgementMetavariableComparesToMetavariable) {
+              return true;
             }
           }) || null;
 
@@ -235,33 +230,6 @@ class ScopedContext extends Context {
     return termGrounded;
   }
 
-  isVariableDefined(variable) {
-    const context = this, ///
-          equivalences = this.getEquivalences(),
-          groundedTerms = [],
-          definedVariables = [];
-
-    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
-
-    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
-            const definedVariableEqualToVariable = definedVariable.isEqualTo(variable);
-
-            if (definedVariableEqualToVariable === variable) {
-              return true;
-            }
-          }),
-          variableDefined = variableMatchesDefinedVariable; ///
-
-    return variableDefined;
-  }
-
-  isMetavariableDefined(metavariable) {
-    const judgementPresent = this.isJudgementPresentByMetavariable(metavariable),
-          metavariableDefined = judgementPresent; ///
-
-    return metavariableDefined
-  }
-
   isJudgementPresentByMetavariable(metavariable) {
     const judgement = this.findJudgementByMetavariable(metavariable),
           judgementPresent = (judgement !== null);

package/src/context/synthetic.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import Context from "../context";
+
+export default class SyntheticContext extends Context {
+  constructor(context, contexts) {
+    super(context);
+
+    this.contexts = contexts;
+  }
+
+  getContexts() {
+    return this.contexts;
+  }
+
+  findTermByTermNode(termNode) {
+    let term = null;
+
+    this.contexts.some((context) => {
+      term = context.findTermByTermNode(termNode);
+
+      if (term !== null) {
+        return true;
+      }
+    });
+
+    return term;
+  }
+
+  findFrameByFrameNode(frameNode) {
+    let frame = null;
+
+    this.contexts.some((context) => {
+      frame = context.findFrameByFrameNode(frameNode);
+
+      if (frame !== null) {
+        return true;
+      }
+    });
+
+    return frame;
+  }
+
+  static fromContexts(contexts, context) {
+    const syntheticContext = new SyntheticContext(context, contexts);
+
+    return syntheticContext;
+  }
+}

package/src/context.js

@@ -24,9 +24,30 @@ export default class Context extends ContextBase {
     return filePath;
   }
 
+  getTerms() {
+    const context = this.getContext(),
+          terms = context.getTerms();
+
+    return terms;
+  }
+
+  getFrames() {
+    const context = this.getContext(),
+      frames = context.getFrames();
+
+    return frames;
+  }
+
+  getSubstitutions() {
+    const context = this.getContext(),
+          substitutions = context.getSubstitutions();
+
+    return substitutions;
+  }
+
   getVariables(includeRelease) {
     const context = this.getContext(),
-          variables = context.getVariables(includeRelease);
+      variables = context.getVariables(includeRelease);
 
     return variables;
   }
@@ -38,6 +59,13 @@ export default class Context extends ContextBase {
     return combinators;
   }
 
+  getMetavariables(includeRelease) {
+    const context = this.getContext(),
+          metavariables = context.getMetavariables(includeRelease);
+
+    return metavariables;
+  }
+
   getSubproofOrProofAssertions() {
     const context = this.getContext(),
           subproofOrProofAssertions = context.getSubproofOrProofAssertions();
@@ -81,6 +109,34 @@ export default class Context extends ContextBase {
     return statement;
   }
 
+  findReferenceByMetavariableNode(metavariableNode) {
+    const context = this.getContext(),
+          reference = context.findReferenceByMetavariableNode(metavariableNode);
+
+    return reference;
+  }
+
+  findTopLevelAssertionByReference(reference) {
+    const context = this.getContext(),
+      topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+
+    return topLevelAssertion;
+  }
+
+  findSubstitutionByVariable(variable, generalContext, specificContext) {
+    const context = this.getContext(),
+          substitution = context.findSubstitutionByVariable(variable, generalContext, specificContext);
+
+    return substitution;
+  }
+
+  findSubstitutionByMetavariable(metavariable, generalContet, specificContext) {
+    const context = this.getContext(),
+          substitution = context.findSubstitutionByMetavariable(metavariable, generalContet, specificContext);
+
+    return substitution;
+  }
+
   findVariableByVariableIdentifier(variableIdentifier) {
     const context = this.getContext(),
           variable = context.findVariableByVariableIdentifier(variableIdentifier);
@@ -95,6 +151,70 @@ export default class Context extends ContextBase {
     return metavariable;
   }
 
+  findSimpleSubstitutionByMetavariable(metavariable) {
+    const context = this.getContext(),
+          simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
+
+    return simpleSubstitution;
+  }
+
+  findSubstitutionByMetavariableAndSubstitution(metavariable, substitution, generalContet, specificContext) {
+    const context = this.getContext();
+
+    substitution = context.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution, generalContet, specificContext); ///
+
+    return substitution;
+  }
+
+  isTermPresentByTermNode(termNode) {
+    const context = this.getContext(),
+          termPresent = context.isTermPresentByTermNode(termNode);
+
+    return termPresent;
+  }
+
+  isFramePresentByFrameNode(frameNode) {
+    const context = this.getContext(),
+          framePresent = context.isFramePresentByFrameNode(frameNode);
+
+    return framePresent;
+  }
+
+  isJudgementPresentByMetavariable(metavariable) {
+    const context = this.getContext(),
+          judgementPresent = context.isJudgementPresentByMetavariable(metavariable);
+
+    return judgementPresent;
+  }
+
+  isStatementPresentByStatementNode(statementNode) {
+    const context = this.getContext(),
+      statementPresent = context.isStatementPresentByStatementNode(statementNode);
+
+    return statementPresent;
+  }
+
+  isAssertionPresentByAssertionNode(assertionNode) {
+    const context = this.getContext(),
+          assertionPresent = context.isAssertionPresentByAssertionNode(assertionNode);
+
+    return assertionPresent;
+  }
+
+  isReferencePresentByReferenceNode(referenceNode) {
+    const context = this.getContext(),
+          referencePresent = context.isReferencePresentByReferenceNode(referenceNode);
+
+    return referencePresent;
+  }
+
+  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
+    const context = this.getContext(),
+          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode);
+
+    return substitutionPresent;
+  }
+
   isProcedurePresentByName(name) {
     const context = this.getContext(),
           procedurePresent = context.isProcedurePresentByName(name);
@@ -116,6 +236,36 @@ export default class Context extends ContextBase {
     return metavariablePresent;
   }
 
+  addRule(rule) {
+    const context = this.getContext();
+
+    context.addRule(rule);
+  }
+
+  adTerm(term) {
+    const context = this.getContext();
+
+    context.adTerm(term);
+  }
+
+  addFrame(frame) {
+    const context = this.getContext();
+
+    context.addFrame(frame);
+  }
+
+  addStatement(statement) {
+    const context = this.getContext();
+
+    context.addStatement(statement);
+  }
+
+  addReference(reference) {
+    const context = this.getContext();
+
+    context.addReference(reference);
+  }
+
   addJudgement(judgement) {
     const context = this.getContext(),
           judgementAdded = context.addJudgement(judgement);
@@ -123,6 +273,18 @@ export default class Context extends ContextBase {
     return judgementAdded;
   }
 
+  addSubstitution(substitution) {
+    const context = this.getContext();
+
+    context.addSubstitution(substitution);
+  }
+
+  removeSubstitution(substitution) {
+    const context = this.getContext();
+
+    context.removeSubstitution(substitution);
+  }
+
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
     const context = this.getContext();
 

package/src/element/assertion/contained.js

@@ -38,27 +38,35 @@ export default define(class ContainedAssertion extends Assertion {
 
     context.trace(`Validating the '${containedAssertionString}' contained assertion...`);
 
-    const termValidates = this.validateTerm(assignments, stated, context),
-          frameVerifies = this.validateFrame(assignments, stated, context),
-          statementValidates = this.validateStatement(assignments, stated, context)
+    const valid = this.isValid(context);
 
-    if (termValidates || frameVerifies || statementValidates) {
-      let validatesWhenStated = false,
-          validatesWhenDerived = false;
+    if (!valid) {
+      validates = true;
 
-      if (stated) {
-        validatesWhenStated = this.validateWhenStated(assignments, context);
-      } else {
-        validatesWhenDerived = this.validateWhenDerived(context);
-      }
+      context.debug(`...the '${containedAssertionString}' contained assertion is already valid.`);
+    } else {
+      const termValidates = this.validateTerm(assignments, stated, context),
+            frameVerifies = this.validateFrame(assignments, stated, context),
+            statementValidates = this.validateStatement(assignments, stated, context)
+
+      if (termValidates || frameVerifies || statementValidates) {
+        let validatesWhenStated = false,
+            validatesWhenDerived = false;
+
+        if (stated) {
+          validatesWhenStated = this.validateWhenStated(assignments, context);
+        } else {
+          validatesWhenDerived = this.validateWhenDerived(context);
+        }
 
-      if (validatesWhenStated || validatesWhenDerived) {
-        validates = true;
+        if (validatesWhenStated || validatesWhenDerived) {
+          validates = true;
+        }
       }
-    }
 
-    if (validates) {
-      context.debug(`...validated the '${containedAssertionString}' contained assertion.`);
+      if (validates) {
+        context.debug(`...validated the '${containedAssertionString}' contained assertion.`);
+      }
     }
 
     return validates;
@@ -179,7 +187,7 @@ export default define(class ContainedAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  unifyIndependently(substitutions, generalContext, specificContext) {
+  unifyIndependently(generalContext, specificContext) {
     let unifiesIndependently;
 
     const context = specificContext,  ///
@@ -187,9 +195,9 @@ export default define(class ContainedAssertion extends Assertion {
 
     context.trace(`Unifying the '${containedAssertionString}' contained assertion independently...`);
 
-    const term = termFromTermAndSubstitutions(this.term, substitutions, generalContext, specificContext),
-          frame = frameFromFrameAndSubstitutions(this.frame, substitutions, generalContext, specificContext),
-          statement = statementFromStatementAndSubstitutions(this.statement, substitutions, generalContext, specificContext),
+    const term = termFromTermAndSubstitutions(this.term, generalContext, specificContext),
+          frame = frameFromFrameAndSubstitutions(this.frame, generalContext, specificContext),
+          statement = statementFromStatementAndSubstitutions(this.statement, generalContext, specificContext),
           validatesWhenDerived = validateWhenDerived(term, frame, statement, this.negated, generalContext, specificContext);
 
     unifiesIndependently = validatesWhenDerived; ///

package/src/element/assertion/defined.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import elements from "../../elements";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
@@ -28,35 +27,43 @@ export default define(class DefinedAssertion extends Assertion {
   }
 
   validate(assignments, stated, context) {
-    let validated = false;
+    let validates = false;
 
     const definedAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${definedAssertionString}' defined assertion...`);
 
-    const termValidates = this.validateTerm(assignments, stated, context),
-          frameVerifies = this.validateFrame(assignments, stated, context);
+    const valid = this.isValid(context);
 
-    if (termValidates || frameVerifies) {
-      let verifiesWhenStated = false,
-          verifiesWhenDerived = false;
+    if (valid) {
+      validates = true;
 
-      if (stated) {
-        verifiesWhenStated = this.validateWhenStated(assignments, context);
-      } else {
-        verifiesWhenDerived = this.validateWhenDerived(context);
-      }
+      context.debug(`...the '${definedAssertionString}' defined assertion is already valid.`);
+    } else {
+      const termValidates = this.validateTerm(assignments, stated, context),
+            frameVerifies = this.validateFrame(assignments, stated, context);
+
+      if (termValidates || frameVerifies) {
+        let verifiesWhenStated = false,
+            verifiesWhenDerived = false;
+
+        if (stated) {
+          verifiesWhenStated = this.validateWhenStated(assignments, context);
+        } else {
+          verifiesWhenDerived = this.validateWhenDerived(context);
+        }
 
-      if (verifiesWhenStated || verifiesWhenDerived) {
-        validated = true;
+        if (verifiesWhenStated || verifiesWhenDerived) {
+          validates = true;
+        }
       }
-    }
 
-    if (validated) {
-      context.debug(`...validated the '${definedAssertionString}' defined assertion.`);
+      if (validates) {
+        context.debug(`...validates the '${definedAssertionString}' defined assertion.`);
+      }
     }
 
-    return validated;
+    return validates;
   }
 
   validateTerm(assignments, stated, context) {
@@ -80,7 +87,7 @@ export default define(class DefinedAssertion extends Assertion {
         });
 
         if (termValidates) {
-          context.debug(`...validated the'${definedAssertionString}' defined assertino's '${termString}' term.`);
+          context.debug(`...validates the'${definedAssertionString}' defined assertino's '${termString}' term.`);
         }
       }
     }
@@ -109,7 +116,7 @@ export default define(class DefinedAssertion extends Assertion {
         frameVerifies = this.frame.validate(assignments, stated, context);
 
         if (frameVerifies) {
-          context.debug(`...validated the'${definedAssertionString}' defined assertino's '${frameString}' frame.`);
+          context.debug(`...validates the'${definedAssertionString}' defined assertino's '${frameString}' frame.`);
         }
       }
     }
@@ -127,7 +134,7 @@ export default define(class DefinedAssertion extends Assertion {
     verifiesWhenStated = true;
 
     if (verifiesWhenStated) {
-      context.debug(`...validated the '${definedAssertionString}' stated defined assertion.`);
+      context.debug(`...validates the '${definedAssertionString}' stated defined assertion.`);
     }
 
     return verifiesWhenStated;
@@ -146,13 +153,13 @@ export default define(class DefinedAssertion extends Assertion {
     verifiesWhenDerived = validateWhenDerived(this.term, this.frame, this.negated, generalContext, specificContext);
 
     if (verifiesWhenDerived) {
-      context.debug(`...validated the '${definedAssertionString}' derived defined assertion.`);
+      context.debug(`...validates the '${definedAssertionString}' derived defined assertion.`);
     }
 
     return verifiesWhenDerived;
   }
 
-  unifyIndependently(substitutions, generalContext, specificContext) {
+  unifyIndependently(generalContext, specificContext) {
     let unifiesIndependently;
 
     const context = specificContext, ///
@@ -160,8 +167,8 @@ export default define(class DefinedAssertion extends Assertion {
 
     context.trace(`Unifying the '${definedAssertionString}' defined assertion independently...`);
 
-    const term = termFromTermAndSubstitutions(this.term, substitutions, generalContext, specificContext),
-          frame = frameFromFrameAndSubstitutions(this.frame, substitutions, generalContext, specificContext),
+    const term = termFromTermAndSubstitutions(this.term, generalContext, specificContext),
+          frame = frameFromFrameAndSubstitutions(this.frame, generalContext, specificContext),
           verifiesWhenDerived = validateWhenDerived(term, frame, this.negated, generalContext, specificContext);
 
     unifiesIndependently = verifiesWhenDerived; ///
@@ -182,11 +189,8 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
   const context = specificContext;  ///
 
   if (term !== null) {
-    const { Variable } = elements,
-          termNode = term.getNode(),
-          variable = Variable.fromTermNode(termNode, context),
-          generalContext = context, ///
-          variableDefined = generalContext.isVariableDefined(variable);
+    const variable = term.getVariable(generalContext, specificContext),
+          variableDefined = isVariableDefined(variable, context);
 
     if (!negated && variableDefined) {
       verifiesWhenDerived = true;
@@ -198,10 +202,8 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
   }
 
   if (frame!== null) {
-    const { Metavariable } = elements,
-          frameNode = frame.getNode(),
-          metavariable = Metavariable.fromFrameNode(frameNode, context),
-          metavariableDefined = context.isMetavariableDefined(metavariable);
+    const metavariable = frame.getMetavariable(generalContext, specificContext),
+          metavariableDefined = isMetavariableDefined(metavariable, context);
 
     if (!negated && metavariableDefined) {
       verifiesWhenDerived = true;
@@ -214,3 +216,29 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
 
   return verifiesWhenDerived;
 }
+
+function isVariableDefined(variable, context) {
+  const equivalences = context.getEquivalences(),
+        groundedTerms = [],
+        definedVariables = [];
+
+  equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
+
+  const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
+          const definedVariableEqualToVariable = definedVariable.compare(variable);
+
+          if (definedVariableEqualToVariable === variable) {
+            return true;
+          }
+        }),
+        variableDefined = variableMatchesDefinedVariable; ///
+
+  return variableDefined;
+}
+
+function isMetavariableDefined(metavariable, context) {
+  const judgementPresent = context.isJudgementPresentByMetavariable(metavariable),
+        metavariableDefined = judgementPresent; ///
+
+  return metavariableDefined
+}

package/src/element/assertion/property.js

@@ -55,35 +55,43 @@ export default define(class PropertyAssertion extends Assertion {
 
     context.trace(`Validating the '${propertyAssertionString}' property assertion...`);
 
-    const termValidates = this.validateTerm(assignments, stated, context);
+    const valid = this.isValid(context);
 
-    if (termValidates) {
-      const propertyRelationVerifies = this.validatePropertyRelation(assignments, stated, context);
+    if (valid) {
+      validates = true;
+
+      context.debug(`...the '${propertyAssertionString}' property assertion is already valid.`);
+    } else {
+      const termValidates = this.validateTerm(assignments, stated, context);
+
+      if (termValidates) {
+        const propertyRelationVerifies = this.validatePropertyRelation(assignments, stated, context);
 
-      if (propertyRelationVerifies) {
-        let validatesWhenStated = false,
+        if (propertyRelationVerifies) {
+          let validatesWhenStated = false,
             validatesWhenDerived = false;
 
-        if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
-        } else {
-          validatesWhenDerived = this.validateWhenDerived(context);
-        }
+          if (stated) {
+            validatesWhenStated = this.validateWhenStated(assignments, context);
+          } else {
+            validatesWhenDerived = this.validateWhenDerived(context);
+          }
 
-        if (validatesWhenStated || validatesWhenDerived) {
-          validates = true;
+          if (validatesWhenStated || validatesWhenDerived) {
+            validates = true;
+          }
         }
       }
-    }
 
-    if (validates) {
-      if (stated) {
-        this.assign(assignments, context);
+      if (validates) {
+        if (stated) {
+          this.assign(assignments, context);
+        }
       }
-    }
 
-    if (validates) {
-      context.debug(`...validated the '${propertyAssertionString}' property assertion.`);
+      if (validates) {
+        context.debug(`...validated the '${propertyAssertionString}' property assertion.`);
+      }
     }
 
     return validates;

package/src/element/assertion/satisfies.js

@@ -31,16 +31,24 @@ export default define(class SatisfiesAssertion extends Assertion {
 
     context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertion...`);
 
-    const signatureVerifies = this.validateSignature(assignments, stated, context);
+    const valid = this.isValid(context);
 
-    if (signatureVerifies) {
-      const referenceVerifies = this.validateReference(assignments, stated, context);
+    if (valid) {
+      validates = true;
 
-      validates = referenceVerifies; ///
-    }
+      context.debug(`...the '${satisfiesAssertionString}' satisfies assertion is already valid.`);
+    } else {
+      const signatureVerifies = this.validateSignature(assignments, stated, context);
+
+      if (signatureVerifies) {
+        const referenceVerifies = this.validateReference(assignments, stated, context);
 
-    if (validates) {
-      context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion.`);
+        validates = referenceVerifies; ///
+      }
+
+      if (validates) {
+        context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion.`);
+      }
     }
 
     return validates;

package/src/element/assertion/subproof.js

@@ -27,14 +27,22 @@ export default define(class SubproofAssertion extends Assertion {
 
     context.trace(`Validating the '${subproofAssertionString}' subproof assertion...`);
 
-    const statementsValidate = this.validateStatements(assignments, stated, context);
+    const valid = this.isValid(context);
 
-    if (statementsValidate) {
+    if (valid) {
       validates = true;
-    }
 
-    if (validates) {
-      context.debug(`...validated the '${subproofAssertionString}' subproof assertion.`);
+      context.debug(`...the '${subproofAssertionString}' subproof assertion is already valid.`);
+    } else {
+      const statementsValidate = this.validateStatements(assignments, stated, context);
+
+      if (statementsValidate) {
+        validates = true;
+      }
+
+      if (validates) {
+        context.debug(`...validated the '${subproofAssertionString}' subproof assertion.`);
+      }
     }
 
     return validates;