Listing: Listing

def proposed_tests():
    # Specifications only: no executed pass is asserted.
    model = LongitudinalNetwork(widths=(2, 2, 2), seed=7)
    ledger = ScarLedger(model)
    before = snapshot(model, ledger, "initial")

    # Exact floor zero deletion is an identity.
    removed = ledger.delete_fraction(0.0, permanent=True)
    assert all(k == 0 for k in removed.values())
    for name in ledger.masks:
        assert torch.equal(ledger.masks[name], before["masks"][name])
        assert torch.equal(ledger.scars[name], before["scars"][name])

    # Permanence and complete phase restoration.
    ledger.delete_fraction(0.5, permanent=True)
    model.a, model.g, model.p = 0.7, 0.85, 0.6
    model.activation, model.decay_rate = "tanh", 0.008
    saved = snapshot(model, ledger, "post_scar")
    clone, cloned_ledger, _ = restore(saved)
    assert clone.a == model.a and clone.p == model.p
    assert clone.activation == model.activation
    for name in ledger.scars:
        assert torch.equal(cloned_ledger.scars[name], ledger.scars[name])

    # Ordinary deletion leaves eligible coordinates for repair.
    ledger.delete_fraction(0.5, permanent=False)
    old_scars = {n: s.clone() for n, s in ledger.scars.items()}
    scores = {
        n: torch.ones_like(model.get_parameter(n)) for n in ledger.masks
    }
    ledger.regrow(1.0, scores, 0.03, seed=0)
    for name in ledger.masks:
        assert not bool((ledger.masks[name] & ledger.scars[name]).any())
        assert torch.equal(ledger.scars[name], old_scars[name])

    # Reset reproduces the source's gain identity and preserves protection.
    model.reset_transient_controls()
    assert model.a == 1.0 and model.g == 1.0
    assert model.activation == "relu" and model.p == 0.6
    assert model.effective_gain() == 1.0

    # Protection decrements: compare with numerical tolerance.
    for d, expected in ((0.002, 0.9), (0.015, 0.25), (0.008, 0.6)):
        model.p, model.decay_rate = 1.0, d
        for _ in range(50):
            model.decay_protection()
        assert math.isclose(model.p, expected, abs_tol=1e-12)

    # Minimum-one is a different operation at fraction zero.
    other = LongitudinalNetwork(widths=(2, 2, 2), seed=7)
    other_ledger = ScarLedger(other)
    counts = other_ledger.delete_fraction(
        0.0, permanent=True, minimum_one=True
    )
    assert all(k == 1 for k in counts.values())

    # Random scarring accepts equality of request and availability.
    full = LongitudinalNetwork(widths=(2, 2, 2), seed=7)
    full_ledger = ScarLedger(full)
    full_ledger.initial_scars(1.0, placement_seed=0)
    assert full_ledger.counts()["active"] == 0
    assert full_ledger.counts()["scar_density"] == 1.0

    # A no-eligible repair is an identity.
    scores = {
        n: torch.zeros_like(full.get_parameter(n))
        for n in full_ledger.masks
    }
    result = full_ledger.regrow(1.0, scores, 0.03, seed=0)
    assert all(k == 0 for k in result.values())