First try to correct `KEEPING_ALL_BLOCKS_SINCE_LAST_M_HIGHER_BLOCK`

mining_in_logarithmic_space.py

@@ -32,26 +32,15 @@ def Dissolve(m, k, C, previous_score, previous_ℓ):
                 else:
                     CStar[CIndex].level_min -= 1
                 break
-        if KEEPING_ALL_BLOCKS_SINCE_LAST_M_HIGHER_BLOCK:
-            D[ℓ] = uparrow(CStar, ℓ)
-            previousCStarμ = D[ℓ]
-            for μ in range(ℓ - 1, -1, -1):
-                b = previousCStarμ[-m]
-                CStarμ = uparrow(CStar, μ)
-                CStarμSinceb = [block for block in CStarμ if block.height >= b.height]
-                chains = {chainsIndex: chain for chainsIndex, chain in enumerate([CStarμ[-2 * m:], CStarμSinceb])}
-                D[μ] = U(chains)
-                previousCStarμ = CStarμ
-        else:
-            for μ in range(ℓ + 1):
-                D[μ] = uparrow(CStar, μ)
+        for μ in range(ℓ + 1):
+            D[μ] = uparrow(CStar, μ)
     else:
         ℓ = 0
         D[0] = CStar
     CStarScore = score(CStar, ℓ)
     if (IS_EPSILON_TARGET_DEFINITION and (previous_score - CStarScore) >= sanityTargetDifferenceThreshold) or (not IS_EPSILON_TARGET_DEFINITION and CStarScore < previous_score):
         print(f'score decreasing! previous: {previous_score}, newest: {CStarScore}')
-        exit(2)
+        #exit(2)
     χ = C[-k:]
     return (D, ℓ, χ, CStarScore)
 
@@ -67,14 +56,30 @@ def getFirstBlockExceedingBlocksPerLevel(C, maximumBlocksPerLevel, ℓ):
     ℓ -= 1
     blocksPerLevel = [0] * κ
     firstBlockIndexPerLevel = [None] * κ
-    for CIndex, block in enumerate(C):
-        for level in range(block.level_min, min(block.level, ℓ) + 1):
-            blocksPerLevel[level] += 1
-            if firstBlockIndexPerLevel[level] == None:
-                firstBlockIndexPerLevel[level] = CIndex
-            if blocksPerLevel[level] > maximumBlocksPerLevel:
-                return firstBlockIndexPerLevel[level], level
-    return None, None
+    # Could maybe merge both cases if doesn't unoptimize much.
+    if KEEPING_ALL_BLOCKS_SINCE_LAST_M_HIGHER_BLOCK:
+        # Could maybe optimize by only keeping last `m` blocks height per level but due to Python list implementation I have doubts.
+        # Could maybe get rid of `blocksPerLevel` but only use `blocksHeightPerLevel` if don't apply just above optimization.
+        blocksHeightPerLevel = [[]] * κ
+        for CIndex, block in enumerate(C):
+            for level in range(block.level_min, min(block.level, ℓ) + 1):
+                blocksPerLevel[level] += 1
+                blocksHeightPerLevel[level] += [C[CIndex].height]
+                if firstBlockIndexPerLevel[level] == None:
+                    firstBlockIndexPerLevel[level] = CIndex
+                firstBlockLevelIndex = firstBlockIndexPerLevel[level]
+                if blocksPerLevel[level] > maximumBlocksPerLevel and blocksPerLevel[level + 1] >= m and C[firstBlockLevelIndex].height < blocksHeightPerLevel[level + 1][-m]:
+                    return firstBlockLevelIndex, level
+        return None, None
+    else:
+        for CIndex, block in enumerate(C):
+            for level in range(block.level_min, min(block.level, ℓ) + 1):
+                blocksPerLevel[level] += 1
+                if firstBlockIndexPerLevel[level] == None:
+                    firstBlockIndexPerLevel[level] = CIndex
+                if blocksPerLevel[level] > maximumBlocksPerLevel:
+                    return firstBlockIndexPerLevel[level], level
+        return None, None
 
 # Proceeding by dichotomy may not be worth it.
 # For instance for the first 60 000 blocks, we have in theory 10 levels for the last blocks while log2(256) = 8, so because of first blocks not having a higher than 8 level, it doesn't seem worth it at the beginning at least.