@fraczak/k 4.0.4 → 5.0.1

package/BIG_PICTURE.md

@@ -14,19 +14,24 @@ Formally, a _type_ is a (subclass of) finite tree automata. The type defines a s
 which corresponds to the set of trees accepted by the automaton.
 Therefore, every type admits a unique normal form in terms of its minimal deterministic tree automaton.
 
-The set of all types can be seen as the universal deterministic (infinite) tree automaton.
-Every node of that automaton defines a type; only a finite set of nodes are reachable from
-any node.
-
 Types are defined by two constructs:
 
 1. Product
 2. Union (also called tagged or disjoint union)
 
+```bnf
+type ::= name | '{' type_label_list '}' | '<' type_label_list '>'
+type_label_list ::= /* empty */ | ( type label ',' )* type label 
+name ::= IDENTIFIER
+label ::= STRING
+```
+
 Given a finite (possibly empty) set of types `t1, t2, ..., tn` and a set of pairwise different tags (labels) `l1, l2, ..., ln`,
 
-- by `{ t1 l1, t2 l2, ..., tn ln }`, we define a _product type_ with exactly `n` projection functions `.l1`, `.l2`, `...`, `.ln`,
-  mapping a value of type `{t1 l1, t2 l2, ..., tn ln}` into a value of type `t1`, `t2`, `...`, `tn`, respectively.
+- by `{ t1 l1, t2 l2, ..., tn ln }`, we define a _product type_ with exactly `n`
+  _projection_ functions: `.l1`, `.l2`, `...`, `.ln`.
+  Each projection function is mapping a value of type `{t1 l1, t2 l2, ..., tn ln}`
+  into a value of type `t1`, `t2`, `...`, `tn`, respectively.
 - by `< t1 l1, t2 l2, ..., tn ln >`, we define a _union type_ with exactly `n` projection functions `.l1`, `.l2`, `...`, `.ln`,
   mapping a value of type `<t1 l1, t2 l2, ..., tn ln>` into a value of type `t1`, `t2`, `...`, `tn`, respectively.
 
@@ -38,11 +43,37 @@ Some properties of these types:
 
 1. Singleton product and singleton union types, `{ t label }` and `< t label >`, are equivalent as they have
    the same set of values (and the same projection function `.label`). That's why, we not allow singleton product nor
-   singleton union types in the syntax of the language. The other benefit is that we will be able to use the same systax
-   for values of both product and union types, interpretting every singleton product-like value, e.g., `{ a_value label }`,
+   singleton union types in the syntax of the language. The other benefit is that we will be able to use the same syntax
+   for writing out values of both product and union types, interpretting every singleton product-like value, e.g., `{ a_value label }`,
    as a union type value (a variant).  
-2. The empty product type `{}` has a single value, called the _unit_ and also denoted by `{}`, which has no fields.
-3. The empty union type `<>` has no values.
+2. The empty product type, `{}`, has a single value, called the _unit_
+   and also denoted by `{}`, which has no fields.
+3. The empty union type, `<>`, has no values.
+
+### Filters (patterns)
+
+A _filter_ is a way of representing a _type class_, i.e, a set of types sharing some struture.
+For example, if I wanted to refer to all product types that have a field `f` of type `T`,
+I would write a pattern: `?{ T f, ... }`. In general, a filter is defined by:
+
+```bnf
+filter ::= name | '$' type_expr | '{' filter_label_list '}'
+   | '<' filter_label_list '>' | '(' filter_label_list ')'
+   | filter '=' name
+filter_label_list ::= /* empty */ | '...'
+   | ( filter label ',' ) * filter label
+```
+
+Examples:
+
+```k-repl
+  X                 -- any type
+  ( ... )           -- any type
+  { ... }           -- any product type
+  ( X x, X y )      -- any type with two fields of the same type
+  < X x, ... > = X  -- a (recursive) type, 'X', with variant 'x'
+                    -- of the same type 'X' 
+```
 
 ### Partial functions
 
@@ -50,16 +81,19 @@ A _partial function_ is a function that is not defined for every value of its do
 
 There are three ways of combining partial functions:
 
