zizek 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56550f1df48e9289714d76af41df79738652c10e11109dadf88701f8d9ad8a92
-  data.tar.gz: 3e8be13c05032b6801c870bbd652777677d023561ccf9e378d36bcc52149abb1
+  metadata.gz: a13245a0633d896960fb32535b0216a19220ac11945b3c64b8a6fcabb3ec0ff6
+  data.tar.gz: bc883a26299d4af6c9b73c3d3096d2a9373f045a7f76853afa213657c97a782c
 SHA512:
-  metadata.gz: 8fbc8669a860b93a6471991677b38beb4221d65f60f73e0021e2c2f7f15d3f52f1d90ac80b990d1f62e0d5c431581bafa32a1ff8a114a6bc0b09debda714af0d
-  data.tar.gz: 758527d12cc63a504bcda8f65d084b2f5ba50e571d66d5885f2b613a0d72ae9110911f25fd47d5392bbaa7d00ecd917b48f0b47a03e5cdbd533e3e0c1a6f5acf
+  metadata.gz: b1e1b5ad6b81eda6f9e6903fd64ee5b583b78684e893090f6c095141d59068bcef8b8165bfd176c00a496085cfa96fcac9db78682b55b6ad057c370ceb2ad4f5
+  data.tar.gz: 34ae7a0f7a001b1f70bdcd0b89303fe1e8d6d4892bf1dc9ede060f6b0793411c595dc0fad2b55d4545a4bfc7be0a86b843d65447aa79ce8da866acd680e76fbd

data/CHANGELOG.md

