occam-verify-cli 1.0.892 → 1.0.896

package/src/element/property.js

@@ -6,22 +6,22 @@ import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateProperty } from "../process/instantiate";
 import { nameFromPropertyNode } from "../utilities/element";
-import { nominalTypeNameFromJSON, nominalTypeNameToNominalTypeNameJSON } from "../utilities/json";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 export default define(class Property extends Element {
-  constructor(context, string, node, lineIndex, name, nominalTypeName) {
+  constructor(context, string, node, lineIndex, name, type) {
     super(context, string, node, lineIndex);
 
     this.name = name;
-    this.nominalTypeName = nominalTypeName;
+    this.type = type;
   }
 
   getName() {
     return this.name;
   }
 
-  getNominalTypeName() {
-    return this.nominalTypeName;
+  getType() {
+    return this.type;
   }
 
   getPropertyNode() {
@@ -31,16 +31,34 @@ export default define(class Property extends Element {
     return properetyNode;
   }
 
-  comparePropertyName(propertyName) {
-    const comparesToPropertyName = (this.name === propertyName);
+  setName(name) {
+    this.name = name;
+  }
 
-    return comparesToPropertyName;
+  setType(type) {
+    this.type = type;
   }
 
-  compareNominalTypeName(nominalTypeName) {
-    const comparesToNominalTypeName = (this.nominalTypeName === nominalTypeName);
+  isEqualTo(property) {
+    const propertyNode = property.getNode(),
+          propertyNodeMatches = this.matchPropertyNode(propertyNode),
+          equalTo = propertyNodeMatches;  ///
 
-    return comparesToNominalTypeName;
+    return equalTo;
+  }
+
+  matchPropertyNode(propertyNode) {
+    const node = propertyNode, ///
+          nodeMatches = this.matchNode(node),
+          propertyNodeMatches = nodeMatches; ///
+
+    return propertyNodeMatches;
+  }
+
+  comparePropertyName(propertyName) {
+    const comparesToPropertyName = (this.name === propertyName);
+
+    return comparesToPropertyName;
   }
 
   verify(properties, context) {
@@ -53,11 +71,7 @@ export default define(class Property extends Element {
     const naemVerifies = this.verifyName(properties, context);
 
     if (naemVerifies) {
-      const nominalTypeNameVerifies = this.verifyNominalTypeName(context);
-
-      if (nominalTypeNameVerifies) {
-        verifies = true;
-      }
+      verifies = true;
     }
 
     if (verifies) {
@@ -76,41 +90,21 @@ export default define(class Property extends Element {
 
     const propertyName = this.name, ///
           count = properties.reduce((count, property) => {
-            const propertyComparesToPropertyName = property.comparePropertyName(propertyName);
+            if (property !== this) {
+              const propertyComparesToPropertyName = property.comparePropertyName(propertyName);
 
-            if (propertyComparesToPropertyName) {
-              count++;
+              if (propertyComparesToPropertyName) {
+                count++;
+              }
             }
 
             return count;
           }, 0);
 
-    if (count > 1) {
-      context.debug(`The '${propertyString}' property appears more than once.`);
+    if (count === 0) {
+      naemVerifies = true;
     } else {
-      const superTypes = this.type.getSuperTypes(),
-            superType = superTypes.find((superType) => {
-              const superTypeProperties = superType.getProperties(),
-                    superTypePropertyComparesToPropertyName = superTypeProperties.some((superTypeProperty) => {
-                      const superTypePropertyComparesToPropertyName = superTypeProperty.comparePropertyName(propertyName);
-
-                      if (superTypePropertyComparesToPropertyName) {
-                        return true;
-                      }
-                    });
-
-              if (superTypePropertyComparesToPropertyName) {
-                return true;
-              }
-            }) || null;
-
-      if (superType !== null) {
-        const superTypeString = superType.getString();
-
-        context.debug(`The '${superTypeString}' super-type has the same property.`);
-      } else {
-        naemVerifies = true;
-      }
+      context.debug(`The '${propertyString}' property appears more than once.`);
     }
 
     if (naemVerifies) {
@@ -120,41 +114,53 @@ export default define(class Property extends Element {
     return naemVerifies;
   }
 
-  verifyNominalTypeName(context) {
-    let nominalTypeNameVerifies = false;
+  findValidProperty(context) {
+    const propertyNode = this.getPropertyNode(),
+          property = context.findPropertyByPropertyNode(propertyNode),
+          validProperty = property; ///
 
-    const propertyString = this.getString();  ///
+    return validProperty;
+  }
 
-    context.trace(`Verifying the '${propertyString}' property's nominal type name...`);
+  validate(context) {
+    let property = null;
 
-    const typeComparesToNominalTypeName = this.type.compareNominalTypeName(this.nominalTypeName);
+    const propertyString = this.getString(); ///
 
-    if (typeComparesToNominalTypeName) {
-      nominalTypeNameVerifies = true;
+    context.trace(`Validating the '${propertyString}' property...`);
+
+    const validProperty = this.findValidProperty(context);
+
+    if (validProperty) {
+      property = validProperty; ///
+
+      context.debug(`...the '${propertyString}' property is already valid.`);
     } else {
-      const typePresent = context.isTypePresentByNominalTypeName(this.nominalTypeName);
+      let validates = false;
 
-      if (typePresent) {
-        nominalTypeNameVerifies = true;
-      }
-    }
+      debugger
+
+      if (validates) {
+        const property = this; ///
 
-    if (nominalTypeNameVerifies) {
-      context.debug(`...verifies the '${propertyString}' property's nominal type name.`);
+        context.addProperty(property);
+
+        context.debug(`...validated the '${propertyString}' property.`);
+      }
     }
 
-    return nominalTypeNameVerifies;
+    return property;
   }
 
   toJSON() {
-    const nominalTypeNameJSON = nominalTypeNameToNominalTypeNameJSON(this.nominalTypeName),
-          nominalTypeName = nominalTypeNameJSON,  ///
+    const typeJSON = typeToTypeJSON(this.type),
           string = this.getString(),
           lineIndex = this.getLineIndex(),
+          type = typeJSON,  ///
           json = {
             string,
             lineIndex,
-            nominalTypeName
+            type
           };
 
     return json;
@@ -168,11 +174,11 @@ export default define(class Property extends Element {
             propertyNode = instantiateProperty(string, context),
             node = propertyNode,  ///
             name = nameFromPropertyNode(propertyNode, context),
-            nominalTypeName = nominalTypeNameFromJSON(json);
+            type = typeFromJSON(json, context);
 
       context = null;
 
-      const property = new Property(context, string, node, lineIndex, name, nominalTypeName);
+      const property = new Property(context, string, node, lineIndex, name, type);
 
       return property;
     }, context);

package/src/element/propertyRelation.js

@@ -30,34 +30,74 @@ export default define(class PropertyRelation extends Element {
     return propertyRelationNode;
   }
 
-  verify(context) {
-    let verifies = false;
+  isEqualTo(propertyRelation) {
+    const propertyRelationNode = propertyRelation.getNode(),
+          propertyRelationNodeMatches = this.matchPropertyRelationNode(propertyRelationNode),
+          equalTo = propertyRelationNodeMatches;  ///
+
+    return equalTo;
+  }
+
+  matchPropertyRelationNode(propertyRelationNode) {
+    const node = propertyRelationNode, ///
+          nodeMatches = this.matchNode(node),
+          propertyRelationNodeMatches = nodeMatches; ///
+
+    return propertyRelationNodeMatches;
+  }
+
+  findValidPropertyRelation(context) {
+    const propertyRelationNode = this.getPropertyRelationNode(),
+          propertyRelation = context.findPropertyRelationByPropertyRelationNode(propertyRelationNode),
+          validPropertyRelation = propertyRelation; ///
+
+    return validPropertyRelation;
+  }
+
+  validate(context) {
+    let propertyRelation = null;
 
     const propertyRelationString = this.getString(); ///
 
-    context.trace(`Verifying the '${propertyRelationString}' property relation...`);
+    context.trace(`Validating the '${propertyRelationString}' property relation...`);
 
-    const termValidates = this.validateTerm(context);
+    const validPropertyRelation = this.findValidPropertyRelation(context);
 
-    if (termValidates) {
-      const propertyVerifies = this.verifyProperty(context);
+    if (validPropertyRelation) {
+      propertyRelation = validPropertyRelation; ///
 
-      verifies = propertyVerifies;
-    }
+      context.debug(`...the '${propertyRelationString}' property relation is already valid.`);
+    } else {
+      let validates = false;
+
+      const termValidates = this.validateTerm(context);
+
+      if (termValidates) {
+        const propertyVerifies = this.verifyProperty(context);
+
+        validates = propertyVerifies;
+      }
 
-    if (verifies) {
-      context.debug(`...verified the '${propertyRelationString}' property relation.`);
+      if (validates) {
+        const propertyRelation = this; ///
+
+        this.assign(context);
+
+        context.addPropertyRelation(propertyRelation);
+
+        context.debug(`...validated the '${propertyRelationString}' property relation.`);
+      }
     }
 
-    return verifies;
+    return propertyRelation;
   }
 
   validateTerm(context) {
     let termValidates = false;
 
-    const termString = this.term.getString();
+    const propertyRelationString = this.getString(); ///
 
-    context.trace(`Validating the '${termString}' term...`);
+    context.trace(`Validating the '${propertyRelationString}' property relation's term...`);
 
     const term = this.term.validate(context, (term) => {
       const validatesForwards = true;
@@ -72,7 +112,7 @@ export default define(class PropertyRelation extends Element {
     }
 
     if (termValidates) {
-      context.debug(`...validated the '${termString}' term.`);
+      context.debug(`...validated the '${propertyRelationString}' property relation's term.`);
     }
 
     return termValidates;

package/src/utilities/element.js

@@ -171,12 +171,15 @@ export function axiomFromAxiomNode(axiomNode, context) {
         deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
-        hypotheses = [],
+        hypotheses = hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = axiomNode, ///
         string = topLevelAsssertionString, ///
-        lineIndex = null,
-        axiom = new Axiom(context, string, node, lineIndex, labels, suppositions, deduction, proof, signature, hypotheses);
+        lineIndex = null;
+
+  context = null;
+
+  const axiom = new Axiom(context, string, node, lineIndex, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return axiom;
 }
@@ -220,7 +223,7 @@ export function theoremFromTheoremNode(theoremNode, context) {
         deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
-        hypotheses = [],
+        hypotheses = hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = theoremNode, ///
         string = topLevelAsssertionString, ///
@@ -241,13 +244,12 @@ export function propertyFromPropertyNode(propertyNode, context) {
           node = propertyNode, ///
           string = context.nodeAsString(node),
           lineIndex = null,
-          propertyName = propertyNode.getPropertyName(),
-          nominalTypeName = null,
-          name = propertyName;  ///
+          name = nameFromPropertyNode(propertyNode, context),
+          type = typeFromPropertyNode(propertyNode, context);
 
     context = null;
 
-    property = new Property(context, string, node, lineIndex, name, nominalTypeName);
+    property = new Property(context, string, node, lineIndex, name, type);
   }
 
   return property;
@@ -258,9 +260,9 @@ export function variableFromVariableNode(variableNode, context) {
         node = variableNode,  ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        type = null,
+        type = typeFromVariableNode(variableNode, context),
         identifier = identifierFromVarialbeNode(variableNode, context),
-        propertyRelations = [];
+        propertyRelations = propertyRelationsFromVariableNode(variableNode, context);
 
   context = null;
 
@@ -271,12 +273,12 @@ export function variableFromVariableNode(variableNode, context) {
 
 export function subproofFromSubproofNode(subproofNode, context) {
   const { Subproof } = elements,
-        node = subproofNode, ///
+        node = subproofNode,  ///
+        lineIndex = null,
         suppositions = suppositionsFromSubproofNode(subproofNode, context),
         subDerivation = subDerivationFromSubproofNode(subproofNode, context),
         subproofString = subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation, context),
-        string = subproofString,  ///
-        lineIndex = null;
+        string = subproofString;  ///
 
   context = null;
 
@@ -390,8 +392,8 @@ export function parameterFromParameterNode(parameterNode, context) {
         node = parameterNode, ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        name = parameterNode.getName(),
-        identifier = parameterNode.getIdentifier();
+        name = nameFromParamterNode(parameterNode, context),
+        identifier = identifierFromParamterNode(parameterNode, context);
 
   context = null;
 
@@ -436,7 +438,7 @@ export function conjectureFromConjectureNode(conjectureNode, context) {
         deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
-        hypotheses = [],
+        hypotheses = hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = conjectureNode, ///
         string = topLevelAsssertionString, ///
@@ -746,9 +748,9 @@ export function containedAssertionFromContainedAssertionNode(containedAssertionN
         node = containedAssertionNode,  ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        negated = containedAssertionNode.isNegated(),
         term = termFromContainedAssertionNode(containedAssertionNode, context),
         frame = frameFromContainedAssertionNode(containedAssertionNode, context),
+        negated = negatedFromContainedAssertionNode(containedAssertionNode, context),
         statement = statementFromContainedAssertionNode(containedAssertionNode, context);
 
   context = null;
@@ -792,10 +794,8 @@ export function propertyDeclarationFromPropertyDeclarationNode(propertyDeclarati
         node = propertyDeclarationNode,  ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        typeNode = propertyDeclarationNode.getTypeNode(),
-        propertyNode = propertyDeclarationNode.getPropertyNode(),
-        type = typeFromTypeNode(typeNode, context),
-        property = propertyFromPropertyNode(propertyNode, context);
+        type = typeFromPropertyDeclarationNode(propertyDeclarationNode, context),
+        property = propertyFromPropertyDeclarationNode(propertyDeclarationNode, context);
 
   context = null;
 
@@ -809,11 +809,9 @@ export function variableDeclarationFromVariableDeclarationNode(variableDeclarati
         node = variableDeclarationNode,  ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        typeNode = variableDeclarationNode.getTypeNode(),
-        provisional = variableDeclarationNode.isProvisional(),
-        variableNode = variableDeclarationNode.getVariableNode(),
-        type = typeFromTypeNode(typeNode, context),
-        variable = variableFromVariableNode(variableNode, context);
+        type = typeFromVariableDeclarationNode(variableDeclarationNode, context),
+        variable = variableFromVariableDeclarationNode(variableDeclarationNode, context),
+        provisional = provisionalFromVariableDeclarationNode(variableDeclarationNode, context);
 
   context = null;
 
@@ -1065,7 +1063,26 @@ export function lemmaFromSectionNode(sectionNode, context) {
 }
 
 export function nameFromPropertyNode(propertyNode, context) {
-  const name = propertyNode.getName();
+  const propertyName = propertyNode.getPropertyName(),
+        name = propertyName;
+
+  return name;
+}
+
+export function typeFromPropertyNode(propertyNode, context) {
+  const type = null;  ///
+
+  return type;
+}
+
+export function typeFromVariableNode(variableNode, context) {
+  const type = null;
+
+  return type;
+}
+
+export function nameFromParamterNode(parameterNode, context) {
+  const name = parameterNode.getName();
 
   return name;
 }
@@ -1329,6 +1346,12 @@ export function identifierFromVarialbeNode(variableNode, context) {
   return identifier;
 }
 
+export function identifierFromParamterNode(parameterNode, context) {
+  const identifier = parameterNode.getIdentifier();
+
+  return identifier;
+}
+
 export function statementFromDeductionNode(deductionNode, context) {
   let statement = null;
 
@@ -1653,6 +1676,20 @@ export function labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context)
   return labels;
 }
 
+export function typeFromPropertyDeclarationNode(propertyDeclarationNode, context) {
+  const typeNode = propertyDeclarationNode.getTypeNode(),
+        type = typeFromTypeNode(typeNode, context);
+
+  return type;
+}
+
+export function typeFromVariableDeclarationNode(variableDeclarationNode, context) {
+  const typeNode = variableDeclarationNode.getTypeNode(),
+        type = typeFromTypeNode(typeNode, context);
+
+  return type;
+}
+
 export function procedureCallFromSuppositionNode(suppositionNode, context) {
   let procedureCall = null;
 
@@ -1672,7 +1709,7 @@ export function negatedFromJDefinedAssertionNode(definedAssertionNode, context)
 }
 
 export function propertyFromPropertyRelationNode(propertyRelationNode, context) {
-  const propertyNode = propertyRelationNode.getTermNode(),
+  const propertyNode = propertyRelationNode.getPropertyNode(),
         property = propertyFromPropertyNode(propertyNode, context);
 
   return property;
@@ -1692,6 +1729,12 @@ export function typeFromBracketedConstructorNode(bracketedCcnstructorNode, conte
   return type;
 }
 
+export function propertyRelationsFromVariableNode(variableNode, context) {
+  const propertyRelations = [];
+
+  return propertyRelations;
+}
+
 export function definedAssertionFromStatementNode(statementNode, context) {
   let definedAssertion = null;
 
@@ -1855,6 +1898,20 @@ export function hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, cont
   return ypotheses;
 }
 
+export function propertyFromPropertyDeclarationNode(propertyDeclarationNode, context) {
+  const propertyNode = propertyDeclarationNode.getPropertyNode(),
+        property = propertyFromPropertyNode(propertyNode, context);
+
+  return property;
+}
+
+export function variableFromVariableDeclarationNode(variableDeclarationNode, context) {
+  const variableNode = variableDeclarationNode.getVariableNode(),
+        variable = variableFromVariableNode(variableNode, context);
+
+  return variable;
+}
+
 export function statementFromBracketedCombinatorNode(bracketedCombinatorNode, context) {
   const statementNode = bracketedCombinatorNode.getStatementNode(),
         statement = statementFromStatementNode(statementNode, context);
@@ -1927,6 +1984,12 @@ export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode,
   return deduction;
 }
 
+export function provisionalFromVariableDeclarationNode(variableDeclarationNode, context) {
+  const provisional = variableDeclarationNode.isProvisional();
+
+  return provisional;
+}
+
 export function procedureReferenceFromProcedureCallNode(procedureCallNode, context) {
   const procedureReferenceNode = procedureCallNode.getProcedureReferenceNode(),
         procedureReference = procedureReferenceFromProcedureReferenceNode(procedureReferenceNode, context);

package/src/utilities/json.js

@@ -221,12 +221,6 @@ export function procedureCallFromJSON(json, context) {
   return procedureCall;
 }
 
-export function nominalTypeNameFromJSON(json, context) {
-  const { nominalTypeName } = json;
-
-  return nominalTypeName;
-}
-
 export function procedureReferenceFromJSON(json, context) {
   let { procedureReference } = json;
 
@@ -381,22 +375,6 @@ export function variablesFromJSON(json, context) {
   return variables;
 }
 
-export function equalitiesFromJSON(json, context) {
-  let { equalities } = json;
-
-  const { Equality } = elements,
-        equalitiesJSON = equalities; ///
-
-  equalities = equalitiesJSON.map((equalityJSON) => {
-    const json = equalityJSON,  ///
-          equality = Equality.fromJSON(json, context);
-
-    return equality;
-  });
-
-  return equalities;
-}
-
 export function propertiesFromJSON(json, context) {
   let { properties } = json;
 
@@ -413,6 +391,22 @@ export function propertiesFromJSON(json, context) {
   return properties;
 }
 
+export function equalitiesFromJSON(json, context) {
+  let { equalities } = json;
+
+  const { Equality } = elements,
+    equalitiesJSON = equalities; ///
+
+  equalities = equalitiesJSON.map((equalityJSON) => {
+    const json = equalityJSON,  ///
+      equality = Equality.fromJSON(json, context);
+
+    return equality;
+  });
+
+  return equalities;
+}
+
 export function superTypesFromJSON(json, context) {
   const { superTypes: superTypesJSON } = json;
 
@@ -877,12 +871,6 @@ export function procedureCallToProcedureCallJSON(procedureCall) {
   return procedureCallJSON;
 }
 
-export function nominalTypeNameToNominalTypeNameJSON(nominalTypeName) {
-  const nominalTypeNameJSON = nominalTypeName;  ///
-
-  return nominalTypeNameJSON;
-}
-
 export function mnemicContextToMnemicContextJSON(mnemicContext) {
   const mnemicContextJSON = mnemicContext.toJSON();
 

package/src/utilities/synoptic.js

@@ -24,6 +24,16 @@ export function compressFrames(frames) {
   });
 }
 
+export function compressProperties(properties) {
+  compress(properties, (propertyA, propertyB) => {
+    const propertyAEqualToPropertyB = propertyA.isEqualTo(propertyB);
+
+    if (!propertyAEqualToPropertyB) {
+      return true;
+    }
+  });
+}
+
 export function compressEqualities(equalities) {
   compress(equalities, (equalityA, equalityB) => {
     const equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
@@ -102,4 +112,14 @@ export function compressSubstitutions(substitutions) {
       return true;
     }
   });
-}
+}
+
+export function compressPropertyRelations(propertyRelations) {
+  compress(propertyRelations, (propertyRelationA, propertyRelationB) => {
+    const propertyRelationAEqualToPropertyRelationB = propertyRelationA.isEqualTo(propertyRelationB);
+
+    if (!propertyRelationAEqualToPropertyRelationB) {
+      return true;
+    }
+  });
+}