diff --git a/AlgebraicDataflowArchitectureModel/models/Algolike.model b/AlgebraicDataflowArchitectureModel/models/Algolike.model
index 97aef04..8ea8dc2 100644
--- a/AlgebraicDataflowArchitectureModel/models/Algolike.model
+++ b/AlgebraicDataflowArchitectureModel/models/Algolike.model
@@ -6,25 +6,25 @@
 	guessB := 0
 }
 channel targetAInput{
-	out targetA(t:Int, setTargetA(a:Int)) == a
+	out targetA(t:Int, setTargetA(a:Int)) = a
 }
 channel targetBInput{
-	out targetB(t:Int, setTargetB(b:Int)) == b
+	out targetB(t:Int, setTargetB(b:Int)) = b
 }
 channel attackerAInput{
-	out attackerA(t:Int, setAttackerA(a:Int)) == a
+	out attackerA(t:Int, setAttackerA(a:Int)) = a
 }
 channel attackerBInput{
-	out attackerB(t:Int, setAttackerB(b:Int)) == b
+	out attackerB(t:Int, setAttackerB(b:Int)) = b
 }
 channel guessAInput{
-	out guessA(t:Int, setGuessA(a:Int)) == a
+	out guessA(t:Int, setGuessA(a:Int)) = a
 }
 channel guessBInput{
-	out guessB(t:Int, setGuessB(b:Int)) == b
+	out guessB(t:Int, setGuessB(b:Int)) = b
 }
 channel addDeck{
-	out deck(d:List, addCard(num:Integer)) == cons(tuple(num, false), d)
+	out deck(d:List, addCard(num:Integer)) = cons(tuple(num, false), d)
 }
 
 channel drawAInput{
@@ -32,21 +32,21 @@
 	ref targetA(t:Int, drawAndAttackA(t, g, b))
 	ref guessA(g:Int, drawAndAttackA(t, g, b))
 	ref	handsB(b:List, drawAndAttackA(t, g, b))
-	out	resultByDrawingA(sda:Tuple, drawAndAttackA(t, g, b)) == tuple(eq(fst(get(b, t)), g), t)
+	out	resultByDrawingA(sda:Tuple, drawAndAttackA(t, g, b)) = tuple(fst(get(b, t)) == g, t)
 }
 	
 channel inputDrawArgsA{
-	in	resultByDrawingA(sda:Tuple, drawA(sucTrg, d)) == sucTrg
+	in	resultByDrawingA(sda:Tuple, drawA(sucTrg, d)) = sucTrg
 	ref deck(d:List, drawA(sucTrg, d))
 	
-	out handsA(outA:List, drawA(sucTrg, d)) == if(fst(sucTrg),
-										sortByKey(cons(tuple(fst(head(d)),false), outA)), 
+	out handsA(outA:List, drawA(sucTrg, d)) = if(fst(sucTrg),
+										sortByKey(cons(tuple(fst(head(d)), false), outA)), 
 										sortByKey(cons(tuple(fst(head(d)), true), outA)))
 										
-	out handsB(outB:List, drawA(sucTrg, d)) == if(fst(sucTrg),
+	out handsB(outB:List, drawA(sucTrg, d)) = if(fst(sucTrg),
 										set(outB, snd(sucTrg), tuple(fst(get(outB, snd(sucTrg))), true)), 
 										outB)
-	out deck(t:List, drawA(sucTrg, d)) == tail(t)
+	out deck(t:List, drawA(sucTrg, d)) = tail(t)
 }
 
 channel selectAInput{
@@ -54,14 +54,14 @@
 	ref targetA(t:Int, selectAndAttackA(a, t, g, b))
 	ref guessA(g:Int, selectAndAttackA(a, t, g, b))
 	ref	handsB(b:List, selectAndAttackA(a, t, g, b))
-	out	resultBySelectingA(ssa:Tuple, selectAndAttackA(a, t, g, b)) == tuple(eq(fst(get(b, t)), g), t, a)
+	out	resultBySelectingA(ssa:Tuple, selectAndAttackA(a, t, g, b)) = tuple(fst(get(b, t)) == g, t, a)
 }		
 channel inputSelectArgA{
-	in resultBySelectingA(ssa, selectA(sucTrgAtk)) == sucTrgAtk
-	out handsA(outA, selectA(sucTrgAtk)) == if(fst(sucTrgAtk),
+	in resultBySelectingA(ssa, selectA(sucTrgAtk)) = sucTrgAtk
+	out handsA(outA, selectA(sucTrgAtk)) = if(fst(sucTrgAtk),
 										outA,
 										set(outA, snd(snd(sucTrgAtk)), tuple(fst(get(outA, snd(snd(sucTrgAtk)))), true)))
-	out handsB(outB, selectA(sucTrgAtk)) == if(fst(sucTrgAtk), 
+	out handsB(outB, selectA(sucTrgAtk)) = if(fst(sucTrgAtk), 
 										set(outB, fst(snd(sucTrgAtk)), tuple(fst(get(outB, fst(snd(sucTrgAtk)))), true)), 
 										outB)
 }
@@ -69,21 +69,21 @@
 	ref targetB(t:Int, drawAndAttackB(t, g, a))
 	ref guessB(g:Int, drawAndAttackB(t, g, a))
 	ref	handsA(a:List, drawAndAttackB(t, g, a))
-	out	resultByDrawingB(sdb:Tuple, drawAndAttackB(t, g, a)) == tuple(eq(fst(get(a, t)), g), t)
+	out	resultByDrawingB(sdb:Tuple, drawAndAttackB(t, g, a)) = tuple(fst(get(a, t)) == g, t)
 }
 	
 channel inputDrawArgsB{
-	in	resultByDrawingB(sdb:Tuple, drawB(sucTrg, d)) == sucTrg
+	in	resultByDrawingB(sdb:Tuple, drawB(sucTrg, d)) = sucTrg
 	ref deck(d:List, drawB(sucTrg, d))
 	
-	out handsB(outB:List, drawB(sucTrg, d)) == if(fst(sucTrg),
+	out handsB(outB:List, drawB(sucTrg, d)) = if(fst(sucTrg),
 										sortByKey(cons(tuple(fst(head(d)),false), outB)), 
 										sortByKey(cons(tuple(fst(head(d)), true), outB)))
 										
-	out handsA(outA:List, drawB(sucTrg, d)) == if(fst(sucTrg),
+	out handsA(outA:List, drawB(sucTrg, d)) = if(fst(sucTrg),
 										set(outA, snd(sucTrg), tuple(fst(get(outA, snd(sucTrg))), true)), 
 										outA)
-	out deck(t:List, drawB(sucTrg, d)) == tail(t)
+	out deck(t:List, drawB(sucTrg, d)) = tail(t)
 }
 
 channel selectBInput{
@@ -91,23 +91,23 @@
 	ref targetB(t:Int, selectAndAttackB(atk, t, g, a))
 	ref guessB(g:Int, selectAndAttackB(atk, t, g, a))
 	ref	handsA(a:List, selectAndAttackB(atk, t, g, a))
-	out	resultBySelectingB(ssb:Tuple, selectAndAttackB(atk, t, g, a)) == tuple(eq(fst(get(a, t)), g), t, atk)
+	out	resultBySelectingB(ssb:Tuple, selectAndAttackB(atk, t, g, a)) = tuple(fst(get(a, t)) == g, t, atk)
 }		
 channel inputSelectArgB{
-	in resultBySelectingB(ssb, selectB(sucTrgAtk)) == sucTrgAtk
-	out handsB(outB, selectB(sucTrgAtk)) == if(fst(sucTrgAtk),
+	in resultBySelectingB(ssb, selectB(sucTrgAtk)) = sucTrgAtk
+	out handsB(outB, selectB(sucTrgAtk)) = if(fst(sucTrgAtk),
 										outB,
 										set(outB, snd(snd(sucTrgAtk)), tuple(fst(get(outB, snd(snd(sucTrgAtk)))), true)))
-	out handsA(outA, selectB(sucTrgAtk)) == if(fst(sucTrgAtk), 
+	out handsA(outA, selectB(sucTrgAtk)) = if(fst(sucTrgAtk), 
 										set(outA, fst(snd(sucTrgAtk)), tuple(fst(get(outA, fst(snd(sucTrgAtk)))), true)), 
 										outA)
 }
 
 channel judgeA{
-	in handsA(a:List, judge(j)) == j
-	out loseA(la:Bool, judge(j)) == eq(length(extractFaceDown(j)), 0)
+	in handsA(a:List, judge(j)) = j
+	out loseA(la:Bool, judge(j)) = length(extractFaceDown(j)) == 0
 } 
 channel judgeB{
-	in handsB(b:List, judge(j)) == j
-	out loseB(lb:Bool, judge(j)) == eq(length(extractFaceDown(j)), 0)
+	in handsB(b:List, judge(j)) = j
+	out loseB(lb:Bool, judge(j)) = length(extractFaceDown(j)) == 0
 } 
\ No newline at end of file