@@ -5,7 +5,18 @@ All notable changes to the Ruby package are recorded here. The format follows
 [semantic versioning](https://semver.org/spec/v2.0.0.html) — while the version
 is `0.x`, the API may change in any release.
 
-## [0.1.0] - 2026-10-27
+## [0.1.2] - 2026-10-28
+
+### Fixed
+
+- Shrinking a long byte-string or text draw no longer stalls. Converting a
+  draw to and from its shortlex index took time roughly cubic in its length, so
+  a draw of about 1 KB could keep a shrink running for minutes; byte indexes are
+  now built and decoded in one linear pass, text indexes without full bigint
+  products, and two text draws compare without building either index. Shrunk
+  results and reproduce blobs are unchanged.
+
+## [0.1.1] - 2026-10-27
 
 First release of the Ruby package.
 

data/lib/zizek/gen.rb

@@ -866,6 +866,133 @@ module Zizek
       return result
     end
 
+    def positive_mul_add_small_le(value_raw, factor, addend)
+      value = signed_abs_le(value_raw)
+      n = value.bytesize
+      i0 = 0
+      i1 = 1
+      u0 = 0
+      u8 = 8
+      u255 = 255
+      out = String.new(encoding: Encoding::BINARY)
+      carry = addend
+      pos = i0
+      loop do
+        done = (pos >= n)
+        if done
+          break
+        end
+        byte_ = value.getbyte(pos)
+        scaled = ((byte_ * factor) & MASK)
+        sum = ((scaled + carry) & MASK)
+        out_byte = (sum & u255)
+        out << (out_byte & 0xff)
+        carry = (sum >> u8)
+        pos = (pos + i1)
+      end
+      loop do
+        drained = (carry == u0)
+        if drained
+          break
+        end
+        carry_byte = (carry & u255)
+        out << (carry_byte & 0xff)
+        carry = (carry >> u8)
+      end
+      out << (u0 & 0xff)
+      canonical = canonicalize_signed_le(out)
+      return canonical
+    end
+
+    def small_quotient_digit(current, divisor)
+      u0 = 0
+      u1 = 1
+      u8 = 8
+      digit = u0
+      rest = current
+      bit = u8
+      loop do
+        done = (bit == u0)
+        if done
+          break
+        end
+        bit = ((bit - u1) & MASK)
+        step = ((divisor << bit) & MASK)
+        fits = (rest >= step)
+        if fits
+          rest = ((rest - step) & MASK)
+          place = ((u1 << bit) & MASK)
+          digit = (digit | place)
+        end
+      end
+      return digit
+    end
+
+    def positive_div_small_le(value_raw, divisor)
+      value = signed_abs_le(value_raw)
+      n = value.bytesize
+      i0 = 0
+      i1 = 1
+      u0 = 0
+      u8 = 8
+      high_first = String.new(encoding: Encoding::BINARY)
+      remainder = u0
+      pos = n
+      loop do
+        done = (pos == i0)
+        if done
+          break
+        end
+        pos = (pos - i1)
+        byte_ = value.getbyte(pos)
+        shifted = ((remainder << u8) & MASK)
+        current = ((shifted + byte_) & MASK)
+        digit = small_quotient_digit(current, divisor)
+        high_first << (digit & 0xff)
+        taken = ((digit * divisor) & MASK)
+        remainder = ((current - taken) & MASK)
+      end
+      out = String.new(encoding: Encoding::BINARY)
+      pos = n
+      loop do
+        done = (pos == i0)
+        if done
+          break
+        end
+        pos = (pos - i1)
+        byte_ = high_first.getbyte(pos)
+        out << (byte_ & 0xff)
+      end
+      out << (u0 & 0xff)
+      canonical = canonicalize_signed_le(out)
+      return canonical
+    end
+
+    def positive_rem_small_le(value_raw, divisor)
+      value = signed_abs_le(value_raw)
+      n = value.bytesize
+      i0 = 0
+      i1 = 1
+      u0 = 0
+      u8 = 8
+      remainder = u0
+      pos = n
+      loop do
+        done = (pos == i0)
+        if done
+          break
+        end
+        pos = (pos - i1)
+        byte_ = value.getbyte(pos)
+        shifted = ((remainder << u8) & MASK)
+        current = ((shifted + byte_) & MASK)
+        digit = small_quotient_digit(current, divisor)
+        taken = ((digit * divisor) & MASK)
+        remainder = ((current - taken) & MASK)
+      end
+      return remainder
+    end
+
     def signed_compare_le(left_raw, right_raw)
       left = canonicalize_signed_le(left_raw)
       right = canonicalize_signed_le(right_raw)
@@ -1372,34 +1499,35 @@ module Zizek
     def bytes_to_index(min_size, value)
       i0 = 0
       i1 = 1
-      base = bigint_base_256()
-      offset = bigint_zero()
-      length = min_size
+      u0 = 0
+      u1 = 1
+      u8 = 8
+      u255 = 255
       value_length = value.bytesize
-      loop do
-        done = (length >= value_length)
-        if done
-          break
-        end
-        exponent = (length & MASK)
-        bucket = positive_pow_le(base, exponent)
-        offset = signed_add_le(offset, bucket)
-        length = (length + i1)
-      end
-      position = bigint_zero()
+      last = (value_length - i1)
+      out = String.new(encoding: Encoding::BINARY)
+      carry = u0
       pos = i0
       loop do
         done = (pos >= value_length)
         if done
           break
         end
-        byte_ = value.getbyte(pos)
-        digit = positive_u8_le(byte_)
-        shifted = signed_mul_le(position, base)
-        position = signed_add_le(shifted, digit)
+        mirror = (last - pos)
+        digit = value.getbyte(mirror)
+        sum = ((digit + carry) & MASK)
+        in_offset = (pos >= min_size)
+        if in_offset
+          sum = ((sum + u1) & MASK)
+        end
+        out_byte = (sum & u255)
+        out << (out_byte & 0xff)
+        carry = (sum >> u8)
         pos = (pos + i1)
       end
-      index = signed_add_le(offset, position)
+      out << (carry & 0xff)
+      out << (u0 & 0xff)
+      index = canonicalize_signed_le(out)
       return index
     end
 
@@ -1424,49 +1552,99 @@ module Zizek
     def bytes_from_index(min_size, max_size, index_raw)
       i0 = 0
       i1 = 1
-      base = bigint_base_256()
-      remaining = signed_abs_le(index_raw)
-      length = min_size
+      u0 = 0
+      u1 = 1
+      u8 = 8
+      u255 = 255
+      u256 = 256
+      index = signed_abs_le(index_raw)
+      index_n = index.bytesize
+      significant = index_n
       loop do
-        past_end = (length > max_size)
-        if past_end
+        none_left = (significant == i0)
+        if none_left
           break
         end
-        exponent = (length & MASK)
-        bucket = positive_pow_le(base, exponent)
-        bucket_cmp = signed_compare_le(remaining, bucket)
-        inside_bucket = (bucket_cmp < i0)
-        if inside_bucket
-          out = String.new(encoding: Encoding::BINARY)
-          empty = (length == i0)
-          if empty
-            some_empty = out.dup
-            return some_empty
+        top_pos = (significant - i1)
+        top = index.getbyte(top_pos)
+        top_set = (top != u0)
+        if top_set
+          break
+        end
+        significant = top_pos
+      end
+      length = min_size
+      past_min = (significant > min_size)
+      if past_min
+        length = significant
+        pos = significant
+        loop do
+          done = (pos == i0)
+          if done
+            break
           end
-          power = (length - i1)
-          power_u64 = (power & MASK)
-          divisor = positive_pow_le(base, power_u64)
-          pos = i0
-          loop do
-            done = (pos >= length)
-            if done
-              break
-            end
-            digit = positive_div_le_nonzero(remaining, divisor)
-            byte_ = digit.getbyte(i0)
-            out << (byte_ & 0xff)
-            remaining = positive_rem_le_nonzero(remaining, divisor)
-            divisor = positive_div_le_nonzero(divisor, base)
-            pos = (pos + i1)
+          pos = (pos - i1)
+          index_byte = index.getbyte(pos)
+          offset_byte = u0
+          in_offset = (pos >= min_size)
+          if in_offset
+            offset_byte = u1
+          end
+          below = (index_byte < offset_byte)
+          if below
+            length = (significant - i1)
+            break
+          end
+          above = (index_byte > offset_byte)
+          if above
+            break
           end
-          some = out.dup
-          return some
         end
-        remaining = signed_sub_le(remaining, bucket)
-        length = (length + i1)
       end
-      none = nil
-      return none
+      past_end = (length > max_size)
+      if past_end
+        none = nil
+        return none
+      end
+      low_first = String.new(encoding: Encoding::BINARY)
+      borrow = u0
+      pos = i0
+      loop do
+        done = (pos >= length)
+        if done
+          break
+        end
+        index_byte = u0
+        present = (pos < index_n)
+        if present
+          index_byte = index.getbyte(pos)
+        end
+        subtrahend = borrow
+        in_offset = (pos >= min_size)
+        if in_offset
+          subtrahend = ((subtrahend + u1) & MASK)
+        end
+        lifted = ((index_byte + u256) & MASK)
+        difference = ((lifted - subtrahend) & MASK)
+        out_byte = (difference & u255)
+        low_first << (out_byte & 0xff)
+        kept = (difference >> u8)
+        borrow = ((u1 - kept) & MASK)
+        pos = (pos + i1)
+      end
+      out = String.new(encoding: Encoding::BINARY)
+      pos = length
+      loop do
+        done = (pos == i0)
+        if done
+          break
+        end
+        pos = (pos - i1)
+        byte_ = low_first.getbyte(pos)
+        out << (byte_ & 0xff)
+      end
+      some = out.dup
+      return some
     end
 
     def f64_abs(value)
@@ -5953,9 +6131,11 @@ module Zizek
       u0 = 0
       u1 = 1
       u2 = 2
+      u4 = 4
+      u8 = 8
+      u255 = 255
       length = string_length(value)
-      best = u0
-      found = false
+      ranks = String.new(encoding: Encoding::BINARY)
       at = i0
       loop do
         done = (at >= length)
@@ -5965,9 +6145,37 @@ module Zizek
         codepoint = string_codepoint_at(value, at)
         index = alphabet_index_of(alphabet, codepoint)
         present = !index.nil?
+        stored = u0
         if present
           index_value = index
           rank = alphabet_shrink_rank(alphabet, index_value)
+          stored = ((rank + u1) & MASK)
+        end
+        stored_byte = u0
+        loop do
+          packed_all = (stored_byte == u4)
+          if packed_all
+            break
+          end
+          stored_low = (stored & u255)
+          ranks << (stored_low & 0xff)
+          stored = (stored >> u8)
+          stored_byte = ((stored_byte + u1) & MASK)
+        end
+        at = (at + i1)
+      end
+      best = u0
+      found = false
+      at = i0
+      loop do
+        done = (at >= length)
+        if done
+          break
+        end
+        stored = string_codepoint_at(ranks, at)
+        present = (stored != u0)
+        if present
+          rank = ((stored - u1) & MASK)
           lowerable = (rank != u0)
           improves = (rank > best)
           not_found = (!found)
@@ -5981,15 +6189,13 @@ module Zizek
               if counted
                 break
               end
-              other_codepoint = string_codepoint_at(value, other)
-              other_index = alphabet_index_of(alphabet, other_codepoint)
-              other_present = !other_index.nil?
-              if other_present
-                other_index_value = other_index
-                other_rank = alphabet_shrink_rank(alphabet, other_index_value)
-                same = (other_rank == rank)
-                if same
-                  seen = ((seen + u1) & MASK)
+              other_stored = string_codepoint_at(ranks, other)
+              same = (other_stored == stored)
+              if same
+                seen = ((seen + u1) & MASK)
+                twice = (seen >= u2)
+                if twice
+                  break
                 end
               end
               other = (other + i1)
@@ -6075,19 +6281,23 @@ module Zizek
         none_past = nil
         return none_past
       end
+      i4 = 4
+      whole = (length * i4)
+      drop_start = (position * i4)
+      drop_end = (drop_start + i4)
       out = String.new(encoding: Encoding::BINARY)
       at = i0
       loop do
-        done = (at >= length)
+        done = (at >= whole)
         if done
           break
         end
-        dropped = (at == position)
-        kept = (!dropped)
+        before = (at < drop_start)
+        after = (at >= drop_end)
+        kept = (before || after)
         if kept
-          codepoint = string_codepoint_at(value, at)
-          packed_ = u32_to_le(codepoint)
-          out = append_bytes(out, packed_)
+          byte_ = value.getbyte(at)
+          out << (byte_ & 0xff)
         end
         at = (at + i1)
       end
@@ -6099,20 +6309,30 @@ module Zizek
       i0 = 0
       i1 = 1
       u0 = 0
+      u1 = 1
       size = alphabet_size(alphabet)
-      base = u64_to_bigint_le(size)
       count = string_length(value)
       offset = bigint_zero()
-      length = min_size
-      loop do
-        done = (length >= count)
-        if done
-          break
+      has_offset = (count > min_size)
+      if has_offset
+        length = min_size
+        loop do
+          done = (length >= count)
+          if done
+            break
+          end
+          offset = positive_mul_add_small_le(offset, size, u1)
+          length = (length + i1)
+        end
+        scale = i0
+        loop do
+          done = (scale >= min_size)
+          if done
+            break
+          end
+          offset = positive_mul_add_small_le(offset, size, u0)
+          scale = (scale + i1)
         end
-        exponent = (length & MASK)
-        bucket = positive_pow_le(base, exponent)
-        offset = signed_add_le(offset, bucket)
-        length = (length + i1)
       end
       position = bigint_zero()
       pos = i0
@@ -6129,15 +6349,79 @@ module Zizek
           alphabet_index = found
           rank = alphabet_shrink_rank(alphabet, alphabet_index)
         end
-        digit = u64_to_bigint_le(rank)
-        shifted = signed_mul_le(position, base)
-        position = signed_add_le(shifted, digit)
+        position = positive_mul_add_small_le(position, size, rank)
         pos = (pos + i1)
       end
       index = signed_add_le(offset, position)
       return index
     end
 
+    def string_index_compare(alphabet, min_size, left, right)
+      i0 = 0
+      i1 = 1
+      u0 = 0
+      negative_one = (i0 - i1)
+      size = alphabet_size(alphabet)
+      left_count = string_length(left)
+      right_count = string_length(right)
+      has_members = (size != u0)
+      left_sized = (left_count >= min_size)
+      right_sized = (right_count >= min_size)
+      both_sized = (left_sized && right_sized)
+      direct = (has_members && both_sized)
+      indirect = (!direct)
+      if indirect
+        left_index = string_to_index(alphabet, min_size, left)
+        right_index = string_to_index(alphabet, min_size, right)
+        order = signed_compare_le(left_index, right_index)
+        return order
+      end
+      left_shorter = (left_count < right_count)
+      if left_shorter
+        return negative_one
+      end
+      left_longer = (left_count > right_count)
+      if left_longer
+        return i1
+      end
+      pos = i0
+      loop do
+        done = (pos >= left_count)
+        if done
+          break
+        end
+        left_codepoint = string_codepoint_at(left, pos)
+        right_codepoint = string_codepoint_at(right, pos)
+        differs = (left_codepoint != right_codepoint)
+        if differs
+          left_found = alphabet_index_of(alphabet, left_codepoint)
+          left_present = !left_found.nil?
+          left_rank = u0
+          if left_present
+            left_alphabet_index = left_found
+            left_rank = alphabet_shrink_rank(alphabet, left_alphabet_index)
+          end
+          right_found = alphabet_index_of(alphabet, right_codepoint)
+          right_present = !right_found.nil?
+          right_rank = u0
+          if right_present
+            right_alphabet_index = right_found
+            right_rank = alphabet_shrink_rank(alphabet, right_alphabet_index)
+          end
+          rank_less = (left_rank < right_rank)
+          if rank_less
+            return negative_one
+          end
+          rank_greater = (left_rank > right_rank)
+          if rank_greater
+            return i1
+          end
+        end
+        pos = (pos + i1)
+      end
+      return i0
+    end
+
     def string_max_index(alphabet, min_size, max_size)
       i0 = 0
       i1 = 1
@@ -6176,64 +6460,102 @@ module Zizek
     def string_from_index(alphabet, min_size, max_size, index_raw)
       i0 = 0
       i1 = 1
+      i8 = 8
       u0 = 0
+      u1 = 1
+      u2 = 2
+      u4 = 4
+      u8 = 8
+      u255 = 255
       size = alphabet_size(alphabet)
       no_members = (size == u0)
       if no_members
         none = nil
         return none
       end
-      base = u64_to_bigint_le(size)
       remaining = signed_abs_le(index_raw)
+      remaining_n = remaining.bytesize
+      remaining_bits = (remaining_n * i8)
+      narrow = (remaining_bits <= min_size)
+      several = (size >= u2)
+      first_bucket = (narrow && several)
+      bucket = bigint_one()
+      build_bucket = (!first_bucket)
+      if build_bucket
+        scale = i0
+        loop do
+          done = (scale >= min_size)
+          if done
+            break
+          end
+          bucket = positive_mul_add_small_le(bucket, size, u0)
+          scale = (scale + i1)
+        end
+      end
       length = min_size
       loop do
         past_end = (length > max_size)
         if past_end
           break
         end
-        exponent = (length & MASK)
-        bucket = positive_pow_le(base, exponent)
         bucket_cmp = signed_compare_le(remaining, bucket)
         inside_bucket = (bucket_cmp < i0)
+        inside_bucket = (inside_bucket || first_bucket)
         if inside_bucket
-          out = String.new(encoding: Encoding::BINARY)
-          empty = (length == i0)
-          if empty
-            some_empty = out.dup
-            return some_empty
-          end
-          power = (length - i1)
-          power_u64 = (power & MASK)
-          divisor = positive_pow_le(base, power_u64)
+          ranks = String.new(encoding: Encoding::BINARY)
           pos = i0
           loop do
             done = (pos >= length)
             if done
               break
             end
-            digit = positive_div_le_nonzero(remaining, divisor)
-            digit_u64 = bigint_to_u64_le(digit)
-            digit_fits = !digit_u64.nil?
-            rank = u0
-            if digit_fits
-              rank = digit_u64
+            rank = positive_rem_small_le(remaining, size)
+            rank_byte = u0
+            loop do
+              packed_all = (rank_byte == u4)
+              if packed_all
+                break
+              end
+              rank_low = (rank & u255)
+              ranks << (rank_low & 0xff)
+              rank = (rank >> u8)
+              rank_byte = ((rank_byte + u1) & MASK)
+            end
+            remaining = positive_div_small_le(remaining, size)
+            pos = (pos + i1)
+          end
+          out = String.new(encoding: Encoding::BINARY)
+          pos = length
+          loop do
+            done = (pos == i0)
+            if done
+              break
             end
+            pos = (pos - i1)
+            rank = string_codepoint_at(ranks, pos)
             found = alphabet_shrink_codepoint(alphabet, rank)
             present = !found.nil?
             codepoint = u0
             if present
               codepoint = found
             end
-            packed_ = u32_to_le(codepoint)
-            out = append_bytes(out, packed_)
-            remaining = positive_rem_le_nonzero(remaining, divisor)
-            divisor = positive_div_le_nonzero(divisor, base)
-            pos = (pos + i1)
+            codepoint_byte = u0
+            loop do
+              packed_all = (codepoint_byte == u4)
+              if packed_all
+                break
+              end
+              codepoint_low = (codepoint & u255)
+              out << (codepoint_low & 0xff)
+              codepoint = (codepoint >> u8)
+              codepoint_byte = ((codepoint_byte + u1) & MASK)
+            end
           end
           some = out.dup
           return some
         end
         remaining = signed_sub_le(remaining, bucket)
+        bucket = positive_mul_add_small_le(bucket, size, u0)
         length = (length + i1)
       end
       none = nil

data/lib/zizek/shell.rb

@@ -1635,6 +1635,12 @@ module Zizek
 
           next
         end
+        order = string_draws_compare(candidate_draw, current_draw)
+        unless order.nil?
+          return order unless order.zero?
+
+          next
+        end
         candidate_index = draw_sort_index(candidate_draw)
         current_index = draw_sort_index(current_draw)
         return 1 if candidate_index.nil? || current_index.nil?
@@ -1645,6 +1651,22 @@ module Zizek
       0
     end
 
+    # Order two string draws of one alphabet and minimum size by index, nil
+    # for any other pair. The core compares them without building either
+    # index; a long string's index is too costly to build for every shrink
+    # candidate.
+    def string_draws_compare(candidate, current)
+      return nil unless candidate.kind == :string && current.kind == :string
+
+      characters, minimum, = candidate.params
+      return nil unless current.params[0] == characters && current.params[1] == minimum
+
+      Core.string_index_compare(
+        characters, minimum,
+        Shell.pack_codepoints(candidate.value), Shell.pack_codepoints(current.value)
+      )
+    end
+
     # Rebuild a draw at a schedule index, or report a miss.
     #
     # The rebuilt draw keeps its key: a lowered candidate that lost its name
@@ -1722,43 +1744,22 @@ module Zizek
       Core.choice_list_header(draws.length) + draws.map { |draw| Shell.entry(draw) }.join
     end
 
-    class ChoiceTree
+    # Every choice stream a run has executed, so a mutation that would only
+    # repeat one is skipped. Membership is of whole streams, never of
+    # prefixes: a trie with a node per byte answered the same questions while
+    # holding megabytes for each long example until the run ended. Streams are
+    # keyed as binary strings, so equal bytes are equal keys.
+    class StreamSet
       def initialize
-        @terminal = false
-        @children = {}
-      end
-
-      def include?(path)
-        node = self
-        path.each_byte do |byte|
-          node = node.child(byte)
-          return false if node.nil?
-        end
-        node.terminal?
-      end
-
-      def insert(path)
-        node = self
-        path.each_byte { |byte| node = node.child_or_insert(byte) }
-        node.mark_terminal
-      end
-
-      protected
-
-      def child(byte)
-        @children[byte]
-      end
-
-      def child_or_insert(byte)
-        @children[byte] ||= ChoiceTree.new
+        @streams = {}
       end
 
-      def terminal?
-        @terminal
+      def include?(stream)
+        @streams.key?(stream.b)
       end
 
-      def mark_terminal
-        @terminal = true
+      def insert(stream)
+        @streams[stream.b] = true
       end
     end
 
@@ -2593,7 +2594,7 @@ module Zizek
     # Consecutive executed mutation requests; the schedule caps it at one
     # brood so fresh random generation keeps its share of the run.
     mutation_streak = 0
-    choice_tree = Shell::ChoiceTree.new
+    seen_streams = Shell::StreamSet.new
     # Per-label best score and the stream that produced it, for the targeting
     # hill climber. The schedule, budgets, record and accept rules, stepping,
     # and the step-size search are all compiled (ir/targeting.zir); this loop
@@ -2655,7 +2656,7 @@ module Zizek
       else
         attempts += 1
         error, trial_case = Shell.execute(property, rng: rng, replay: stream)
-        choice_tree.insert(trial_case.__send__(:serialized))
+        seen_streams.insert(trial_case.__send__(:serialized))
         if error.nil?
           valid += 1
           record_targets.call(trial_case)
@@ -2811,9 +2812,9 @@ module Zizek
       simplest_probe = request == 1
       mutation_probe = request == 2
       mutation = mutation_probe ? pending_mutations.shift : nil
-      novelty = Core.generation_novelty_action(request, mutation_probe && choice_tree.include?(mutation))
+      novelty = Core.generation_novelty_action(request, mutation_probe && seen_streams.include?(mutation))
       next if novelty.zero?
-      choice_tree.insert(mutation) if novelty == 2
+      seen_streams.insert(mutation) if novelty == 2
       attempts += 1
       mutation_streak = mutation_probe ? mutation_streak + 1 : 0
       error, test_case = Shell.execute(
@@ -2822,7 +2823,7 @@ module Zizek
         replay: mutation,
         simplest: simplest_probe
       )
-      choice_tree.insert(test_case.__send__(:serialized))
+      seen_streams.insert(test_case.__send__(:serialized))
       generation_us = [((1 << 64) - 1), generation_us + test_case.__send__(:generation_us)].min
       outcome = Shell.classify(error)
       if Core.health_large_base_example(

data/lib/zizek/version.rb

@@ -4,5 +4,5 @@ module Zizek
   # The gemspec reads this file directly, so it must stay free of requires:
   # loading the rest of the package to learn the version would drag the
   # generated core into every `gem build`.
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: zizek
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
-- waldemar.quevedo@gmail.com
+- Waldemar Quevedo
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z