Simulate multiplexers in 'hybrid'

Author: codedot

README.md

@@ -36,15 +36,15 @@ The following is output of the `test.sh` script provided in the package:
 
 ```
 SAMPLE            CLOSED        OPTIMAL       ABSTRACT         HYBRID
-counter             58/6          143/4            N/A            N/A
-w2eta             137/16          205/7           37/7            N/A
+counter             58/6          143/4            N/A           58/4
+w2eta             137/16          205/7           37/7          130/7
 22210ii         1740/182        7886/70         731/70            N/A
 3222ii          5896/545      164197/43        1182/43            N/A
 1022ii        23026/2085     2489461/59        4298/59            N/A
 4222ii    1442259/131124            N/A      262401/64            N/A
 222210ii  6685119/655415            N/A    2359812/201            N/A
-cfact4         15506/887      56890/691       3711/691            N/A
-yfact4        24150/1741     526971/760       4168/760            N/A
+cfact4         15506/887      56890/691       3711/691      77944/691
+yfact4        24150/1741     526971/760       4168/760     349585/760
 cfact5      799868/16170  3074471/13462    69147/13462            N/A
 yfact5      857864/22267            N/A    69780/13550            N/A
 ```

encoding/hybrid/index.js

@@ -7,23 +7,24 @@ const template = fs.readFileSync(path.join(__dirname, "template.txt"), "utf8");
 
 let mkwire, bv;
 
-function rho(id, list)
+function rho(id, list, lvl)
 {
 	bv[id].forEach(entry => {
 		const wire = entry.wire;
-		const lvl = entry.index;
+		const delta = entry.lvl - lvl - 1;
 		const next = mkwire();
-		const agent = `\\fan_{${lvl}}(${next}, ${wire})`;
+		const agent = `\\fan_{[${lvl}, ${delta}]}`;
+		const tree = `${agent}(${next}, ${wire})`;
 
-		list.push(`${id} = ${agent}`);
+		list.push(`${id} = ${tree}`);
 
 		id = next;
 	});
 
 	list.push(`${id} = \\nil`);
 }
 
-function gamma(obj, root, list)
+function gamma(obj, root, list, lvl)
 {
 	const node = obj.node;
 
@@ -38,40 +39,42 @@ function gamma(obj, root, list)
 			const id = obj.name;
 
 			bv[id].push({
-				index: obj.index,
+				lvl: lvl,
 				wire: root
 			});
 		}
 	} else if ("abst" == node) {
 		const id = obj.var;
 		const body = obj.body;
 		const wire = mkwire();
-		let tree = "\\lam(%s, %s)";
+		let tree = "\\lam_{%s}(%s, %s)";
 
+		tree = tree.replace("%s", lvl);
 		tree = tree.replace("%s", id);
 		tree = tree.replace("%s", wire);
 
 		list.push(root + " = " + tree);
 
 		bv[id] = [];
 
-		gamma(body, wire, list);
+		gamma(body, wire, list, lvl);
 
-		rho(id, list);
+		rho(id, list, lvl);
 	} else if ("appl" == node) {
 		const wleft = mkwire();
 		const wright = mkwire();
 		const left = obj.left;
 		const right = obj.right;
-		let agent = "\\app(%s, %s)";
+		let agent = "\\app_{%s}(%s, %s)";
 
+		agent = agent.replace("%s", lvl);
 		agent = agent.replace("%s", wright);
 		agent = agent.replace("%s", root);
 
 		list.push(wleft + " = " + agent);
 
-		gamma(left, wleft, list);
-		gamma(right, wright, list);
+		gamma(left, wleft, list, lvl);
+		gamma(right, wright, list, lvl + 1);
 	}
 }
 
@@ -84,7 +87,7 @@ function encode(generic, term)
 	mkwire = generic.mkwire;
 
 	bv = {};
-	gamma(term, "root", inconfig);
+	gamma(term, "root", inconfig, 0);
 
 	inconfig.inet = template;
 	return inconfig;

