benchflow/frontierphysics-pr152-evidence · Datasets at Hugging Face

text stringlengths 0 2.43k
public_branch = [{'bvp_max_rms_residual': '1.960864989517349e-07', 'bvp_mesh_nodes': '629', 'central_amplitude': '0.18', 'chemical_pot...836e-07', 'bvp_mesh_nodes': '708', 'central_amplitude': '0.52', 'chemical_potential': '-0.9196231268316274', ...}, ...]

def test_public_profiles_independent(public_instance: dict[str, Any], public_branch: list[dict[str, str]]) -> None:
> evidence = validate_profiles(RESULTS, public_instance, public_branch)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

/verifier/test_outputs.py:920:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

result_path = PosixPath('/root/results')
instance = {'boundary_value': {'initial_mesh_points': 560, 'max_nodes': 36000, 'origin_fraction': 2.5e-06, 'tolerance': 2e-07}, '..., 'profile_anchor_count': 2, 'refined_tolerance_factor': 0.35}, 'domain': {'profile_points': 801, 'radius': 40.0}, ...}
branch_rows = [{'bvp_max_rms_residual': '1.960864989517349e-07', 'bvp_mesh_nodes': '629', 'central_amplitude': '0.18', 'chemical_pot...836e-07', 'bvp_mesh_nodes': '708', 'central_amplitude': '0.52', 'chemical_potential': '-0.9196231268316274', ...}, ...]

def validate_profiles(result_path: Path, instance: dict[str, Any], branch_rows: list[dict[str, str]]) -> list[dict[str, Any]]:
index = load_json(result_path / "profile_index.json")
assert index["schema_version"] == RESULT_SCHEMA
expected_inventory = expected_state_inventory(instance)
observed_inventory = [
(
entry["family_id"],
int(entry["node_count"]),
int(entry["state_index"]),
round(float(entry["central_amplitude"]), 12),
)
for entry in index["profiles"]
]
assert observed_inventory == expected_inventory
radius = float(instance["domain"]["radius"])
points = int(instance["domain"]["profile_points"])
beta = float(instance["model"]["beta"])
evidence = []
with np.load(result_path / "profiles.npz", allow_pickle=False) as arrays:
expected_array_keys = {array_key for entry in index["profiles"] for array_key in entry["keys"].values()}
assert len(expected_array_keys) == len(index["profiles"]) * 5
assert set(arrays.files) == expected_array_keys
for entry in index["profiles"]:
family_id = entry["family_id"]
amplitude = float(entry["central_amplitude"])
row = row_for_state(branch_rows, family_id, amplitude)
keys = entry["keys"]
assert set(keys) == {"r", "psi", "dpsi", "phi", "enclosed_mass"}
values = {name: np.asarray(arrays[keys[name]], dtype=float) for name in keys}
assert all(array.ndim == 1 and array.size == points for array in values.values())
assert all(np.all(np.isfinite(array)) for array in values.values())
radial = values["r"]
assert np.max(np.abs(radial - np.linspace(0.0, radius, points))) < 1e-12
assert abs(values["psi"][0] - amplitude) < 2e-5
assert abs(values["dpsi"][0]) < 1e-12
assert abs(values["psi"][-1]) < 2e-7
assert count_nodes(values["psi"]) == int(entry["node_count"]) == int(row["node_count"])
assert np.all(np.diff(values["enclosed_mass"]) >= -1e-8)
finite_difference_derivative = np.gradient(values["psi"], radial, edge_order=2)
derivative_interior = slice(2, -2)
derivative_difference = values["dpsi"][derivative_interior] - finite_difference_derivative[derivative_interior]
derivative_relative_l2 = float(
np.linalg.norm(derivative_difference) / (np.linalg.norm(finite_difference_derivative[derivative_interior]) + 1e-14)
)
derivative_relative_linf = float(
np.max(np.abs(derivative_difference)) / (np.max(np.abs(finite_difference_derivative[derivative_interior])) + 1e-14)
)
assert derivative_relative_l2 < 0.04
assert derivative_relative_linf < 0.07
enclosed_direct = cumulative_trapezoid(4.0 * math.pi * radial*2 values["psi"] ** 2, radial, initial=0.0)
enclosed_relative_linf = float(
np.max(np.abs(values["enclosed_mass"] - enclosed_direct)) / max(1e-12, float(np.max(np.abs(enclosed_direct))))
)
assert abs(values["enclosed_mass"][0]) < 1e-10
assert enclosed_relative_linf < 8e-4
metrics = independent_profile_metrics(
radial,
values["psi"],
values["dpsi"],
values["phi"],
beta,
float(row["chemical_potential"]),
)
assert abs(metrics["mass"] - float(row["mass"])) < 3e-4 * max(1.0, metrics["mass"])
assert abs(metrics["kinetic"] - float(row["kinetic_energy"])) < 5e-4 * max(1.0, abs(metrics["kinetic"]))
assert abs(metrics["contact"] - float(row["contact_energy"])) < 8e-4 * max(1.0, abs(metrics["contact"]))
assert abs(metrics["gravitational"] - float(row["gravitational_energy"])) < 8e-4 * max(1.0, abs(metrics["gravitational"]))
assert metrics["stationary_residual"] < 7e-4
assert metrics["virial_residual"] < 7e-4
assert metrics["potential_error"] < 0.012
assert metrics["equation_relative_l2"] < 0.02
assert abs(metrics["stationary_residual"] - float(row["stationary_identity_residual"])) < 5e-6
assert abs(metrics["virial_residual"] - float(row["virial_residual"])) < 5e-6
> assert abs(metrics["potential_error"] - float(row["green_potential_residual"])) < 5e-6
E AssertionError: assert 5.6479141830128275e-06 < 5e-06
E + where 5.6479141830128275e-06 = abs((0.0023793597042204603 - 0.0023737117900374475))
E + where 0.0023737117900374475 = float('0.0023737117900374475')

/verifier/test_outputs.py:240: AssertionError
_________________ test_public_spectrum_turning_and_convergence _________________

public_instance = {'boundary_value': {'initial_mesh_points': 560, 'max_nodes': 36000, 'origin_fraction': 2.5e-06, 'tolerance': 2e-07}, '..., 'profile_anchor_count': 2, 'refined_tolerance_factor': 0.35}, 'domain': {'profile_points': 801, 'radius': 40.0}, ...}
public_branch = [{'bvp_max_rms_residual': '1.960864989517349e-07', 'bvp_mesh_nodes': '629', 'central_amplitude': '0.18', 'chemical_pot...836e-07', 'bvp_mesh_nodes': '708', 'central_amplitude': '0.52', 'chemical_potential': '-0.9196231268316274', ...}, ...]
public_spectrum = [{'basis_size': '64', 'central_amplitude': '0.18', 'family_id': 'ground', 'growth_rate': '0.0', ...}, {'basis_size': '...: '0.0', ...}, {'basis_size': '80', 'central_amplitude': '0.4', 'family_id': 'ground', 'growth_rate': '0.0', ...}, ...]

def test_public_spectrum_turning_and_convergence(
public_instance: dict[str, Any],

public_branch = [{'bvp_max_rms_residual': '1.960864989517349e-07', 'bvp_mesh_nodes': '629', 'central_amplitude': '0.18', 'chemical_pot...836e-07', 'bvp_mesh_nodes': '708', 'central_amplitude': '0.52', 'chemical_potential': '-0.9196231268316274', ...}, ...]

def test_public_profiles_independent(public_instance: dict[str, Any], public_branch: list[dict[str, str]]) -> None:

> evidence = validate_profiles(RESULTS, public_instance, public_branch)

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

/verifier/test_outputs.py:920:

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

result_path = PosixPath('/root/results')

instance = {'boundary_value': {'initial_mesh_points': 560, 'max_nodes': 36000, 'origin_fraction': 2.5e-06, 'tolerance': 2e-07}, '..., 'profile_anchor_count': 2, 'refined_tolerance_factor': 0.35}, 'domain': {'profile_points': 801, 'radius': 40.0}, ...}

branch_rows = [{'bvp_max_rms_residual': '1.960864989517349e-07', 'bvp_mesh_nodes': '629', 'central_amplitude': '0.18', 'chemical_pot...836e-07', 'bvp_mesh_nodes': '708', 'central_amplitude': '0.52', 'chemical_potential': '-0.9196231268316274', ...}, ...]

def validate_profiles(result_path: Path, instance: dict[str, Any], branch_rows: list[dict[str, str]]) -> list[dict[str, Any]]:

index = load_json(result_path / "profile_index.json")

assert index["schema_version"] == RESULT_SCHEMA

expected_inventory = expected_state_inventory(instance)

observed_inventory = [

(

entry["family_id"],

int(entry["node_count"]),

int(entry["state_index"]),

round(float(entry["central_amplitude"]), 12),

)

for entry in index["profiles"]

]

assert observed_inventory == expected_inventory

radius = float(instance["domain"]["radius"])

points = int(instance["domain"]["profile_points"])

beta = float(instance["model"]["beta"])

evidence = []

with np.load(result_path / "profiles.npz", allow_pickle=False) as arrays:

expected_array_keys = {array_key for entry in index["profiles"] for array_key in entry["keys"].values()}

assert len(expected_array_keys) == len(index["profiles"]) * 5

assert set(arrays.files) == expected_array_keys

for entry in index["profiles"]:

family_id = entry["family_id"]

amplitude = float(entry["central_amplitude"])

row = row_for_state(branch_rows, family_id, amplitude)

keys = entry["keys"]

assert set(keys) == {"r", "psi", "dpsi", "phi", "enclosed_mass"}

values = {name: np.asarray(arrays[keys[name]], dtype=float) for name in keys}

assert all(array.ndim == 1 and array.size == points for array in values.values())

assert all(np.all(np.isfinite(array)) for array in values.values())

radial = values["r"]

assert np.max(np.abs(radial - np.linspace(0.0, radius, points))) < 1e-12

assert abs(values["psi"][0] - amplitude) < 2e-5

assert abs(values["dpsi"][0]) < 1e-12

assert abs(values["psi"][-1]) < 2e-7

assert count_nodes(values["psi"]) == int(entry["node_count"]) == int(row["node_count"])

assert np.all(np.diff(values["enclosed_mass"]) >= -1e-8)

finite_difference_derivative = np.gradient(values["psi"], radial, edge_order=2)

derivative_interior = slice(2, -2)

derivative_difference = values["dpsi"][derivative_interior] - finite_difference_derivative[derivative_interior]

derivative_relative_l2 = float(

np.linalg.norm(derivative_difference) / (np.linalg.norm(finite_difference_derivative[derivative_interior]) + 1e-14)

)

derivative_relative_linf = float(

np.max(np.abs(derivative_difference)) / (np.max(np.abs(finite_difference_derivative[derivative_interior])) + 1e-14)

)

assert derivative_relative_l2 < 0.04

assert derivative_relative_linf < 0.07

enclosed_direct = cumulative_trapezoid(4.0 * math.pi * radial**2 * values["psi"] ** 2, radial, initial=0.0)

enclosed_relative_linf = float(

np.max(np.abs(values["enclosed_mass"] - enclosed_direct)) / max(1e-12, float(np.max(np.abs(enclosed_direct))))

)

assert abs(values["enclosed_mass"][0]) < 1e-10

assert enclosed_relative_linf < 8e-4

metrics = independent_profile_metrics(

radial,

values["psi"],

values["dpsi"],

values["phi"],

beta,

float(row["chemical_potential"]),

)

assert abs(metrics["mass"] - float(row["mass"])) < 3e-4 * max(1.0, metrics["mass"])

assert abs(metrics["kinetic"] - float(row["kinetic_energy"])) < 5e-4 * max(1.0, abs(metrics["kinetic"]))

assert abs(metrics["contact"] - float(row["contact_energy"])) < 8e-4 * max(1.0, abs(metrics["contact"]))

assert abs(metrics["gravitational"] - float(row["gravitational_energy"])) < 8e-4 * max(1.0, abs(metrics["gravitational"]))

assert metrics["stationary_residual"] < 7e-4

assert metrics["virial_residual"] < 7e-4

assert metrics["potential_error"] < 0.012

assert metrics["equation_relative_l2"] < 0.02

assert abs(metrics["stationary_residual"] - float(row["stationary_identity_residual"])) < 5e-6

assert abs(metrics["virial_residual"] - float(row["virial_residual"])) < 5e-6

> assert abs(metrics["potential_error"] - float(row["green_potential_residual"])) < 5e-6

E AssertionError: assert 5.6479141830128275e-06 < 5e-06

E + where 5.6479141830128275e-06 = abs((0.0023793597042204603 - 0.0023737117900374475))

E + where 0.0023737117900374475 = float('0.0023737117900374475')

/verifier/test_outputs.py:240: AssertionError

_________________ test_public_spectrum_turning_and_convergence _________________

public_instance = {'boundary_value': {'initial_mesh_points': 560, 'max_nodes': 36000, 'origin_fraction': 2.5e-06, 'tolerance': 2e-07}, '..., 'profile_anchor_count': 2, 'refined_tolerance_factor': 0.35}, 'domain': {'profile_points': 801, 'radius': 40.0}, ...}

public_branch = [{'bvp_max_rms_residual': '1.960864989517349e-07', 'bvp_mesh_nodes': '629', 'central_amplitude': '0.18', 'chemical_pot...836e-07', 'bvp_mesh_nodes': '708', 'central_amplitude': '0.52', 'chemical_potential': '-0.9196231268316274', ...}, ...]

public_spectrum = [{'basis_size': '64', 'central_amplitude': '0.18', 'family_id': 'ground', 'growth_rate': '0.0', ...}, {'basis_size': '...: '0.0', ...}, {'basis_size': '80', 'central_amplitude': '0.4', 'family_id': 'ground', 'growth_rate': '0.0', ...}, ...]

def test_public_spectrum_turning_and_convergence(

public_instance: dict[str, Any],