occam-verify-cli 1.0.612 → 1.0.631

package/src/element/substitution/reference.js

@@ -47,7 +47,7 @@ export default define(class ReferenceSubstitution extends Substitution {
 
   getMetavariableName() { return this.targetReference.getMetavariableName(); }
 
-  matchMetavariableName(metavariableName) { return this.targetReference.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.targetReference.compareMetavariableName(metavariableName); }
 
   isTrivial() {
     const targetReferenceEqualToReplacementReference = this.targetReference.isEqualTo(this.replacementReference),
@@ -99,9 +99,9 @@ export default define(class ReferenceSubstitution extends Substitution {
       }
 
       if (validates) {
-        const substititoin = this;  ///
+        const subsitution = this;  ///
 
-        context.addSubstitution(substititoin);
+        context.addSubstitution(subsitution);
 
         context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
       }

package/src/element/substitution/statement.js

@@ -68,7 +68,7 @@ export default define(class StatementSubstitution extends Substitution {
 
   getMetavariableName() { return this.targetStatement.getMetavariableName(); }
 
-  matchMetavariableName(metavariableName) { return this.targetStatement.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.targetStatement.compareMetavariableName(metavariableName); }
 
   compareStatement(statement, context) {
     statement = stripBracketsFromStatement(statement, context); ///
@@ -135,9 +135,9 @@ export default define(class StatementSubstitution extends Substitution {
       }
 
       if (validates) {
-        const substititoin = this;  ///
+        const substitution = this;  ///
 
-        context.addSubstitution(substititoin);
+        context.addSubstitution(substitution);
 
         context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
       }

package/src/element/substitution/term.js

@@ -48,6 +48,8 @@ export default define(class TermSubstitution extends Substitution {
 
   getVariableIdentifier() { return this.targetTerm.getVariableIdentifier(); }
 
+  compareVariableIdentifier(variableIdentifier) { return this.targetTerm.compareVariableIdentifier(variableIdentifier); }
+
   isTrivial() {
     const targetTermEqualToReplacementTerm = this.targetTerm.isEqualTo(this.replacementTerm),
           trivial = targetTermEqualToReplacementTerm; ///
@@ -100,9 +102,9 @@ export default define(class TermSubstitution extends Substitution {
       }
 
       if (validates) {
-        const substititoin = this;  ///
+        const substitution = this;  ///
 
-        context.addSubstitution(substititoin);
+        context.addSubstitution(substitution);
 
         context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
       }

package/src/element/substitution.js

@@ -6,16 +6,6 @@ import { primitiveUtilities } from "occam-furtle";
 const { primitiveFromNode } =primitiveUtilities;
 
 export default class Substitution extends Element {
-  constructor(context, string, node) {
-    super(context, string, node);
-  }
-
-  getSubstitution() {
-    const substitution = null;
-
-    return substitution;
-  }
-
   getPrimitive() {
     const context = this.getContext(),
           replacementNode = this.getReplacementNode(),
@@ -32,18 +22,6 @@ export default class Substitution extends Element {
     return substitutionNode;
   }
 
-  getNetavariableName() {
-    const metavariableName = null;
-
-    return metavariableName;
-  }
-
-  getVariableIdentifier() {
-    const variableIdentifier = null;
-
-    return variableIdentifier;
-  }
-
   matchSubstitutionNode(substitutionNode) {
     const substitutionNodeA = substitutionNode; ///
 
@@ -72,12 +50,6 @@ export default class Substitution extends Element {
     return equalTo;
   }
 
-  isSimple() {
-    const simple = true;
-
-    return simple;
-  }
-
   isComplex() {
     const simple = this.isSimple(),
           complex = !simple;
@@ -85,12 +57,6 @@ export default class Substitution extends Element {
     return complex;
   }
 
-  isTrivial() {
-    const trivial = false;
-
-    return trivial;
-  }
-
   isNonTrivial() {
     const trivial = this.isTrivial(),
           nonTrivlal = !trivial;
@@ -98,22 +64,64 @@ export default class Substitution extends Element {
     return nonTrivlal;
   }
 
+  getVariable() {
+    const variable = null;
+
+    return variable;
+  }
+
+  getSubstitution() {
+    const substitution = null;
+
+    return substitution;
+  }
+
+  getMetavariable() {
+    const metavariable = null;
+
+    return metavariable;
+  }
+
+  getMetavariableName() {
+    const metavariableName = null;
+
+    return metavariableName;
+  }
+
+  getVariableIdentifier() {
+    const variableIdentifier = null;
+
+    return variableIdentifier;
+  }
+
+  isSimple() {
+    const simple = true;
+
+    return simple;
+  }
+
+  isTermEqualToTerm(term) {
+    const termEqualToTerm = false;
+
+    return termEqualToTerm;
+  }
+
   isFrameEqualToFrame(frame) {
     const frameEqualToFrame = false;
 
     return frameEqualToFrame;
   }
 
-  isReferenceEqualToReference(reference) {
-    const referenceEqualToReference = false;
+  isStatementEqualToStatement(statement) {
+    const statementEqualToStatement = false;
 
-    return referenceEqualToReference;
+    return statementEqualToStatement;
   }
 
-  compare(substitution) {
-    const comparesToSubstitution = false;
+  isReferenceEqualToReference(reference) {
+    const referenceEqualToReference = false;
 
-    return comparesToSubstitution;
+    return referenceEqualToReference;
   }
 
   compareTerm(term, context) {
@@ -140,6 +148,18 @@ export default class Substitution extends Element {
     return compaaresToMetavariable;
   }
 
+  compareMetavariableName(metavariableName) {
+    const comparesToMetavariableName = false;
+
+    return comparesToMetavariableName;
+  }
+
+  compareVariableIdentifier(variableIdentifier) {
+    const comparesToVariableIdentifier = false;
+
+    return comparesToVariableIdentifier;
+  }
+
   resolve(substitutions, generalContext, specificContext) {
     const resolved = true;
 

package/src/element/term.js

@@ -44,12 +44,30 @@ export default define(class Term extends Element {
     termNode = this.getTermNode();
 
     const termNodeB = termNode, ///
-      termNodeAAMatchesTermBNodeB = termNodeA.match(termNodeB),
-      equalTo = termNodeAAMatchesTermBNodeB; ///
+          termNodeAAMatchesTermBNodeB = termNodeA.match(termNodeB),
+          equalTo = termNodeAAMatchesTermBNodeB; ///
 
     return equalTo;
   }
 
+  compareVariableIdentifier(variableIdentifier) {
+    let comparesToVariableIdentifier = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const variableIdentifierA = variableIdentifier; ///
+
+      variableIdentifier = this.getVariableIdentifier();
+
+      const variableIdentifierB = variableIdentifier;
+
+      comparesToVariableIdentifier = (variableIdentifierA === variableIdentifierB);
+    }
+
+    return comparesToVariableIdentifier;
+  }
+
   isValid(context) {
     const termNode = this.getTermNode(),
           termPresent = context.isTermPresentByTermNode(termNode),

package/src/element/topLevelAssertion/axiom.js

@@ -5,6 +5,13 @@ import TopLevelAssertion  from "../../node/topLevelAssertion";
 import { define } from "../../elements";
 
 export default define(class Axiom extends TopLevelAssertion {
+  getAxiomNode() {
+    const node = this.getNode(),
+          axiomNode = node; ///
+
+    return axiomNode;
+  }
+
   isSatisfiable() {
     const signature = this.getSignature(),
           satisfiable = (signature !== null);

package/src/element/topLevelAssertion/conjecture.js

@@ -5,6 +5,13 @@ import TopLevelAssertion from "../topLevelAssertion";
 import { define } from "../../elements";
 
 export default define(class Conjecture extends TopLevelAssertion {
+  getConjectureNode() {
+    const node = this.getNode(),
+          conjectureNode = node;  ///
+
+    return conjectureNode;
+  }
+
   async verify() {
     let verifies;
 

package/src/element/topLevelAssertion/lemma.js

@@ -5,6 +5,13 @@ import TopLevelAssertion from "../topLevelAssertion";
 import { define } from "../../elements";
 
 export default define(class Lemma extends TopLevelAssertion {
+  getLemmaNode() {
+    const node = this.getNode(),
+          lemmaNode = node; ///
+
+    return lemmaNode;
+  }
+
   async verify() {
     let verifies;
 

package/src/element/topLevelAssertion/theorem.js

@@ -5,6 +5,13 @@ import TopLevelAssertion from "../topLevelAssertion";
 import { define } from "../../elements";
 
 export default define(class Theorem extends TopLevelAssertion {
+  getThoeremNode() {
+    const node = this.getNode(),
+          theoremNode = node; ///
+
+    return theoremNode;
+  }
+
   async verify() {
     let verifies;
 

package/src/element/topLevelAssertion.js

@@ -255,15 +255,13 @@ export default class TopLevelAssertion extends Element {
             suppositionVerifies = await supposition.verify(assignments, context)
 
       if (suppositionVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const subproofOrProofAssertion = supposition;  ////
+        const subproofOrProofAssertion = supposition;  ////
 
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });
 
@@ -286,15 +284,7 @@ export default class TopLevelAssertion extends Element {
         const subproofOrProofAssertionsUnifiesWithSuppositions = await this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context);
 
         if (subproofOrProofAssertionsUnifiesWithSuppositions) {
-          const specificContext = context;  ///
-
-          context = this.getContext();
-
-          const generalContext = context; ///
-
-          context = specificContext;  ///
-
-          const substitutionsResolved = context.areSubstitutionsResolved(generalContext, specificContext);
+          const substitutionsResolved = context.areSubstitutionsResolved();
 
           if (substitutionsResolved) {
             statementAndSubproofOrProofAssertionsUnify = true;

package/src/element/topLevelMetaAssertion/metaLemma.js

@@ -5,6 +5,13 @@ import TopLevelMetaAssertion from "./../topLevelMetaAssertion";
 import { define } from "../../elements";
 
 export default define(class MetaLemma extends TopLevelMetaAssertion {
+  getMetaLemmaNode() {
+    const node = this.getNode(),
+          metaLemmaNode = node; ///
+
+    return metaLemmaNode;
+  }
+
   async verify() {
     let verifies;
 

package/src/element/topLevelMetaAssertion/metatheorem.js

@@ -5,6 +5,13 @@ import TopLevelMetaAssertion from "../topLevelMetaAssertion";
 import { define } from "../../elements";
 
 export default define(class Metatheorem extends TopLevelMetaAssertion {
+  getMetatheoremNode() {
+    const node = this.getNode(),
+          metatheoremNode = node; ///
+
+    return metatheoremNode;
+  }
+
   async verify() {
     let verifies;
 

package/src/element/topLevelMetaAssertion.js

@@ -159,15 +159,13 @@ export default class TopLevelMetaAssertion extends Element {
             suppositionVerifies = await supposition.verify(assignments, context)
 
       if (suppositionVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const subproofOrProofAssertion = supposition;  ////
+        const subproofOrProofAssertion = supposition;  ////
 
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });
 

package/src/element/type.js

@@ -32,6 +32,13 @@ export default define(class Type extends Element {
     return this.superTypes;
   }
 
+  getTypeNode() {
+    const node = this.getNode(),
+          typeNode = node;  ///
+
+    return typeNode;
+  }
+
   getProperties(includeSuperTypes = true) {
     const properties = [];
 

package/src/element/typePrefix.js

@@ -15,6 +15,13 @@ export default define(class TypePrefix extends Element {
     return this.name;
   }
 
+  getTypePrefixNode() {
+    const node = this.getNode(),
+          typePrefixNode = node;  ///
+
+    return typePrefixNode;
+  }
+
   compareTypePrefixName(typePrefixName) {
     const comparesToTypePrefixName = (this.name === typePrefixName);
 

package/src/element/variable.js

@@ -2,6 +2,8 @@
 
 import { Element } from "occam-languages";
 
+import elements from "../elements";
+
 import { define } from "../elements";
 import { typeToTypeJSON } from "../utilities/json";
 
@@ -30,6 +32,13 @@ export default define(class Variable extends Element {
     this.type = type;
   }
 
+  getVariableNode() {
+    const node = this.getNode(),
+          variableNode = node;  //
+
+    return variableNode;
+  }
+
   getTypeString() { return this.type.getString(); }
 
   isIdentifierEqualTo(identifier) {
@@ -162,10 +171,6 @@ export default define(class Variable extends Element {
               termSubstitutionValidates = termSubstitution.validate(generalContext, specificContext);
 
         if (termSubstitutionValidates) {
-          substitution = termSubstitution;  ///
-
-          context.addSubstitution(substitution);
-
           termUnifies = true;
         }
       }

package/src/preamble.js

@@ -38,7 +38,6 @@ import Metatheorem from "./element/topLevelMetaAssertion/metatheorem";
 import Equivalence from "./element/equivalence";
 import Equivalences from "./element/equivalences";
 import Metavariable from "./element/metavariable";
-import Substitutions from "./element/substitutions";
 import ProcedureCall from "./element/procedureCall";
 import SubDerivation from "./element/subDerivation";
 import TypeAssertion from "./element/assertion/type";

package/src/process/assign.js

@@ -1,59 +1,134 @@
 "use strict";
 
-export function variableAssignmentFromVariable(variable) {
-  return function (context) {
-    const nested = false;
+import { variableFromVariableNode } from "../utilities/element";
 
-    context.addVariable(variable, nested);
+export function equalityAssignmentFromEquality(equality, context) {
+  const equalityAssignment = (context) => {
+    const equalityAdded = context.addEquality(equality);
 
-    const variableTypeString = variable.getTypeString(),
-          variableString = variable.getString(),
-          assigned = true;
+    return equalityAdded;
+  };
 
-    assigned ?
-      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeString}'.`) :
-        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeString}'.`);
+  return equalityAssignment;
+}
 
-    return assigned;
+export function judgementAssignmentFromJudgement(judgement, context) {
+  const judgementAssignment = (context) => {
+    const judgementAdded = context.addJudgement(judgement);
+
+    return judgementAdded;
   };
+
+  return judgementAssignment;
 }
 
-export function equalityAssignmentFromEquality(equality) {
-  return function (context) {
-    const equalityString = equality.getString(),
-          equalityAdded = context.addEquality(equality),
-          assigned = equalityAdded; ///
+export function leftVariableAssignmentFromEquality(equality, context) {
+  let leftVariableAssignment = null;
 
-    assigned ?
-      context.trace(`Assigned the '${equalityString}' equality.`) :
-        context.debug(`Unable to assign the '${equalityString}' equality.`);
+  const leftTermNode = equality.getLeftTermNode(),
+        singularVariableNode = leftTermNode.getSingularVariableNode();
 
-    return assigned;
-  };
+  if (singularVariableNode !== null) {
+    const type = equality.getType(),
+          leftVariableNode = singularVariableNode;  ///
+
+    leftVariableAssignment = variableAssignmentFromVariableNodeAndType(leftVariableNode, type, context);
+  }
+
+  return leftVariableAssignment;
 }
 
-export function judgementAssignmentFromJudgement(judgement) {
-  return function (context) {
-    const judgementString = judgement.getString(),
-          judgementAdded = context.addJudgement(judgement),
-          assigned = judgementAdded; ///
+export function rightVariableAssignmentFromEquality(equality, context) {
+  let rightVariableAssignment = null;
 
-    assigned ?
-      context.trace(`Assigned the '${judgementString}' judgement.`) :
-        context.debug(`Unable to assign the '${judgementString}' judgement.`);
+  const rightTermNode = equality.getRightTermNode(),
+        singularVariableNode = rightTermNode.getSingularVariableNode();
 
-    return assigned;
-  };
+  if (singularVariableNode !== null) {
+    const type = equality.getType(),
+          rightVariableNode = singularVariableNode;  ///
+
+    rightVariableAssignment = variableAssignmentFromVariableNodeAndType(rightVariableNode, type, context);
+  }
+
+  return rightVariableAssignment;
 }
 
-export default function assignAssignments(assignments, context) {
-  const assignmentsAssigned = assignments.every((assigment) => {
-    const assigned = assigment(context);
+export function variableAssignmentFromTypeAssertion(typeAssertion, context) {
+
+  debugger
 
-    if (assigned) {
-      return true;
-    }
+  // const { Type, Variable } = elements,
+  //   termNode = this.term.getNode();
+  //
+  // let type,
+  //   provisional;
+  //
+  // provisional = this.type.isProvisional();
+  //
+  // if (!provisional) {
+  //   type = this.type;
+  // } else {
+  //   provisional = false;
+  //
+  //   type = Type.fromTypeAndProvisional(this.type, provisional);
+  // }
+  //
+  // const singularVariableNode = termNode.getSingularVariableNode();
+  //
+  // if (singularVariableNode !== null) {
+  //   const variableNode = singularVariableNode,  ///
+  //     variable = Variable.fromVariableNodeAndType(variableNode, type, context),
+  //     variableAssignment = variableAssignmentFromVariable(variable),
+
+}
+
+export function variableAssignmentFromPrepertyAssertion(propertyAssertion, context) {
+
+  debugger
+
+  // let variable;
+  //
+  // const { Variable } = elements,
+  //   termNode = this.term.getNode();
+  //
+  // variable = Variable.fromTermNode(termNode, context);
+  //
+  // if (variable !== null) {
+  //   const variableIdentifier = variable.getIdentifier();
+  //
+  //   variable = context.findVariableByVariableIdentifier(variableIdentifier);
+  //
+  //   variable = Variable.fromVariableAndPropertyRelation(variable, this.propertyRelation);
+  //
+  //   const variableAssignment = variableAssignmentFromVariable(variable),
+
+  }
+
+export default function assignAssignments(assignments, context) {
+  assignments.forEach((assignment) => {
+    assignment(context);
   });
+}
+
+function variableAssignmentFromVariableNodeAndType(variableNode, type, context) {
+  const variable = variableFromVariableNode(variableNode, context);
+
+  variable.setType(type);
+
+  const variableAssignment = (context) => {
+    context.addVariable(variable);
+
+    const variableTypeString = variable.getTypeString(),
+          variableString = variable.getString(),
+          assigned = true;
+
+    assigned ?
+      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeString}'.`) :
+        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeString}'.`);
+
+    return assigned;
+  };
 
-  return assignmentsAssigned;
+  return variableAssignment;
 }

package/src/process/unify.js

@@ -2,7 +2,6 @@
 
 import { ZipPass, queryUtilities } from "occam-languages";
 
-import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { termFromTermNode, frameFromFrameNode, statementFromStatementNode } from "../utilities/element";
 
 const { nodeQuery } = queryUtilities;
@@ -161,7 +160,7 @@ class CombinatorPass extends ZipPass {
         context = generalContext; ///
 
         const metaTypeName = metaTypeNode.getMetaTypeName(),
-              metaType = findMetaTypeByMetaTypeName(metaTypeName);
+              metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
 
         context = specificContext;  ///
 
@@ -189,7 +188,7 @@ class CombinatorPass extends ZipPass {
         context = generalContext; ///
 
         const metaTypeName = metaTypeNode.getMetaTypeName(),
-              metaType = findMetaTypeByMetaTypeName(metaTypeName);
+              metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
 
         context = specificContext;  ///
 

package/src/process/validate.js

@@ -92,8 +92,8 @@ class StatementPass extends ForwardPass {
         let success = false;
 
         const statement = statementFromStatementNode(statementNode, context),
-              assignments = null,
               stated = false,
+              assignments = null,
               statementValidates = statement.validate(assignments, stated, context);
 
         if (statementValidates) {