encoding/hybrid/template.txt

@@ -1,34 +1,42 @@
-\app[\fan_{i}(a, b), \fan_{i}(c, d)] {
+\app_{i}[\fan_{j}(a, b), \fan_{j}(c, d)] {
 	/* Duplicate application. */
-	++this.total;
-} \fan_{i}[\app(a, c), \app(b, d)];
+	if (j[0] < i)
+		++this.total;
+	else
+		return false;
+} \fan_{j}[\app_{i}(a, c), \app_{i + j[1]}(b, d)];
 
-\fan_{i}[\lam(a, b), \lam(c, d)] {
+\fan_{i}[\lam_{j}(a, b), \lam_{j + i[1]}(c, d)] {
 	/* Duplicate abstraction. */
-	++this.total;
-} \lam[\fan_{i}(a, c), \fan_{i}(b, d)];
+	if (i[0] < j)
+		++this.total;
+	else
+		return false;
+} \lam_{j}[\fan_{i}(a, c), \fan_{i}(b, d)];
 
 \fan_{i}[a, b] {
 	/* Annihilate matching fans. */
-	if (i == j)
+	if (i[0] == j[0])
 		++this.total;
 	else
 		return false;
 } \fan_{j}[a, b];
 
-\fan_{i}[\fan_{j}(a, b), \fan_{j}(c, d)] {
+\fan_{i}[\fan_{j}(a, b), \fan_{[j[0] + i[1], j[1]]}(c, d)] {
 	/* Duplicate different fans. */
-	if (i != j)
+	if (i[0] < j[0])
 		++this.total;
 	else
 		return false;
 } \fan_{j}[\fan_{i}(a, c), \fan_{i}(b, d)];
 
-\app[a, b] {
+\app_{i}[a, b] {
 	/* Apply beta reduction. */
-	++this.beta;
-	++this.total;
-} \lam[a, b];
+	if (i == j)
+		++this.beta, ++this.total;
+	else
+		return false;
+} \lam_{j}[a, b];
 
 \fan_{i}[\atom_{M}, \atom_{M}] {
 	/* Duplicate an atom. */
@@ -49,9 +57,9 @@
 \read_{C}[a] {
 	/* Read back abstraction. */
 	++this.total;
-} \lam[\atom_{this.mkid()}, \read_{this.abst(C)}(a)];
+} \lam_{i}[\atom_{this.mkid()}, \read_{this.abst(C)}(a)];
 
-\app[\read_{this.appl(M)}(a), a] {
+\app_{i}[\read_{this.appl(M)}(a), a] {
 	/* Read back application. */
 	++this.total;
 } \atom_{M};

test.sh

@@ -34,10 +34,10 @@ printf "$TERMF$CELLF$CELLF$CELLF$CELLF\n" SAMPLE \
 	CLOSED OPTIMAL ABSTRACT HYBRID
 
 compare counter "v1: v1 (v2: v2 v2) (v3: v3 v3)" \
-	closed optimal abstract HYBRID
+	closed optimal abstract hybrid
 
 compare w2eta "v1, v2: v1 (v1 (v1 (v1 v2)))" \
-	closed optimal abstract HYBRID
+	closed optimal abstract hybrid
 
 compare 22210ii "v1: v1" \
 	closed optimal abstract HYBRID
@@ -55,10 +55,10 @@ compare 222210ii "v1: v1" \
 	closed OPTIMAL abstract HYBRID
 
 compare cfact4 "v1, v2: v1 (v1 (v1 v2))" \
-	closed optimal abstract HYBRID
+	closed optimal abstract hybrid
 
 compare yfact4 "v1, v2: v1 (v1 (v1 v2))" \
-	closed optimal abstract HYBRID
+	closed optimal abstract hybrid
 
 compare cfact5 "v1, v2: v1 (v1 (v1 (v1 (v1 v2))))" \
 	closed optimal abstract HYBRID