-1. __Composition__: we write a composition of `f` and `g` as `(f  g)`, meaning that if `f` is defined on valye `x` producing `y`,
+1. __Composition__: we write a composition of `f` and `g` as `(f  g)`,
+   meaning that if `f` is defined on value `x` producing `y`,
    and `g` is defined on value `y` producing `z`, then `(f g)` is defined on value `x` producing `z`.
 2. __Union__: we write `< f1, f2 >` for a union of two functions `f1` and `f2`, meaning that
    if `f1` is defined on value `x` producing `y`, then `< f1, f2 >`
    is defined on value `x` producing `y`. Otherwise, i.e., when `f1` is not defined for `x`, `< f1 f2 >` acts as `f2`.
-3. __Product__: we write `{f1 lab1, f2 lab2 }` for a product of two functions `f1` and `f2`, meaning that if `f1` and `f2`
-   are both defined on value `x` producing `y1` and `y2`, respectively, then `{f1 lab1, f2 lab2 }`
-   is defined on value `x` producing `{y1 lab1, y2 lab2}`. Otherwise, `{f1 lab1, f2 lab2 }` is not defined for `x`.
+3. __Product__: we write `{f1 lab1, f2 lab2 }` for a product of two functions `f1` and `f2`,
+   meaning that if `f1` and `f2` are both defined on value `x` producing `y1` and `y2`,
+   respectively, then `{f1 lab1, f2 lab2 }` is defined on value `x` producing
+   `{y1 lab1, y2 lab2}`. 
+   Otherwise, `{f1 lab1, f2 lab2 }` is not defined for `x`.
 
-Actually, all of the above operations take any number of arguments, not only two. For example,
+Actually, composition, union, and product combine any number of partial functions, not only two. For example,
 empty composition, `()`, defines the identity function.
 
 ### Program
@@ -70,68 +104,66 @@ which is the partial function the program defines.
 The language syntax is defined by:
 
 ```bnf
-program ::= (type_definition | function_definition) * expression
-
+program ::= (type_definition | function_definition)* expression
 type_definition ::= '$' type_name '=' type ';'
-type ::= '{' type_label_list '}' | '<' type_label_list '>'
-type_label_list ::= /* empty */ | ( type_expression label_name ',' ) + type_expression label_name
-type_expression ::= type_name | type
-
-function_definition ::= function_name '=' expression ';'
-expression ::= projection | typing | composition | union | product | function_name
-projection ::= '.' label_name
-typing ::= '$' tape_expression 
+function_definition ::= name '=' expression ';'
+expression ::= name | '$' type | '?' filter 
+   | projection | composition | union | product 
+projection ::= '.' label
 composition ::= '(' expression * ')'  
 union ::= '<' (expression ',') + expression '>' 
-product ::= '{' expression_label_list '}'
-expression_label_list ::= /* empty */ | ( expression label_name ',' ) * expression label
+product ::= '{' expr_label_list '}'
+expr_label_list ::= /* empty */ 
+   | (expression label_name ',')* expression label
 ```
 
-We assume that the `type_name`, `function_name`, and `label_name` are identifiers (strings) such that:
+We assume that in a `kernel-core` program the names (for types, functions, and labels) are identifiers (strings) such that:
 
 1. All defined type names are distinct.
 2. All defined function names are distinct.
 3. All label names within a type definition or a `product` expression are locally distinct.
 
-The `typing` expression acts as a type annotation and can be seen as a 'filter', i.e., an identity
-function defined only for the values of the corresponding type.
+`Filter` or `type` expressions act as a type annotation, i.e., an identity
+function defined only for the values of the corresponding types.
 
 That's it.
+
 No `builtin` types, no `if` statement, no `loop`, no `throw`, no _closure_, no _annotations_, and no macros.
-Just types and partial functions.
+Just _types_, _filters_, and _functions_.
 
 ### Normalization
 
 All type names are replaced by the hash of their canonical representation.
 
