diff -r b51d34113d47 -r 73f990bc6843 Spiral.scala --- a/Spiral.scala Thu May 07 11:36:15 2020 +0100 +++ b/Spiral.scala Wed May 27 22:23:52 2020 +0100 @@ -1,244 +1,19 @@ + +import Spiral._ import Element.elem import RexpRelated._ import RexpRelated.Rexp._ -import Partial._ +//import Partial._ import scala.collection.mutable.ListBuffer + object Spiral{ - val space = elem(" ") - val corner = elem("+") - def spiral(nEdges: Int, direction: Int): Element = { - if(nEdges == 1) - elem("+") - else { - val sp = spiral(nEdges - 1, (direction + 3) % 4) - def verticalBar = elem('|', 1, sp.height) - def horizontalBar = elem('-', sp.width, 1) - if(direction == 0) - (corner beside horizontalBar) above sp//(sp beside space) - else if (direction == 1) - sp beside (corner above verticalBar) - else if (direction == 2) - (space beside sp) above (horizontalBar beside corner) - else - (verticalBar above corner) beside (space above sp) - } - } val alphabet = ("""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.:"=()\;-+*!<>\/%{} """+"\n\t").toSet//Set('a','b','c') - def regx_tree(r: Rexp): Element = aregx_tree(internalise(r)) - def annotated_tree(r: ARexp): Element = { - r match { - case ACHAR(bs, d) => { - //val Some(d) = alphabet.find(f) - d match { - case '\n' => elem("\\n") - case '\t' => elem("\\t") - case ' ' => elem("space") - case d => if(bs.isEmpty) elem(d.toString) else elem(d.toString++" ") beside elem(bs.toString) - } - } - case AONE(bs) => { - if(bs.isEmpty) elem("ONE") else elem("ONE ") beside elem(bs.toString) - } - case AZERO => { - elem("ZERO") - } - case ASEQ(bs, r1, r2) => { - annotated_binary_print("SEQ", r1, r2, bs) - } - case AALTS(bs, rs) => { - //elem("Awaiting completion") - annotated_list_print("ALT", rs, bs) - } - case ASTAR(bs, r) => { - annotated_list_print("STA", List(r), bs) - } - } - } - def aregx_tree(r: ARexp): Element = { - r match { - case ACHAR(bs, d) => { - //val Some(d) = alphabet.find(f) - d match { - case '\n' => elem("\\n") - case '\t' => elem("\\t") - case ' ' => elem("space") - case d => elem(d.toString) - } - } - case AONE(bs) => { - elem("ONE") - } - case AZERO => { - elem("ZERO") - } - case ASEQ(bs, r1, r2) => { - binary_print("SEQ", r1, r2) - } - case AALTS(bs, rs) => { - //elem("Awaiting completion") - list_print("ALT", rs) - } - case ASTAR(bs, r) => { - list_print("STA", List(r)) - } - } - } - val port = elem(" └-") - def list_print(name: String, rs: List[ARexp]): Element = { - rs match { - case r::Nil => { - val pref = aregx_tree(r) - val head = elem(name) - (head left_align (port up_align pref) ) - } - case r2::r1::Nil => { - binary_print(name, r2, r1) - } - case r::rs1 => { - val pref = aregx_tree(r) - val head = elem(name) - if (pref.height > 1){ - val link = elem('|', 1, pref.height - 1) - (head left_align ((port above link) beside pref)) left_align tail_print(rs1) - } - else{ - (head left_align (port beside pref) ) left_align tail_print(rs1) - } - } - } - } - def annotated_list_print(name: String, rs: List[ARexp], bs: List[Bit]): Element = { - rs match { - case r::Nil => { - val pref = annotated_tree(r) - val head = if(bs.isEmpty) elem(name) else elem(name ++ " ") beside elem(bs.toString) - (head left_align (port up_align pref) ) - } - case r2::r1::Nil => { - annotated_binary_print(name, r2, r1, bs) - } - case r::rs1 => { - val pref = annotated_tree(r) - val head = if (bs.isEmpty) elem(name) else elem(name ++ " ") beside elem(bs.toString) - if (pref.height > 1){ - val link = elem('|', 1, pref.height - 1) - (head left_align ((port above link) beside pref)) left_align annotated_tail_print(rs1) - } - else{ - (head left_align (port beside pref) ) left_align annotated_tail_print(rs1) - } - } - } - } - - def annotated_tail_print(rs: List[ARexp]): Element = { - rs match { - case r2::r1::Nil => { - val pref = annotated_tree(r2) - val suff = annotated_tree(r1) - if (pref.height > 1){ - val link = elem('|', 1, pref.height - 1) - ((port above link) beside pref) left_align (port up_align suff) - } - else{ - (port beside pref) left_align (port up_align suff) - } - } - case r2::rs1 => { - val pref = annotated_tree(r2) - - if (pref.height > 1){ - val link = elem('|', 1, pref.height - 1) - ((port above link) beside pref) left_align annotated_tail_print(rs1)//(port up_align tail_print(rs1) ) - } - else{ - (port beside pref) left_align annotated_tail_print(rs1)//(port up_align tail_print(rs1)) - } - //pref left_align tail_print(rs1) - } - } - } - - def tail_print(rs: List[ARexp]): Element = { - rs match { - case r2::r1::Nil => { - val pref = aregx_tree(r2) - val suff = aregx_tree(r1) - if (pref.height > 1){ - val link = elem('|', 1, pref.height - 1) - ((port above link) beside pref) left_align (port up_align suff) - } - else{ - (port beside pref) left_align (port up_align suff) - } - } - case r2::rs1 => { - val pref = aregx_tree(r2) - - if (pref.height > 1){ - val link = elem('|', 1, pref.height - 1) - ((port above link) beside pref) left_align tail_print(rs1)//(port up_align tail_print(rs1) ) - } - else{ - (port beside pref) left_align tail_print(rs1)//(port up_align tail_print(rs1)) - } - //pref left_align tail_print(rs1) - } - } - } - - def binary_print(name: String, r1: ARexp, r2: ARexp): Element = { - val pref = aregx_tree(r1) - val suff = aregx_tree(r2) - val head = elem(name) - if (pref.height > 1){ - val link = elem('|', 1, pref.height - 1) - (head left_align ((port above link) beside pref) ) left_align (port up_align suff) - } - else{ - (head left_align (port beside pref) ) left_align (port up_align suff) - } - } - def annotated_binary_print(name: String, r1: ARexp, r2: ARexp, bs: List[Bit]): Element = { - val pref = annotated_tree(r1) - val suff = annotated_tree(r2) - val head = if (bs.isEmpty) elem(name) else elem(name ++ " ") beside elem(bs.toString) - if (pref.height > 1){ - val link = elem('|', 1, pref.height - 1) - (head left_align ((port above link) beside pref) ) left_align (port up_align suff) - } - else{ - (head left_align (port beside pref) ) left_align (port up_align suff) - } - } - + val arr_of_size = ListBuffer.empty[Int] - def pC(r: Rexp): Set[Rexp] = {//PD's companion - r match { - case SEQ(r1, r2) => pC(r2) - case ALTS(rs) => rs.flatMap(a => pC(a) ).toSet - case CHAR(c) => Set(r) - case r => Set() - } - } - def illustration(r: Rexp, s: String){ - var i_like_imperative_style = internalise(r) - val all_chars = s.toList - for (i <- 0 to s.length - 1){ - val der_res = bder(all_chars(i), i_like_imperative_style) - val simp_res = bsimp(der_res) - println("The original regex, the regex after derivative w.r.t " + all_chars(i) + " and the simplification of the derivative.") - println(aregx_tree(i_like_imperative_style) up_align aregx_tree(der_res) up_align aregx_tree(simp_res)) - //println(asize(i_like_imperative_style), asize(der_res), asize(simp_res)) - arr_of_size += asize(i_like_imperative_style) - //println(asize(simp_res), asize(simp_res) / arr_of_size(0) ) - i_like_imperative_style = simp_res - } - arr_of_size += asize(i_like_imperative_style) - } + val ran = scala.util.Random var alphabet_size = 3 def balanced_seq_star_gen(depth: Int, star: Boolean): Rexp = { @@ -252,20 +27,15 @@ SEQ(balanced_seq_star_gen(depth - 1, true), balanced_seq_star_gen(depth - 1, true)) } } - def max(i: Int, j: Int): Int = { - if(i > j) - i - else - j - } def random_struct_gen(depth:Int): Rexp = { val dice = ran.nextInt(3) val dice2 = ran.nextInt(3) - (dice, depth) match { + val new_depth = (List(0, depth - 1 - dice2)).max + (dice, new_depth) match { case (_, 0) => ((ran.nextInt(3) + 97).toChar).toString - case (0, i) => STAR(random_struct_gen(max(0, i - 1 - dice2))) - case (1, i) => SEQ(random_struct_gen(max(0, i - 1 - dice2)), random_struct_gen(max(0, i - 1 - dice2))) - case (2, i) => ALTS( List(random_struct_gen(max(0, i - 1 - dice2)), random_struct_gen(max(0, i - 1 - dice2))) ) + case (0, i) => STAR(random_struct_gen(new_depth)) + case (1, i) => SEQ(random_struct_gen(new_depth), random_struct_gen(new_depth)) + case (2, i) => ALTS( List(random_struct_gen(new_depth), random_struct_gen(new_depth)) ) } } def balanced_struct_gen(depth: Int): Rexp = { @@ -297,41 +67,8 @@ println(b(0),b.max) } - def dep_exp(depth: List[Int]){ - for(i <- depth){ - arr_of_size.clear() - val s = rd_string_gen(alphabet_size, (i-8)*(i-8)+10) - val r = random_struct_gen(i) - println("depth: "+i) - illustration(r, s) //"abcabadaaadcabdbabcdaadbabbcbbdabdabbcbdbabdbcdb") - //println("depth: " + i + " general stats:"+ arr_of_size(0), arr_of_size.max, arr_of_size.max/arr_of_size(0)) - //println("x y label alignment") - /*for(i <- 0 to s.length - 1){ - if(s(i) == '\n') - println(i+" "+arr_of_size(i)+" "+"nl"+" -140") - else if(s(i) == ' ') - println(i+" "+arr_of_size(i)+" "+"sp"+" -140") - else - println(i+" "+arr_of_size(i)+" "+s(i)+" -140") - }*/ - //println(s.length + " " + arr_of_size(s.length) + " ]" + " -140") - } - } - def case_study(ss: List[String], r: Rexp){ - for(s <- ss){ - arr_of_size.clear() - illustration(r, s) - println("x y label alignment") - for(i <- 0 to s.length - 1){ - if(s(i) == '\n') - println(i+" "+arr_of_size(i)+" "+"nl"+" -140") - else if(s(i) == ' ') - println(i+" "+arr_of_size(i)+" "+"sp"+" -140") - else - println(i+" "+arr_of_size(i)+" "+s(i)+" -140") - } - } - } + + def star_gen(dp: Int): Rexp = { if(dp > 0) STAR(star_gen(dp - 1)) @@ -346,48 +83,9 @@ Nil } } - def regx_print(r: Rexp): String = { - r match { - case ZERO => - "ZERO" - case CHAR(c) => { - //val Some(c) = alphabet.find(f) - "\"" + c.toString + "\"" - } - case ONE => { - "ONE" - } - case ALTS(rs) => { - "ALTS(List("+(rs.map(regx_print)).foldLeft("")((a, b) => if(a == "") b else a + "," + b)+"))" - } - case SEQ(r1, r2) => { - "SEQ(" + regx_print(r1) + "," + regx_print(r2) + ")" - } - case STAR(r) => { - "STAR(" + regx_print(r) + ")" - } - } - } + val mkst = "abcdefghijklmnopqrstuvwxyz" - - def inclusion_truth(anatomy: List[Rexp], pd: Set[Rexp]): Boolean = { - val aset = anatomy.toSet - if(aset subsetOf pd){ - true - } - else{ - println("inclusion not true") - false - } - } - def size_comp(anatomy: List[Rexp], pd: Set[Rexp]):Boolean = {println("size of PD and bspilled simp regx: ", pd.size, anatomy.size); true} - def size_expansion_rate(r: List[Rexp], pd: Set[Rexp]): Boolean = if(size(r(0)) > (pd.map(size).sum) * 3 ) { false }else {true} - def ders_simp(r: ARexp, s: List[Char]): ARexp = { - s match { - case Nil => r - case c::cs => ders_simp(bsimp(bder(c, r)), cs) - } - } + val big_panda = STAR(STAR(STAR(ALTS(List(ALTS(List(CHAR('c'), CHAR('b'))), SEQ(CHAR('c'),CHAR('c'))))))) val str_panda = "ccccb" @@ -396,28 +94,28 @@ case b::bs1 => elem(b.toString) beside bstostick(bs1) case Nil => elem(' ', 1, 1) } - def bits_print(r: ARexp): Element = r match { + def aregex_simple_print(r: ARexp): Element = r match { case AALTS(bs,rs) => { val bitstick = bstostick(bs) rs match { case r::rs1 => rs1.foldLeft( ((elem("(") left_align bitstick) beside - bits_print(r)) )( (acc, r2) => acc beside ((elem(" + ") above elem(" ")) beside bits_print(r2) )) beside + aregex_simple_print(r)) )( (acc, r2) => acc beside ((elem(" + ") above elem(" ")) beside aregex_simple_print(r2) )) beside elem(")") case Nil => elem(' ', 1, 1) } } case ASEQ(bs, r1, r2) => { - ((elem("[") left_align bstostick(bs)) beside bits_print(r1) beside elem("~") beside bits_print(r2) beside (elem("]") above elem(" "))) + ((elem("[") left_align bstostick(bs)) beside aregex_simple_print(r1) beside elem("~") beside aregex_simple_print(r2) beside (elem("]") above elem(" "))) } case ASTAR(bs, r) => { r match { case AONE(_) | AZERO | ACHAR(_, _) => { - (elem("{") left_align bstostick(bs)) beside (bits_print(r) beside elem("}*")) + (elem("{") left_align bstostick(bs)) beside (aregex_simple_print(r) beside elem("}*")) } case _ => { - (elem("{") left_align bstostick(bs)) beside (bits_print(r) beside elem("}*")) + (elem("{") left_align bstostick(bs)) beside (aregex_simple_print(r) beside elem("}*")) } } } @@ -432,30 +130,30 @@ elem ("0") above elem(" ") } } - def happy_print(r: Rexp): Unit = r match { + def regex_simple_print(r: Rexp): Unit = r match { case ALTS( r::rs ) => { print("(") - happy_print(r) + regex_simple_print(r) rs.map(r2=>{ print(" + ") - happy_print(r2) + regex_simple_print(r2) }) print(")") } case SEQ(r1, r2) => { - happy_print(r1) + regex_simple_print(r1) print("~") - happy_print(r2) + regex_simple_print(r2) } case STAR(r) => { r match { case ONE | ZERO | CHAR(_) => { - happy_print(r) + regex_simple_print(r) print("*") } case _ => { print("[") - happy_print(r) + regex_simple_print(r) print("]*") } } @@ -470,42 +168,30 @@ print(c) } } - def bits_slide(s: String, r: Rexp){ - val nangao = ders_simp(internalise(r), s.toList) - val easy = bsimp(bders(s.toList, internalise(r))) - println(s) - println(r) - happy_print(r) - println() - print(bits_print(nangao)) - println() - print(bits_print(easy)) - println() - } //found r = SEQ(ALTS(List(CHAR(c), CHAR(a))),SEQ(ALTS(List(CHAR(a), CHAR(c))),ALTS(List(CHAR(b), CHAR(c))))) s = "aa" def bsimp_print(r: ARexp): Unit = r match { case ASEQ(bs, r1, r2) => { println("0.r or r.0 to 0 or bs1 1.r to fuse bs++bs1 r") - bits_print(bsimp(r1)) - bits_print(bsimp(r2)) + aregex_simple_print(bsimp(r1)) + aregex_simple_print(bsimp(r2)) } case AALTS(bs, rs) => { println("rs.map(bsimp) equals *************") val rs_simp = rs.map(bsimp) for(r <- rs_simp){ - println(bits_print(r)) + println(aregex_simple_print(r)) } println("*************") println("flts(rs_simp)") val flat_res = flats(rs_simp) for(r <- flat_res){ - println(bits_print(r)) + println(aregex_simple_print(r)) } println("dB(flat_res)") val dist_res = distinctBy(flat_res, erase) for(r <- dist_res){ - println(bits_print(r)) + println(aregex_simple_print(r)) } dist_res match { case Nil => println("AZERO") @@ -515,99 +201,16 @@ } case _ => println("No simp at this level") } - def tellmewhy(){ - //val r = SEQ(ALTS(List(CHAR('a'), CHAR('b'))),ALTS(List(ALTS(List(CHAR('a'), CHAR('a'))), STAR(CHAR('a'))))) - //val r = SEQ(ALTS(List(CHAR('a'), CHAR('b'))),ALTS(List(CHAR('a'), STAR(CHAR('a')) ) )) - val r = ("ab" | ( (("a")%) | "aa") ) - //val r = ("a"|"b")~("a") - val s = "aa" - for(i <- 0 to s.length-1){ - val ss = s.slice(0, i+1) - val nangao = bders_simp_rf(ss.toList, internalise(r)) - val easy = (bders(ss.toList, internalise(r))) - println("iteration starts") - println("bders_simp") - println(bits_print(nangao)) - println() - println("bders") - println(bits_print(easy)) - println() - println("new simp") - println(bits_print(bsimp_rf(easy))) - println("iteration ends") - } - println("old simp ders") - println(bits_print(bsimp(bders(s.toList, internalise(r))))) - println("old derssimp") - println(bits_print(ders_simp(internalise(r), s.toList))) - } - def find_re(){ - for (i <- 1 to 10000){ - val r = balanced_struct_gen(3) - val s = rd_string_gen(2,1) - val nangao = ders_simp(internalise(r), s.toList) - val easy = bsimp(bders(s.toList, internalise(r))) - if(nangao != easy){ - bits_slide(s, r) - } - } - } + + //simplified regex size 291, so called pd_simp size 70 (did not do simplification to terms in the PD set) def pushbits(r: ARexp): ARexp = r match { case AALTS(bs, rs) => AALTS(Nil, rs.map(r=>fuse(bs, pushbits(r)))) case ASEQ(bs, r1, r2) => ASEQ(bs, pushbits(r1), pushbits(r2)) case r => r } - def correctness_proof_convenient_path(){ - for(i <- 1 to 19999){ - val s = rd_string_gen(alphabet_size, 3)//"abaa"//rd_string_gen(alphabet_size, 3) - val r = internalise(random_struct_gen(4))//ASTAR(List(),AALTS(List(),List(ASTAR(List(Z),ACHAR(List(),'a')), ASEQ(List(S),ACHAR(List(),'a'),ACHAR(List(),'b')))))//internalise(balanced_struct_gen(3))//SEQ(ALTS(List(STAR("a"),ALTS(List("a","c")))),SEQ(ALTS(List("c","a")),ALTS(List("c","b")))) //random_struct_gen(7) - for(j <- 0 to s.length - 1){ - val ss = s.slice(0, j+ 1) - val nangao = bders_simp_rf(ss.toList, r) - val easy = bsimp_rf(bders_rf(ss.toList, r)) - if(!(nangao == easy)){ - println(j) - println("not equal") - println("string") - println(ss) - println("original regex") - println(annotated_tree(r)) - println("regex after ders simp") - println(annotated_tree(nangao)) - println("regex after ders") - println(annotated_tree(bders(ss.toList, r)))//flats' fuse when opening up AALTS causes the difference - println("regex after ders and then a single simp") - println(annotated_tree(easy)) - } - } - } - } - /* if(bts == cdbts){//test of equality code v = retrieve internalise(r) v if |- v : r - println(bts) - println(cdbts) - println("code v = retrieve internalise(r) v if |- v : r") - } - val r_der_s = bders(st.toList, rg) - println(aregx_tree(r_der_s)) - val bts = retrieve(r_der_s, unsimplified_vl) - val cdbts = code(unsimplified_vl) - val simprg = bsimp(r_der_s) - val frectv = decode(erase(simprg), cdbts) - val simpbts = retrieve(simprg, frectv) - if(bts == simpbts){ - println("retrieve r v = retrieve (bsimp r) (decode bsimp(r) code(v))") - println("bits:") - //println(bts) - println(simpbts) - println("v = ") - println(unsimplified_vl) - println("frect v = ") - println(frectv) - } - *///KH8W5BXL def nice_lex(r: Rexp, s: List[Char], ar: ARexp) : Val = s match { case Nil => if (nullable(r)){ @@ -688,17 +291,6 @@ println(s"bsimp(bder c r) = ${unsimp}, whereas bsimp(bder c bsimp r) = ${simped}") } } - def essence_posix(){ - //val s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"//rd_string_gen(alphabet_size, 3)//"abaa"//rd_string_gen(alphabet_size, 3) - val s0 = "a" - val r = SEQ(STAR(ALT("a", "aa")), "b")//internalise(random_struct_gen(4))//ASTAR(List(),AALTS(List(),List(ASTAR(List(Z),ACHAR(List(),'a')), ASEQ(List(S),ACHAR(List(),'a'),ACHAR(List(),'b')))))//internalise(balanced_struct_gen(3))//SEQ(ALTS(List(STAR("a"),ALTS(List("a","c")))),SEQ(ALTS(List("c","a")),ALTS(List("c","b")))) //random_struct_gen(7) - for(i <- 1 to 40){ - val s = s0*i - //printf("%d %d\n",i, size(ders(s.toList, r))) - printf("%d %d\n",i, asize(ders_simp( internalise(r), s.toList))) - //println(asize(ders_simp( internalise(r), s.toList))) - } - } def speed_test(){ val s0 = "a"*1000 @@ -825,11 +417,11 @@ val v1 = inj(erase(r), c, v0) val v2 = fuzzy_inj(r, c, v) println("regular expression original") - println(bits_print(r)) + println(aregex_simple_print(r)) println("regular expression derivative") - println(bits_print(dr)) + println(aregex_simple_print(dr)) println("regular expression simped derivative") - println(bits_print(sdr)) + println(aregex_simple_print(sdr)) println("simplified value") println(v) println("unsimplified value") @@ -842,36 +434,32 @@ println("fuzzy_inj "+r+c+v) } def vunsimp_test(){ - for(i <- 1 to 1000){ - val r = random_struct_gen(5)//[{ a}*~{{a}*}*] - val c = (ran.nextInt(3) + 97).toChar//Sequ(Stars(List()),Stars(List())) - val dr = der(c, r) - val bdr = bder(c, internalise(r)) - if(nullable(dr)){ - println("bohooooooooooooooooo!") - val dv = mkeps(dr) - val target_vr = bsimp2(bdr, dv) - println(bits_print(target_vr._1)) - println(target_vr._2) - println(vunsimp(bdr, dv)(target_vr._2)) - } - } + /*val bdr = AALTS( + List(), + List( + AONE(List(S,Z)), + ASTAR(List(Z,Z,S), ACHAR(List(),'c')), + ASEQ(List(Z), ASTAR(List(S), ACHAR(List(), 'c')), ASTAR(List(S), ACHAR(List(), 'c') ) ) + ) + )*/ + val bdr = AALTS(List(),List(AALTS(List(Z),List(ASEQ(List(), + ASEQ(List(),AONE(List(S)),ASTAR(List(),ACHAR(List(),'c'))),ASTAR(List(),ACHAR(List(),'c'))), + ASEQ(List(Z),AONE(List(S)),ASTAR(List(),ACHAR(List(),'c'))))), AALTS(List(S),List(AONE(List(Z)), AZERO)))) + val dr = erase(bdr) + val dv = mkeps(dr) + //val bdr = bder(c, internalise(r)) + //val dv = mkeps(dr) + println(aregex_simple_print(bdr)) + println(dv) + val target_vr = bsimp2(bdr, dv) + println(aregex_simple_print(target_vr._1)) + println(target_vr._2) + println(vunsimp(bdr, dv)(target_vr._2)) } + + def main(args: Array[String]) { - //finj_test0('b', fuse(List(S, Z), internalise( ( ("a"|"b")% ) ) )) - //finj_test0('a', fuse(List(S, Z), internalise( ( ("a"|"b")% ) ) )) - //finj_test0('b', bder('a', internalise( (("c" | "ab")%) ))) - //finj_test0('a', internalise( (("c" | "ab")%) )) - //this example gives us an exception - //val r = internalise(ALTS(List(STAR(CHAR('c')), STAR(CHAR('b'))))) - //val c = 'c' - //if(bder(c, r) != internalise(der(c, erase(r)))) - //println("noooooo!") - //println(bits_print(r)) - //println(c) - //finj_test0(c, r) vunsimp_test() } } -//List( ASTAR(List(Z),ACHAR(List(),a)), AALTS(List(S),List(ACHAR(List(Z),b), ACHAR(List(S),a))) )