occam-verify-cli 1.0.890 → 1.0.895

package/src/utilities/element.js

@@ -10,7 +10,8 @@ import { equivalenceStringFromTerms,
          subproofStringFromSuppositionsAndSubDerivation,
          procedureCallStringFromProcedureReferenceAndParameters,
          topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
-         topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
+         topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction,
+         complexTypeDeclarationStringFromTypeSuperTypesAndProvisional } from "../utilities/string";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -170,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;
 }
@@ -219,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, ///
@@ -233,17 +237,20 @@ export function theoremFromTheoremNode(theoremNode, context) {
 }
 
 export function propertyFromPropertyNode(propertyNode, context) {
-  const { Property } = elements,
-        node = propertyNode, ///
-        string = context.nodeAsString(node),
-        lineIndex = null,
-        propertyName = propertyNode.getPropertyName(),
-        nominalTypeName = null,
-        name = propertyName;  ///
+  let property = null;
 
-  context = null;
+  if (propertyNode != null) {
+    const { Property } = elements,
+          node = propertyNode, ///
+          string = context.nodeAsString(node),
+          lineIndex = null,
+          name = nameFromPropertyNode(propertyNode, context),
+          type = typeFromPropertyNode(propertyNode, context);
 
-  const property = new Property(context, string, node, lineIndex, name, nominalTypeName);
+    context = null;
+
+    property = new Property(context, string, node, lineIndex, name, type);
+  }
 
   return property;
 }
@@ -253,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;
 
@@ -266,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;
 
@@ -385,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;
 
@@ -431,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, ///
@@ -488,12 +495,11 @@ export function typePrefixFromTypePrefixNode(typePrefixNode, context) {
         node = typePrefixNode, ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        term = termFromTypePrefixNode(typePrefixNode, context),
-        type = typeFromTypePrefixNode(typePrefixNode, context);
+        name = nameFromTypePrefixNode(typePrefixNode, context);
 
   context = null;
 
-  const typePrefix = new TypePrefix(context, string, node, lineIndex, term, type);
+  const typePrefix = new TypePrefix(context, string, node, lineIndex, name);
 
   return typePrefix;
 }
@@ -742,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;
@@ -783,16 +789,29 @@ export function procedureReferenceFromProcedureReferenceNode(procedureReferenceN
   return procedureRefereence;
 }
 
+export function propertyDeclarationFromPropertyDeclarationNode(propertyDeclarationNode, context) {
+  const { PropertyDeclaration } = elements,
+        node = propertyDeclarationNode,  ///
+        string = context.nodeAsString(node),
+        lineIndex = null,
+        type = typeFromPropertyDeclarationNode(propertyDeclarationNode, context),
+        property = propertyFromPropertyDeclarationNode(propertyDeclarationNode, context);
+
+  context = null;
+
+  const propertyDeclaration = new PropertyDeclaration(context, string, node, lineIndex, property, type);
+
+  return propertyDeclaration;
+}
+
 export function variableDeclarationFromVariableDeclarationNode(variableDeclarationNode, context) {
   const { VariableDeclaration } = elements,
         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;
 
@@ -938,15 +957,17 @@ export function constructorDeclarationFromConstructorDeclarationNode(constructor
 export function complexTypeDeclarationFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
   const { ComplexTypeDeclaration } = elements,
         node = complexTypeDeclarationNode,  ///
-        string = context.nodeAsString(node),
         lineIndex = null,
         type = typeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
         superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-        provisional = provisionalFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context);
+        provisional = provisionalFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        propertyDeclarations = propertyDeclarationsFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        complexTypeDeclarationString = complexTypeDeclarationStringFromTypeSuperTypesAndProvisional(type, superTypes, provisional),
+        string = complexTypeDeclarationString;  ///
 
   context = null;
 
-  const complexTypeDeclaration = new ComplexTypeDeclaration(context, string, node, lineIndex, type, superTypes, provisional);
+  const complexTypeDeclaration = new ComplexTypeDeclaration(context, string, node, lineIndex, type, superTypes, provisional, propertyDeclarations);
 
   return complexTypeDeclaration;
 }
@@ -1042,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;
 }