-We will also replace the function name by the hash of the normalized unfolded definition of the function.
-Obviously, two different definitions of the same function may have different hashes.
+We replace the function name by the hash of the normalized definition of the function as provided by the program defining the function.
+Obviously, a function may have many different definitions so the hash-based names are not canonical. By using hash-based function names we avoid the problem of name clashes when bringing together many `kernel-core` programs.
 
-This approach solves the problem of modules and imports and opens the door to a universal
+This approach solves the problem of modules, imports, etc., and opens the door to a universal
 registry of types (schemas) and functions.
 
 ## Typing and Polymorphism (codes and filters/patterns)
 
-Abstract Syntax Tree of a program after parsing consists of a dictionary of _type definitions_,
+Abstract Syntax Tree of a program consists of a dictionary of _type definitions_,
 a dictionary  of _function definitions_, and the final _main expression_.
 
 In principle, the initial form of the Abstract Syntax Tree, _raw_ AST, is enough to evaluate
 the program on an input.
 
-Our objective however is to compute canonicals representations for types and normalized
-representations for functions, so they could be effectively reused.
+Our objective however is to compute canonical representations for types and normalized
+representations for functions, so they could be reused.
 
 The normalization steps are:
 
 1. Build the _type graph_ from all types used by the program, i.e., used in _type definitions_ 
    as well as type expressions used in _function definitions_ and the _main expression_.
-2. Annotate the expressions with types or type patterns; every node of the AST is annotated with a pair of type patterns.
-3. Turn the _singleton_ type patterns into types and add them to the _type graph_. Go to (2) unless no change.
-4. Normalize the function definitions by rewriting them as the fix-point of a single equation.
+2. Annotate the expressions with filters; every node of the AST is annotated with a pair of filters.
+3. Turn the _singleton_ filters into types and add them to the _type graph_. Go to (2) unless no change.
 
-### Example
+### Examples
 
-```k
+#### Example 1
+
+```k-repl
 $ bit = < {} o, {} i >;
 bit0 = {{} o} $bit;
 bit1 = {{} i} $bit;
@@ -169,7 +201,7 @@ and a type `byte` as a product, for simplicity, of four `bit`s.
 Functions `bit0`, `bit1`, and `zero` are "constant polymorphic functions", meaning:
 
 - constant: if defined, they always return exactly the same value;
-- polymorphic: they are defined for more than one pair of input and output type: functions
+- polymorphic: they are defined for more than one pair of input and output types: functions
   `bit0` and `bit1` are of type `?X -> $bit`, and `zero` is of type `?X -> $byte`, where `?X`
   denotes an unconstrained type pattern, also denoted as `?(...)`.
 
@@ -186,15 +218,42 @@ with following constraints:
    > `?( V i, ...)`;
 - `V` is unconstrained, denoted by `(...)`;
 
-We could write it as: `?($byte byte, ((...) i, ...) overflown, ...)`.
+We can write it as: `?($byte byte, ((...) i, ...) overflown, ...)`.
 
 The target type `${ byte byte, bit overflown }` was derived from pattern `?{ $byte byte, $bit overflown }`.
-Such a pettern is called _singleton pattern_ as only one type fits the pattern.
+Such a pattern is called _singleton pattern_, as only one type fits the pattern.
+
+#### Example 2
+
+Polymorphic list functions:
+
+```k-repl
+list? = ?< {} nil, {X car, Y cdr} cons > = Y;
+nil = {{} nil} list?;
+singleton = {{() car, nil cdr} cons} list?;
+cons = {{.car car, .cdr cdr} cons} list?;
+nil? = list? .nil nil;
+car = list? .cons .car;
+cdr = list? .cons .cdr;
+```
+
+For example, the filter annotation for `car` is:
+
+```k-repl
+--R car
+{
+  name: 'yRXGSJrIWCuKV',
+  type: '?<{X1 car, X0 cdr} cons, $KL nil>=X0  -->  ?X1',
+  def: '?<{X1 car, X0 cdr} cons, $KL nil>=X0 .cons .car ?X1'
+}
+--C KL
+$ KL = {}; -- $C0={};
+```
 
 ## Universal Schema Registry
 
 Since the normalization process for types is fast and deterministic, we can build a universal
