10. All at once vs one at a time — the update scheme changes the answer · Dr. Seok's Cancer-Cell Digital Twin, First Steps

In lesson 3 we agreed to update every gene at the same instant. It makes the computation easy and the results reproducible.

But does a real cell have such a clock? It does not. Transcription time, translation time and protein degradation time all differ from gene to gene.

So there is an alternative — asynchronous update. At each step you pick one gene at random and update only that one.

	Synchronous	Asynchronous
Update	All together	One at a time, at random
Result	Same start → same ending	Same start → several possible endings
Long oscillations	Show up often	Usually disappear
Computation	Exhaustive enumeration possible	Requires many sampled runs

Here is what matters — a good share of the long oscillations that come out of synchronous update are artefacts of the model. Fixed points generally survive; cycles are sensitive to the update scheme.

The oscillation that was so tidy under synchronous update scatters under asynchronous.

Python Runs in your browser

import bn, random

net = bn.twin()
start = net.state(p53=1)

def async_run(net, state, n=300, seed=0):
    """At each step pick one gene at random and update only that one."""
    rng = random.Random(seed)
    cur = tuple(state)
    for _ in range(n):
        g = rng.randrange(net.n)                 # the one gene to update
        nxt = net.step(cur)
        cur = cur[:g] + (nxt[g],) + cur[g + 1:]  # swap in that position only
    return cur

print("synchronous - a period-4 oscillation (the same four states forever)")
for s in net.attractor(start):
    print("   ", ", ".join(net.on_genes(s)) or "(all OFF)")

print()
print("asynchronous - where are we after 300 steps, varying the seed")
for seed in range(6):
    end = async_run(net, start, 300, seed)
    print(f"   seed={seed}  ON: {', '.join(net.on_genes(end)) or '(all OFF)'}")

This result matters. The cancer fixed point we base our search for targets on is not an artefact.

Python Runs in your browser

import bn, random

net = bn.twin()
cancer = net.state(DDX54=1, MDM2=1, CD47=1, PDL1=1, Proliferation=1)

def async_run(net, state, n=300, seed=0):
    rng = random.Random(seed)
    cur = tuple(state)
    for _ in range(n):
        g = rng.randrange(net.n)
        nxt = net.step(cur)
        cur = cur[:g] + (nxt[g],) + cur[g + 1:]
    return cur

# Does the cancer fixed point hold up under asynchronous update too?
same = sum(1 for seed in range(200)
           if async_run(net, cancer, 300, seed) == cancer)
print(f"start at the cancer fixed point, 300 asynchronous steps: stayed put {same}/200 times")
print()
print("A fixed point is unmoved by the update scheme.")
print("Whichever gene you pick to update, the value stays the same -")
print("that is precisely what 'fixed point' means.")

🎮 Update-scheme bench

Roll the same starting point synchronously and asynchronously and compare.

Press it several times. Only the asynchronous side changes its answer.

Loading…

🤔 Check yourself

What happens if you run the same initial state twice under asynchronous update?

🤔 Check yourself

Which synchronous result is most sensitive to the update scheme?

🤔 Check yourself

What does it mean that the cancer fixed point survives asynchronous update?