@@ -1306,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;
 
@@ -1630,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;
 
@@ -1649,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;
@@ -1669,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;
 
@@ -1832,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);
@@ -1904,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);
@@ -2090,6 +2176,13 @@ export function replacementStatementFromStatementSubstitutionNode(statementSubst
   return replacementStatement;
 }
 
+export function propertyDeclarationsFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+  const propertyDeclarationnNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(),
+        propertyDeclarations = propertyDeclarationsFromPropertyDeclarationNodes(propertyDeclarationnNodes, context);
+
+  return propertyDeclarations;
+}
+
 export function termsFromTermNodes(termNodes, context) {
   const terms = termNodes.map((termNode) => {
     const term = termFromTermNode(termNode, context);
@@ -2204,3 +2297,13 @@ export function stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context
 
   return stepsOrSubproofs;
 }
+
+export function propertyDeclarationsFromPropertyDeclarationNodes(propertyDeclarationnNodes, context) {
+  const propertyDeclrations = propertyDeclarationnNodes.map((propertyDeclarationNode) => {
+    const propertyDeclcaration = propertyDeclarationFromPropertyDeclarationNode(propertyDeclarationNode, context);
+
+    return propertyDeclcaration;
+  });
+
+  return propertyDeclrations;
+}

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/string.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { baseTypeFromNothing } from "../utilities/type";
+import { EMPTY_STRING, PROVISIONALLY } from "../constants";
 
 export function termsStringFromTerms(terms) {
   const termsString = terms.reduce((termsString, term) => {
@@ -59,18 +60,25 @@ export function hypothesesStringFromHypotheses(hypotheses) {
 }
 
 export function superTypesStringFromSuperTypes(superTypes) {
-  const baseType = baseTypeFromNothing(),
-        superTypesString = superTypes.reduce((superTypesString, superType) => {
-          if (superType !== baseType) {
-            const superTypeString = superType.getString();
+  let superTypesString;
 
-            superTypesString = (superTypesString === null) ?
-                                 `'${superTypeString}'` :
-                                   `${superTypesString}, '${superTypeString}'`;
-          }
+  const baseType = baseTypeFromNothing();
 
-          return superTypesString;
-        }, null);
+  superTypesString = superTypes.reduce((superTypesString, superType) => {
+    if (superType !== baseType) {
+      const superTypeString = superType.getString();
+
+      superTypesString = (superTypesString === null) ?
+                           `'${superTypeString}'` :
+                              `${superTypesString}, '${superTypeString}'`;
+    }
+
+    return superTypesString;
+  }, null);
+
+  superTypesString = (superTypesString !== null) ?
+                       `:${superTypesString}` :
+                          EMPTY_STRING;
 
   return superTypesString;
 }
@@ -89,13 +97,21 @@ export function parametersStringFromParameters(parameters) {
   return parametersString;
 }
 
+export function provisinalStringFromProvisional(provisional) {
+  const provisionString = provisional ?
+                            PROVISIONALLY :
+                              EMPTY_STRING;
+
+  return provisionString;
+}
+
 export function suppositionsStringFromSuppositions(suppositions) {
   const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
     const suppositionString = supposition.getString();
 
     suppositionsString = (suppositionsString === null) ?
-                            suppositionString: ///
-                             `${suppositionsString}, ${suppositionString}`;
+      suppositionString: ///
+      `${suppositionsString}, ${suppositionString}`;
 
     return suppositionsString;
   }, null);
@@ -230,6 +246,15 @@ export function topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels
   return topLevelAssertionString;
 }
 
+export function complexTypeDeclarationStringFromTypeSuperTypesAndProvisional(type, superTypes, provisional) {
+  const typeString = type.getString(),
+        superTypesString = superTypesStringFromSuperTypes(superTypes),
+        provisionalString = provisinalStringFromProvisional(provisional),
+        complexTypeDeclarationString = `${provisionalString}${typeString}${superTypesString}`;
+
+  return complexTypeDeclarationString;
+}
+
 export function topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction) {
   const labelString = label.getString(),
         deductionString = deduction.getString(),

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;
+    }
+  });
+}