-schema registry that will store all invented types. 
+schema registry that will store all invented types.
 The registry will be a key-value store, where the key is the hash of the normalized type,
 and the value is the normalized type itself.
 
@@ -203,8 +262,7 @@ definition and stored in the similar key-value store.
 
 Non-polymorphic functions can be easily indexed by the hashes of their input and output types
 so that we can quickly find the function we need.
-Searching for polymorphic functions is more complicated, as we need to find the function
-whose input and output type patterns fit given types.
+Indexing polymorphic functions seems complicated (TODO).
 
 ## Serialization and Compilation
 

package/Code-derivation-tests/bnat.mjs

@@ -5,7 +5,7 @@ import assert from 'assert';
 t(fs.readFileSync("./Examples/bnat-patterns.k").toString("utf8"), (annotated) => {
     // console.log(JSON.stringify(annotated,null,2));
     const {input,output} = in_out(annotated);
-    // console.log(output);
+    console.log(output);
     assert.equal(output.type, annotated.representatives["bnat"]);
     assert.equal(input.type, annotated.representatives["pair"]);
     console.log("OK");

package/TODO.md

@@ -0,0 +1,18 @@
+# To do list for canonical names
+
+- [ ] Write a script to search for conflicting names
+- [ ] Export a relation. i.e., rewrite it as a list of all
+      dependency definitions using canonical names
+- [ ] Find a way of adding 'comments' or some way of 'tagging' the definitions
+- [X] The definitions should be simplied by removing useless filters
+- [X] Definitions, which are just aliases to non built-in rels should not introduce a new canonical name
+- [ ] Can we inline some references w/o changing the canonical name?
+
+## Simplification rules
+
+It seems to me that after calculating input and output patterns, all
+filters and code expressions could be replaced by just input and output
+filters corresponding to the patterns. [DONE]
+
+The filer variables have to be renamed for normalization if they take part of 
+the canonical name calculation. [DONE]

package/TYPING.md

@@ -360,6 +360,6 @@ Repeat the procedure until the type pattern graph is not changing anymore.
 - [X] Redefine built-in CONS and SNOC to allign with no support for non-homogeneous lists
 - [X] Integrate filters into typePatters (execution is not affected)
 - [/] better type error repporting - the info exists in the pattern parent tree ... in progress
-- [ ] Introduce a space/time bounds for type derivation
+- [X] Introduce a space/time bounds for type derivation
 - [ ] Check for loops, e.g., `$x = < x f, ...>`, `$x = [x]`, `$x = {x f, ...}` -- this
-      looks a little arbitrary, but maybe this is actually an important part
+      looks a little arbitrary, but maybe this is actually an important part

package/export.mjs

@@ -0,0 +1,185 @@
+
+import { prettyRel, patterns2filters } from "./pretty.mjs";
+import { hash } from "./hash.mjs";
+
+function simplifyRel(relDef,rels) {
+  // remove filters and codes
+  const prune = (rel) => {
+    const newRel = {...rel};
+    switch (rel.op) {
+      case "product":
+        newRel.product = rel.product.map(({label, exp}) => ({label, exp: prune(exp)}));
+        break;
+      case "union":
+        newRel.union = rel.union.map(exp => prune(exp));
+        break;
+      case "comp":
+        newRel.comp = rel.comp.reduce((list, exp) => {
+          const newExp = prune(exp);
+          if (newExp.op != "identity") 
+            list.push(newExp);
+          return list;
+        },[]);
+        if (newRel.comp.length == 0) 
+          newRel.op = "identity";
+        break;
+      case "vector":
+        newRel.vector = rel.vector.map(exp => prune(exp));
+        break;
+      case "caret":
+        newRel.caret = prune(rel.caret);
+        break;
+      case 'code':
+      case 'filter':
+        newRel.op = "identity";
+        break;
+      case 'ref':
+        // console.log("ref", rel.ref, rels[rel.ref]);
+        if (["filter","code","identity"].includes(rels[rel.ref]?.def.op)){
+          newRel.op = "identity";
+        };
+        break;
+      default:
+        break;
+    };
+    return newRel;
+  };
+
+  const rel = relDef.def;
+  const filters = patterns2filters(relDef.typePatternGraph, ...rel.patterns).map( filter =>
+    ({op: "filter", filter: filter}));
+  const newRel = prune(rel);
+  let resultRel = {...newRel};
+  if (newRel.op == "identity")
+    return {...resultRel, ...filters[0]}; 
+
+  if (newRel.op == "comp") { 
+    resultRel.comp = [ filters[0], ...newRel.comp, filters[1] ];
+    return resultRel;
+  }
+  return {...resultRel,
+    op: "comp",
+    comp: [filters[0], newRel, filters[1] ]
+  };
+};
+
+
+function theID(alias, rel, scc, name) {
+  const sccNames = new Set(scc);
+  const auxNames = {[name]: "X0"};
+  // rename and remove filters and codes
+  const reNameX = (rel) => {
+    const newRel = {...rel};
+    switch (rel.op) {
+      case "product":
+        newRel.product = rel.product.map(({label, exp}) => ({label, exp: reNameX(exp)}));
+        break;
+      case "union":
+        newRel.union = rel.union.map(exp => reNameX(exp));
+        break;
+      case "comp":
+        newRel.comp = rel.comp.map(exp => reNameX(exp));
+        break;
+      case "vector":
+        newRel.vector = rel.vector.map(exp => reNameX(exp));
+        break;
+      case "caret":
+        newRel.caret = reNameX(rel.caret);
+        break;
+      case "ref": {
+        const n = rel.ref;
+        if (alias[n] != undefined) {
+          newRel.ref = alias[n];
+        } else if (auxNames[n] != undefined) {
+          newRel.ref = auxNames[n];
+        } else if (sccNames.has(n)) {
+          auxNames[n] = `X${Object.keys(auxNames).length}`;
+          newRel.ref = auxNames[n];
+        };
+      }; break;
+      default:
+        break;
+    };
+    return newRel;
+  };
+
+  const newRel = reNameX(rel);
+  const resultRelStr = prettyRel(newRel);
+  // console.log(` ${name} = ${resultRelStr}`);
+  const newName = hash(resultRelStr);
+  return newName;
+};
+
+function assignCanonicalNames(scc, rels, relAlias) {
+  const newAlias = scc.reduce( (newAlias,relName) => {
+    const relDef = rels[relName];
+    if (relDef.def.op == "ref" && rels[relDef.def.ref] != undefined) {
+      // inlining if direct alias to a non built-in relation
+      // relDef.def = rels[relDef.def.ref]; // simplifyRel(rels[relDef.def.ref],rels);
+      rels[relName] = rels[relDef.def.ref];
+    } else {
+      relDef.def = simplifyRel(relDef,rels);
+    }
+    newAlias[relName] = theID(relAlias, rels[relName].def, scc, relName);
+    return newAlias;
+  }, {});
+  const newNames = [...new Set(Object.values(newAlias))];
+  // console.log(` --- SCC: {${scc.join(",")}} ---`);
+
+  const sccCanonicalName = newNames.sort().join(":");
+  for (let relName in newAlias) {
+    if (newNames.length > 1)
+      relAlias[relName] = hash(newAlias[relName]+":"+sccCanonicalName);
+    else
+      relAlias[relName] = newAlias[relName];
+    // console.log(`  ${relName} -> ${relAlias[relName]}`);
+  };  
+}
+
+function exportRelation(rels, alias, name) {
+  const queue = [name];
+  const inQueue = { [name]: true };
+  const result = {};
+  const reName = (rel) => {
+    const newRel = {...rel};
+    switch (rel.op) {
+      case "product":
+        newRel.product = rel.product.map(({label, exp}) => ({label, exp: reName(exp)}));
+        break;
+      case "union":
+        newRel.union = rel.union.map(exp => reName(exp));
+        break;
+      case "comp":
+        newRel.comp = rel.comp.map(exp => reName(exp));
+        break;
+      case "vector":
+        newRel.vector = rel.vector.map(exp => reName(exp));
+        break;
+      case "caret":
+        newRel.caret = reName(rel.caret);
+        break;
+      case "ref": {
+        const n = rel.ref;
+        if (alias[n] == undefined) // built-in
+          return newRel; 
+        newRel.ref = alias[n];
+        if (! inQueue[n]) {
+          inQueue[n] = true;
+          queue.push(n);
+        }
+      }; break;
+      default:
+        break;
+    };
+    return newRel;
+  };
+  while (queue.length > 0 ) {
+    const name = queue.shift();
+    const canonicalName = alias[name];
+    result[canonicalName] = {...rels[name], def: reName(rels[name].def), name: name};
+  }
+  return result;
+}
+
+export default { assignCanonicalNames, exportRelation };
+export { assignCanonicalNames, exportRelation };

package/index.mjs

@@ -4,19 +4,7 @@ import run from "./run.mjs";
 import t from "./codes.mjs";
 
 function compile(script) {
-  try {
-    run.defs = annotate(script);
-  } catch (e) {
-    console.error(e.message);
-    console.error("WARN: Recompiling without type reconciliation due to the type error above.");
-    const { defs, exp } = parse(script);
-    const { codes, representatives } = t.finalize(defs.codes);
-    run.defs = {
-      rels: {...defs.rels, "__main__": {def: exp}}, 
-      codes, representatives
-    };
-    
-  }
+  run.defs = annotate(script);
   return run.bind(null, run.defs.rels.__main__.def);
 }
 
@@ -35,9 +23,9 @@ function annotate(script) {
   const representatives = t.register(defs.codes);
   const rels = {...defs.rels, "__main__": {def: exp}};
 
-  patterns(representatives, rels);
+  const relAlias = patterns(representatives, rels);
  
-  return {rels, representatives}
+  return {rels, representatives, relAlias};
 }
 annotate.doc = "Annotate all the script expressions with patterns";
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "4.0.4",
+    "version": "5.0.1",
     "description": "k-language for JSON-like data transformation",
     "main": "index.mjs",
     "scripts": {

package/parser.jison

@@ -43,7 +43,7 @@ function fromEscString(escString) {
 
 %%
 [/][*]([^*]*[*]+[^*/])*[^*]*[*]+[/]             /* c-comment */
-("//"|"#"|"%"|"--")[^\n]*                       /* one line comment */
+("//"|"#"|"%"|"--"|"\\")[^\n]*                  /* one line comment */
 \s+                                             /* blanks */
 "<"                                            return 'LA';
 "{"                                            return 'LC';

package/parser.mjs

@@ -846,7 +846,7 @@ case 25:return 47;
 break;
 }
 },
-rules: [/^(?:[/][*]([^*]*[*]+[^*/])*[^*]*[*]+[/])/,/^(?:(\/\/|#|%|--)[^\n]*)/,/^(?:\s+)/,/^(?:<)/,/^(?:\{)/,/^(?:\[)/,/^(?:\()/,/^(?:>)/,/^(?:\})/,/^(?:\])/,/^(?:\))/,/^(?:=)/,/^(?:\.\.\.)/,/^(?:\.)/,/^(?:,)/,/^(?:;)/,/^(?::)/,/^(?:\$)/,/^(?:\?)/,/^(?:\|)/,/^(?:\^)/,/^(?:"([^"\\]|\\(.|\n))*"|'([^'\\]|\\(.|\n))*')/,/^(?:[a-zA-Z_][a-zA-Z0-9_?!]*)/,/^(?:0|[-]?[1-9][0-9]*)/,/^(?:\+\+\+)/,/^(?:$)/],
+rules: [/^(?:[/][*]([^*]*[*]+[^*/])*[^*]*[*]+[/])/,/^(?:(\/\/|#|%|--|\\)[^\n]*)/,/^(?:\s+)/,/^(?:<)/,/^(?:\{)/,/^(?:\[)/,/^(?:\()/,/^(?:>)/,/^(?:\})/,/^(?:\])/,/^(?:\))/,/^(?:=)/,/^(?:\.\.\.)/,/^(?:\.)/,/^(?:,)/,/^(?:;)/,/^(?::)/,/^(?:\$)/,/^(?:\?)/,/^(?:\|)/,/^(?:\^)/,/^(?:"([^"\\]|\\(.|\n))*"|'([^'\\]|\\(.|\n))*')/,/^(?:[a-zA-Z_][a-zA-Z0-9_?!]*)/,/^(?:0|[-]?[1-9][0-9]*)/,/^(?:\+\+\+)/,/^(?:$)/],
 conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25],"inclusive":true}}
 });
 return lexer;

package/patterns.mjs

@@ -3,6 +3,7 @@ import hash from "./hash.mjs";
 import { TypePatternGraph } from "./typing.mjs";
 import { Graph, sccs, topoOrder } from "./Graph.mjs";
 import codes from "./codes.mjs";
+import { assignCanonicalNames } from "./export.mjs";
 
 const unitCode = codes.unitCode;
 
@@ -97,10 +98,11 @@ function compactRel(relDef, name = "") {
 
 function patterns(representatives, rels) {
   // INPUT: 
-  //   codes: {"BG": {"code": "product", "product": {}}, ...}
-  //   representatives:{"{}": "BG", ...}
+  //   codes: {"KL": {"code": "product", "product": {}}, ...}
+  //   representatives:{"{}": "KL", ...}
   //   rels: {"rlz": [{op: comp,...}, ...], ...}
  
+  const relAlias = {};
 
   // 1 INITIALIZATION
   // 1.1 initialize patternNodes and rels
@@ -405,7 +407,7 @@ function patterns(representatives, rels) {
         rel.patterns = [rootDef.typePatternGraph.addNewNode(), rootDef.typePatternGraph.addNewNode()];
         break;
       default:
-        throw new Error(`No definition found for ${rel.ref}`);  
+        throw new Error(`No definition found for '${rel.ref}'`);  
     }
   }  
 
@@ -416,7 +418,7 @@ function patterns(representatives, rels) {
   for (const relName in rels) {
     const rootDef = rels[relName];
     rootDef.typePatternGraph = new TypePatternGraph();
-    rootDef.varRefs = []; // the list of non-built references as pointers to AST nodes
+    rootDef.varRefs = []; // the list of references to non-builtin rels as pointers to AST nodes
     rootDef.patternVars = {}; 
     augment(rootDef.def, rootDef);
     delete rootDef.patternVars;
@@ -453,12 +455,16 @@ function patterns(representatives, rels) {
 
   // 3. Topological sort of the DAG
 
-  const sccInOrder = topoOrder(DAG);
+  const sccInOrder = topoOrder(DAG).reverse();
 
   // 4. For each strongly connected component C in a bottom-up order
+  
+  //    we will also generate the canonical representation of the relations in C and replace 
+  //    the name to the relation by the hash of the canonical representation    
+
+  // console.log("----- SCC in order", sccInOrder);
 
-  for (const scc of sccInOrder.reverse()) {
-    // console.log(`SCC: { ${DAGnodes[scc].scc} }`);
+  for (const scc of sccInOrder) {
 
     const maxNumberOfIterations = 10;
     
@@ -497,9 +503,7 @@ function patterns(representatives, rels) {
             throw e;
           }
         }
-
         rels[relName] = compactRel(relDef,relName);
-        
         return relDefToString(rels[relName]); 
       }));
 
@@ -507,9 +511,19 @@ function patterns(representatives, rels) {
         // console.log("SUCCESS!");
         break;
       }
-    } // while
-      
+    } // end of iteration loop
+
+    DAGnodes[scc].scc.forEach( relName => {
+      const relDef = rels[relName];
+      const canonical = relDefToString(relDef);
+      const h = hash(canonical);
+      relAlias[relName] = h;
+    });
+
+    assignCanonicalNames(DAGnodes[scc].scc, rels, relAlias);
+
   }
+  return relAlias;
 }
 
 export default { patterns };