try to understand how this is possible

Author: breandan

src/commonMain/kotlin/ai/hypergraph/kaliningraph/CommonUtils.kt

@@ -133,13 +133,19 @@ class KBitSet(val n: Int) {
   constructor(n: Int, v: Collection<Int>) : this(n) { v.forEach { set(it) } }
   // Each element of 'data' holds 64 bits, covering up to n bits total.
   private val data = LongArray((n + 63) ushr 6)
+  var set = mutableSetOf<Int>()
+  var modified = false
 
   fun set(index: Int) {
+    modified = true
     val word = index ushr 6
     val bit  = index and 63
+    set += index
     data[word] = data[word] or (1L shl bit)
   }
 
+  fun setAll() { (0..<n).forEach { set(it) } }
+
   operator fun get(index: Int): Boolean {
     val word = index ushr 6
     val bit  = index and 63

src/commonMain/kotlin/ai/hypergraph/kaliningraph/parsing/CFG.kt

@@ -258,6 +258,16 @@ class Bindex<T>(
 class BiMap(val cfg: CFG) {
   val L2RHS by lazy { cfg.groupBy({ it.LHS }, { it.RHS }).mapValues { it.value.toSet() } }
   val R2LHS by lazy { cfg.groupBy({ it.RHS }, { it.LHS }).mapValues { it.value.toSet() } }
+  val R2LHSV by lazy { cfg.filter { it.RHS.all { it in cfg.nonterminals } }.groupBy({ it.RHS }, { it.LHS }).mapValues { it.value.toSet() } }
+  val R2LHSI by lazy {
+    val mmap = List(cfg.nonterminals.size) { List(cfg.nonterminals.size) { mutableListOf<Int>() } }
+    R2LHSV.forEach {
+      val rhs = it.key.map { cfg.bindex[it] }
+      mmap[rhs[0]][rhs[1]] += it.value.map { cfg.bindex[it] }
+    }
+//    R2LHSV.map { it.key.map { cfg.bindex[it] } to it.value.map { cfg.bindex[it] } }.toMap()
+    mmap
+  }
 
   val TDEPS: Map<Σᐩ, MutableSet<Σᐩ>> by lazy { // Maps all symbols to NTs that can generate them
     mutableMapOf<Σᐩ, MutableSet<Σᐩ>>().apply {

src/commonMain/kotlin/ai/hypergraph/kaliningraph/parsing/SetValiant.kt

@@ -50,7 +50,7 @@ fun CFG.isValid(str: List<Σᐩ>): Bln =
   if (str.size == 1) checkUnitWord(str.first()).isNotEmpty()
 //  else initialUTBMatrix(str.pad3()).seekFixpoint().diagonals.last()[0][0]
   else {
-     val dp = Array(str.size + 1) { Array(str.size + 1) { BooleanArray(nonterminals.size) { false } } }
+    val dp = Array(str.size + 1) { Array(str.size + 1) { BooleanArray(nonterminals.size) { false } } }
     str.map {
 //      if (it != "_" && tmMap[it] == null) println("What was this? \"$it\" / ${str.joinToString(" ")}")
       if (it == "_" || tmMap[it] == null) (0..<nonterminals.size).toList()
@@ -76,8 +76,26 @@ fun CFG.isValid(str: List<Σᐩ>): Bln =
      }
     dp[0][str.size][bindex[START_SYMBOL]]
   }
-    //.also { it.forEachIndexed { r, d -> d.forEachIndexed { i, it -> println("$r, $i: ${toNTSet(it)}") } } }
-    //.also { println("Last: ${it.joinToString(",") {if (it) "1" else "0"}}") }
+
+fun CFG.isValidAlt(str: List<Σᐩ>): Bln =
+  if (str.size == 1) checkUnitWord(str.first()).isNotEmpty()
+  else {
+    val dp = Array(str.size + 1) { Array(str.size + 1) { KBitSet(nonterminals.size) } }
+    str.map {
+      if (it == "_" || tmMap[it] == null) (0..<nonterminals.size).toList()
+      else tmToVidx[tmMap[it]!!] }.forEachIndexed { i, it -> it.forEach { vidx -> dp[i][i+1].set(vidx) } }
+
+    for (dist: Int in 0 until dp.size) {
+      for (iP: Int in 0 until dp.size - dist) {
+        val p = iP
+        val q = iP + dist
+        val appq = p..q
+        for (r in appq) for (lt in dp[p][r].set) for (rt in dp[r][q].set)
+          bimap.R2LHSI[lt][rt].forEach { dp[p][q].set(it) }
+      }
+    }
+    dp[0][str.size][bindex[START_SYMBOL]]
+  }
 
 fun CFG.corner(str: Σᐩ) =
  solveFixedpoint(str.tokenizeByWhitespace())[0].last().map { it.root }.toSet()
@@ -288,6 +306,47 @@ fun CFG.initialMatrix(str: List<Σᐩ>): TreeMatrix =
     }.toSet()
   }
 
+typealias GRES = List<GRE?>
+
+fun CFG.makeGRESAlgebra(): Ring<GRES> =
+  Ring.of(// Not a proper ring, but close enough.
+    // 0 = ∅
+    nil = listOf(),
+    // x + y = x ∪ y
+    plus = { x, y ->
+      if (x.isEmpty()) y else if (y.isEmpty()) x
+      else x.zip(y) { a, b ->
+        if (a == null) b
+        else if (b == null) a
+        else a + b
+      }
+    },
+    // x · y = { A0 | A1 ∈ x, A2 ∈ y, (A0 -> A1 A2) ∈ P }
+    times = { x, y -> if (x.isEmpty() || y.isEmpty()) emptyList() else greJoin(x, y) }
+  )
+
+fun CFG.greJoin(left: GRES, right: GRES): GRES =
+  vindex.map { lrs ->
+    val pairs = mutableListOf<GRE>()
+    for (i in 0..<lrs.size step 2) {
+      val left = (left[lrs[i]])
+      val right = (right[lrs[i + 1]])
+      if (left != null && right != null)
+        pairs += left * right
+    }
+    if (pairs.isEmpty()) null else GRE.CUP(*pairs.toTypedArray())
+  }
+
+fun CFG.initialGREMatrix(str: List<Σᐩ>): FreeMatrix<GRES> =
+  FreeMatrix(makeGRESAlgebra(), str.size + 1) { i, j ->
+    if (i + 1 != j) listOf<GRE>()
+    else if (str[j - 1] == HOLE_MARKER || str[j - 1] !in tmMap)
+      List(nonterminals.size) { GRE.SET(KBitSet(terminals.size).apply { setAll() }) }
+    else bimap[listOf(str[j - 1])].map { nt ->
+      GRE.SET(KBitSet(terminals.size).apply { set(tmMap[str[j - 1]]!!) })
+    }
+  }
+
 fun CFG.initialUTBMatrix(
   tokens: List<Σᐩ>,
   allNTs: Set<Σᐩ> = nonterminals,

src/commonTest/kotlin/ai/hypergraph/kaliningraph/parsing/SetValiantTest.kt

@@ -440,7 +440,7 @@ class SetValiantTest {
       }.also { println("Fast transition: ${it.duration.inWholeMilliseconds}ms") }.value
 
       measureTimedValue {
-        println(str in language)
+        println(isValidAlt(str))
       }.also { println("DP transition: ${it.duration.inWholeMilliseconds}ms") }.value
 
       println("Length: ${str.size}")