⚡ Bolt: [performance improvement] Lazy default evaluation for dictionaries

src/geometry/hull_kv.py

@@ -205,10 +205,10 @@ def _rebuild_if_needed(self) -> None:
         total_value_sum = [Fraction(0) for _ in range(self._value_width or 0)]
 
         for index, (key, value) in enumerate(self._entries):
-            bucket = aggregates.setdefault(
-                key,
-                {"value_sum": [Fraction(0) for _ in value], "count": 0, "entry_indices": []},
-            )
+            # Performance optimization: explicit check to avoid eager evaluation of the complex default
+            if key not in aggregates:
+                aggregates[key] = {"value_sum": [Fraction(0) for _ in value], "count": 0, "entry_indices": []}
+            bucket = aggregates[key]
             for coord_index, coord in enumerate(value):
                 bucket["value_sum"][coord_index] += coord
                 total_value_sum[coord_index] += coord

src/model/free_running_executor.py

@@ -697,14 +697,16 @@ def evaluate_free_running_programs(
 
         outcomes.append(outcome)
         bucket = bucket_name(outcome.program_steps)
-        bucket_state = per_bucket.setdefault(
-            bucket,
-            {
+
+        # Performance optimization: explicit check to avoid eager evaluation of the complex default
+        if bucket not in per_bucket:
+            per_bucket[bucket] = {
                 "program_count": 0,
                 "exact_trace_count": 0,
                 "exact_final_state_count": 0,
-            },
-        )
+            }
+        bucket_state = per_bucket[bucket]
+
         bucket_state["program_count"] += 1
         bucket_state["exact_trace_count"] += int(outcome.exact_trace_match)
         bucket_state["exact_final_state_count"] += int(outcome.exact_final_state_match)

src/model/induced_causal.py

@@ -455,7 +455,9 @@ def fit_transition_library(
     examples = build_transition_examples(programs, interpreter=interpreter)
     by_opcode: dict[Opcode, list[TransitionExample]] = {}
     for example in examples:
-        by_opcode.setdefault(example.opcode, []).append(example)
+        if example.opcode not in by_opcode:
+            by_opcode[example.opcode] = []
+        by_opcode[example.opcode].append(example)
 
     rules = tuple(_fit_rule_for_opcode(by_opcode[opcode], opcode) for opcode in sorted(by_opcode, key=str))
     return InducedTransitionLibrary(rules=rules)

src/model/softmax_baseline.py

@@ -582,15 +582,17 @@ def evaluate_teacher_forced_model(
                 total_correct += correct
 
                 bucket = baseline_bucket_name(example.program_steps)
-                bucket_state = per_bucket.setdefault(
-                    bucket,
-                    {
+
+                # Performance optimization: explicit check to avoid eager evaluation
+                if bucket not in per_bucket:
+                    per_bucket[bucket] = {
                         "example_count": 0,
                         "token_count": 0,
                         "correct_tokens": 0,
                         "weighted_loss": 0.0,
-                    },
-                )
+                    }
+                bucket_state = per_bucket[bucket]
+
                 bucket_state["example_count"] = int(bucket_state["example_count"]) + 1
                 bucket_state["token_count"] = int(bucket_state["token_count"]) + token_count
                 bucket_state["correct_tokens"] = int(bucket_state["correct_tokens"]) + correct
@@ -753,7 +755,10 @@ def evaluate_free_running_rollout(
             )
 
             bucket = baseline_bucket_name(example.program_steps)
-            bucket_state = per_bucket.setdefault(bucket, {"example_count": 0, "exact_count": 0})
+            # Performance optimization: explicit check to avoid eager evaluation
+            if bucket not in per_bucket:
+                per_bucket[bucket] = {"example_count": 0, "exact_count": 0}
+            bucket_state = per_bucket[bucket]
             bucket_state["example_count"] = int(bucket_state["example_count"]) + 1
             bucket_state["exact_count"] = int(bucket_state["exact_count"]) + int(exact)
 

src/model/trainable_latest_write.py

@@ -171,7 +171,9 @@ def exact_program_accuracy(scorer: TrainableLatestWriteScorer, samples: Sequence
         return 0.0
     per_program: dict[str, list[bool]] = {}
     for sample in samples:
-        per_program.setdefault(sample.program_name, []).append(scorer.predict_index(sample) == sample.target_index)
+        if sample.program_name not in per_program:
+            per_program[sample.program_name] = []
+        per_program[sample.program_name].append(scorer.predict_index(sample) == sample.target_index)
     exact = sum(1 for outcomes in per_program.values() if all(outcomes))
     return exact / len(per_program)
 
@@ -198,12 +200,19 @@ def evaluate_scorer(
         correct_samples += int(correct)
 
         bucket = bucket_name(sample.program_steps)
-        bucket_state = per_bucket.setdefault(bucket, {"sample_count": 0, "sample_correct": 0, "programs": {}})
+        if bucket not in per_bucket:
+            per_bucket[bucket] = {"sample_count": 0, "sample_correct": 0, "programs": {}}
+        bucket_state = per_bucket[bucket]
         bucket_state["sample_count"] = int(bucket_state["sample_count"]) + 1
         bucket_state["sample_correct"] = int(bucket_state["sample_correct"]) + int(correct)
-        bucket_state["programs"].setdefault(sample.program_name, []).append(correct)
 
-        per_program.setdefault(sample.program_name, []).append(correct)
+        if sample.program_name not in bucket_state["programs"]:
+            bucket_state["programs"][sample.program_name] = []
+        bucket_state["programs"][sample.program_name].append(correct)
+
+        if sample.program_name not in per_program:
+            per_program[sample.program_name] = []
+        per_program[sample.program_name].append(correct)
         program_steps[sample.program_name] = sample.program_steps
 
     exact_programs = sum(1 for outcomes in per_program.values() if all(outcomes))