reformat files with black

Henrique Assumpção · Henrique Assumpção · commit 7f2733135285 · 2025-10-20T16:05:51.000-03:00
diff --git a/examples/alphaevolve_math_problems/circle_packing_rect/evaluator.py b/examples/alphaevolve_math_problems/circle_packing_rect/evaluator.py
@@ -103,12 +103,9 @@ def evaluate(program_path: str):
         radii_sum = np.sum(circles[:, -1])
 
         return {
-                "radii_sum": float(radii_sum),
-                "combined_score": float(radii_sum / BENCHMARK),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "radii_sum": float(radii_sum),
+            "combined_score": float(radii_sum / BENCHMARK),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/erdos_min_overlap/evaluator.py b/examples/alphaevolve_math_problems/erdos_min_overlap/evaluator.py
@@ -67,13 +67,10 @@ def evaluate(program_path: str):
         verify_c5_solution(h_values, c5_bound, n_points)
 
         return {
-                "c5_bound": float(c5_bound),
-                "combined_score": BENCHMARK / float(c5_bound),
-                "n_points": int(n_points),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "c5_bound": float(c5_bound),
+            "combined_score": BENCHMARK / float(c5_bound),
+            "n_points": int(n_points),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/first_autocorr_ineq/evaluator.py b/examples/alphaevolve_math_problems/first_autocorr_ineq/evaluator.py
@@ -76,16 +76,12 @@ def evaluate(program_path: str):
                 sys.path.remove(program_dir)
 
         verify_autocorrelation_solution(f_values, c1_achieved, n_points)
-        return  {
-                "c1": float(c1_achieved),
-                "combined_score": BENCHMARK / float(c1_achieved),
-                "loss": float(loss),
-                "n_points": int(n_points),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
         return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "c1": float(c1_achieved),
+            "combined_score": BENCHMARK / float(c1_achieved),
+            "loss": float(loss),
+            "n_points": int(n_points),
+            "eval_time": float(eval_time),
         }
-    
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/heilbronn_convex/13/evaluator.py b/examples/alphaevolve_math_problems/heilbronn_convex/13/evaluator.py
@@ -64,12 +64,9 @@ def evaluate(program_path: str):
         min_area_normalized = min_triangle_area / convex_hull_area
 
         return {
-                "min_area_normalized": float(min_area_normalized),
-                "combined_score": float(min_area_normalized / BENCHMARK),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "min_area_normalized": float(min_area_normalized),
+            "combined_score": float(min_area_normalized / BENCHMARK),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/heilbronn_convex/14/evaluator.py b/examples/alphaevolve_math_problems/heilbronn_convex/14/evaluator.py
@@ -63,12 +63,9 @@ def evaluate(program_path: str):
         min_area_normalized = min_triangle_area / convex_hull_area
 
         return {
-                "min_area_normalized": float(min_area_normalized),
-                "combined_score": float(min_area_normalized / BENCHMARK),
-                "eval_time": float(eval_time)
-                }
+            "min_area_normalized": float(min_area_normalized),
+            "combined_score": float(min_area_normalized / BENCHMARK),
+            "eval_time": float(eval_time),
+        }
     except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
-        }
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/heilbronn_triangle/evaluator.py b/examples/alphaevolve_math_problems/heilbronn_triangle/evaluator.py
@@ -84,12 +84,9 @@ def evaluate(program_path: str):
         min_area_normalized = min_triangle_area / triangle_area(a, b, c)
 
         return {
-                "min_area_normalized": float(min_area_normalized),
-                "combined_score": float(min_area_normalized / BENCHMARK),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "min_area_normalized": float(min_area_normalized),
+            "combined_score": float(min_area_normalized / BENCHMARK),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/hexagon_packing/11/evaluator.py b/examples/alphaevolve_math_problems/hexagon_packing/11/evaluator.py
@@ -175,9 +175,7 @@ def verify_construction(
     # Disjointness check.
     for i in range(len(inner_hex_params_list)):
         for j in range(i + 1, len(inner_hex_params_list)):
-            if not hexagons_are_disjoint(
-                inner_hex_params_list[i], inner_hex_params_list[j], tol
-            ):
+            if not hexagons_are_disjoint(inner_hex_params_list[i], inner_hex_params_list[j], tol):
                 raise AssertionError(f"Hexagons {i+1} and {j+1} intersect!")
     # Containment check.
     if not all_hexagons_contained(inner_hex_params_list, outer_hex_params, tol):
@@ -228,12 +226,9 @@ def evaluate(program_path: str):
         inv_outer_hex_side_length = float(1 / outer_hex_side_length)
 
         return {
-                "inv_outer_hex_side_length": inv_outer_hex_side_length,
-                "combined_score": float(inv_outer_hex_side_length / BENCHMARK),
-                "eval_time": float(eval_time)
-                }
+            "inv_outer_hex_side_length": inv_outer_hex_side_length,
+            "combined_score": float(inv_outer_hex_side_length / BENCHMARK),
+            "eval_time": float(eval_time),
+        }
     except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
-        }
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/hexagon_packing/12/evaluator.py b/examples/alphaevolve_math_problems/hexagon_packing/12/evaluator.py
@@ -175,9 +175,7 @@ def verify_construction(
     # Disjointness check.
     for i in range(len(inner_hex_params_list)):
         for j in range(i + 1, len(inner_hex_params_list)):
-            if not hexagons_are_disjoint(
-                inner_hex_params_list[i], inner_hex_params_list[j], tol
-            ):
+            if not hexagons_are_disjoint(inner_hex_params_list[i], inner_hex_params_list[j], tol):
                 raise AssertionError(f"Hexagons {i+1} and {j+1} intersect!")
     # Containment check.
     if not all_hexagons_contained(inner_hex_params_list, outer_hex_params, tol):
@@ -228,12 +226,9 @@ def evaluate(program_path: str):
         inv_outer_hex_side_length = float(1 / outer_hex_side_length)
 
         return {
-                "inv_outer_hex_side_length": inv_outer_hex_side_length,
-                "combined_score": float(inv_outer_hex_side_length / BENCHMARK),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "inv_outer_hex_side_length": inv_outer_hex_side_length,
+            "combined_score": float(inv_outer_hex_side_length / BENCHMARK),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/kissing_number/evaluator.py b/examples/alphaevolve_math_problems/kissing_number/evaluator.py
@@ -86,13 +86,10 @@ def evaluate(program_path: str):
 
         num_points = len(points)
         benchmark_ratio = num_points / BENCHMARK
-        return  {
-                "num_points": num_points,
-                "combined_score": float(benchmark_ratio),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
         return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "num_points": num_points,
+            "combined_score": float(benchmark_ratio),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/matmul/evaluator.py b/examples/alphaevolve_math_problems/matmul/evaluator.py
@@ -98,13 +98,10 @@ def evaluate(program_path: str):
         inverse_rank = BENCHMARK / rank
 
         return {
-                "combined_score": inverse_rank,
-                "loss": loss,
-                "rank": rank,
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "combined_score": inverse_rank,
+            "loss": loss,
+            "rank": rank,
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/matmul/initial_program.py b/examples/alphaevolve_math_problems/matmul/initial_program.py
@@ -96,9 +96,7 @@ def __init__(self, target_tensor: jnp.ndarray, hypers: Hyperparameters):
 
     def _loss_fn(self, continuous_decomposition: tuple) -> jnp.ndarray:
         # Snap the continuous parameters to the discrete grid
-        discrete_decomposition = jax.tree_util.tree_map(
-            round_to_half_ste, continuous_decomposition
-        )
+        discrete_decomposition = jax.tree_util.tree_map(round_to_half_ste, continuous_decomposition)
         # Compute the loss using only these exact half-integer values
         reconstructed = jnp.einsum("ir,jr,kr->ijk", *discrete_decomposition)
         return l2_loss_real(reconstructed, self.target_tensor)
diff --git a/examples/alphaevolve_math_problems/minimizing_max_min_dist/2/evaluator.py b/examples/alphaevolve_math_problems/minimizing_max_min_dist/2/evaluator.py
@@ -57,12 +57,9 @@ def evaluate(program_path: str):
 
         inv_ratio_squared = (min_distance / max_distance) ** 2 if max_distance > 0 else 0
         return {
-                "min_max_ratio": float(inv_ratio_squared),
-                "combined_score": float(inv_ratio_squared / BENCHMARK),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "min_max_ratio": float(inv_ratio_squared),
+            "combined_score": float(inv_ratio_squared / BENCHMARK),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/minimizing_max_min_dist/3/evaluator.py b/examples/alphaevolve_math_problems/minimizing_max_min_dist/3/evaluator.py
@@ -57,12 +57,9 @@ def evaluate(program_path: str):
 
         inv_ratio_squared = (min_distance / max_distance) ** 2 if max_distance > 0 else 0
         return {
-                "min_max_ratio": float(inv_ratio_squared),
-                "combined_score": float(inv_ratio_squared / BENCHMARK),
-                "eval_time": float(eval_time)
-                }
+            "min_max_ratio": float(inv_ratio_squared),
+            "combined_score": float(inv_ratio_squared / BENCHMARK),
+            "eval_time": float(eval_time),
+        }
     except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
-        }
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/second_autocorr_ineq/evaluator.py b/examples/alphaevolve_math_problems/second_autocorr_ineq/evaluator.py
@@ -77,14 +77,11 @@ def evaluate(program_path: str):
         c2_verified = verify_c2_solution(f_values, c2_achieved_from_opt, n_points)
 
         return {
-                "c2": float(c2_verified),
-                "combined_score": float(c2_verified) / BENCHMARK,
-                "loss": float(loss),
-                "n_points": int(n_points),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "c2": float(c2_verified),
+            "combined_score": float(c2_verified) / BENCHMARK,
+            "loss": float(loss),
+            "n_points": int(n_points),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/sums_diffs_finite_sets/evaluator.py b/examples/alphaevolve_math_problems/sums_diffs_finite_sets/evaluator.py
@@ -79,14 +79,11 @@ def evaluate(program_path: str):
         verify_c6_solution(u_set, c6_bound)
 
         return {
-                "c6_bound": float(c6_bound),
-                "combined_score": float(c6_bound) / BENCHMARK,
-                "set_size": len(u_set),
-                "max_val": int(np.max(u_set)),
-                "eval_time": float(eval_time),
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "c6_bound": float(c6_bound),
+            "combined_score": float(c6_bound) / BENCHMARK,
+            "set_size": len(u_set),
+            "max_val": int(np.max(u_set)),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/third_autocorr_ineq/evaluator.py b/examples/alphaevolve_math_problems/third_autocorr_ineq/evaluator.py
@@ -70,14 +70,11 @@ def evaluate(program_path: str):
         verify_c3_solution(f_values, c3_achieved, n_points)
 
         return {
-                "c3": float(c3_achieved),
-                "combined_score": BENCHMARK / float(c3_achieved),
-                "loss": float(loss),
-                "n_points": int(n_points),
-                "eval_time": float(eval_time)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "c3": float(c3_achieved),
+            "combined_score": BENCHMARK / float(c3_achieved),
+            "loss": float(loss),
+            "n_points": int(n_points),
+            "eval_time": float(eval_time),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
diff --git a/examples/alphaevolve_math_problems/uncertainty_ineq/evaluator.py b/examples/alphaevolve_math_problems/uncertainty_ineq/evaluator.py
@@ -93,9 +93,7 @@ def verify_c4_solution_strict(
         raise ValueError(f"C4 mismatch: reported {reported_c4:.12f}, recomputed {c4:.12f}")
 
     if not np.isclose(rmax, reported_rmax, rtol=rtol, atol=atol):
-        raise ValueError(
-            f"r_max mismatch: reported {reported_rmax:.12f}, recomputed {rmax:.12f}"
-        )
+        raise ValueError(f"r_max mismatch: reported {reported_rmax:.12f}, recomputed {rmax:.12f}")
 
     return c4, rmax
 
@@ -121,17 +119,14 @@ def evaluate(program_path: str):
         c4, rmax = verify_c4_solution_strict(coeffs, float(c4_bound), float(r_max))
 
         return {
-                "c4_bound": float(c4),
-                "combined_score": float(BENCHMARK / c4),
-                "r_max": float(rmax),
-                "coeffs": coeffs.tolist(),
-                "eval_time": float(t1 - t0)
-                }
-    except Exception as e:
-        return {
-            'combined_score': 0.0,
-            'error': str(e)
+            "c4_bound": float(c4),
+            "combined_score": float(BENCHMARK / c4),
+            "r_max": float(rmax),
+            "coeffs": coeffs.tolist(),
+            "eval_time": float(t1 - t0),
         }
+    except Exception as e:
+        return {"combined_score": 0.0, "error": str(e)}
 
 
 if __name__ == "__main__":
diff --git a/examples/alphaevolve_math_problems/uncertainty_ineq/initial_program.py b/examples/alphaevolve_math_problems/uncertainty_ineq/initial_program.py
@@ -168,8 +168,7 @@ def get_c4_from_params(params: np.ndarray, hypers: Hyperparameters):
 
     # Enforce P(0) = 0
     c0 = (
-        -(np.sum(c_others * H_vals_at_zero[1:-1]) + c_last * H_vals_at_zero[-1])
-        / H_vals_at_zero[0]
+        -(np.sum(c_others * H_vals_at_zero[1:-1]) + c_last * H_vals_at_zero[-1]) / H_vals_at_zero[0]
     )
     hermite_coeffs = np.concatenate([[c0], np.array(c_others), [c_last]])
 
