Each of the 120 nodes represents a body that can contain some amount of heat. Reproduces the plot at the top of
Wolfram's NKS, page 163.
See: https://www.wolframscience.com/nks/p163--partial-differential-equations/
See: http://hplgit.github.io/num-methods-for-PDEs/doc/pub/diffu/sphinx/._main_diffu001.html
"""
space = np.linspace(25, -25, 120)
initial_conditions = [np.exp(-x**2) for x in space]
adjacency_matrix = ntm.network.cellular_automaton(120)
a = 0.25
dt = .5
dx = .5
F = a * dt / dx**2
def activity_rule(ctx):
current = ctx.current_activity
left = ctx.activities[0]
right = ctx.activities[2]
return current + F * (right - 2 * current + left)
activities, _ = ntm.evolve(initial_conditions,
adjacency_matrix,
activity_rule,
timesteps=75)
ntm.plot_grid(activities)
HEAD['q6']: {
CELL[' ']: [HEAD['q6'], CELL[' '], TuringMachine.STAY],
CELL['a']: [HEAD['q6'], CELL['a'], TuringMachine.STAY],
CELL['b']: [HEAD['q6'], CELL['b'], TuringMachine.STAY],
CELL['c']: [HEAD['q6'], CELL['c'], TuringMachine.STAY],
CELL['x']: [HEAD['q6'], CELL['x'], TuringMachine.STAY],
CELL['y']: [HEAD['q6'], CELL['y'], TuringMachine.STAY],
CELL['z']: [HEAD['q6'], CELL['z'], TuringMachine.STAY]
}
}
tape = " aabbcc "
tm = HeadCentricTuringMachine(tape=[CELL[t] for t in tape],
rule_table=rule_table,
initial_head_state=HEAD['q0'],
initial_head_position=2,
terminating_state=HEAD['q6'],
max_timesteps=50)
activities, _ = ntm.evolve(tm.initial_conditions,
tm.adjacency_matrix,
activity_rule=tm.activity_rule,
input=tm.input_function)
tape_history, head_activities = tm.activities_for_plotting(activities)
ntm.plot_grid(tape_history,
node_annotations=head_activities,
show_grid=True)
0, 0, 1, 1]
initial_conditions = [1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1,
1, 1, 1, 0, 1, 1, 1]
r = ntm.ReversibleRule(lambda ctx: ntm.rules.nks_ca_rule(ctx, 122))
activities, _ = ntm.evolve(initial_conditions, adjacency_matrix, timesteps=1002, activity_rule=r.activity_rule,
past_conditions=[previous_state])
timestep = []
average_node_entropies = []
for i, c in enumerate(activities):
timestep.append(i)
bit_string = ''.join([str(x) for x in c])
average_node_entropies.append(ntm.average_node_entropy(activities[:i+1]))
print("%s, %s" % (i, average_node_entropies[-1]))
plt.subplot(3, 1, (1, 2))
plt.title("Avg. Node (Shannon) Entropy")
plt.gca().set_xlim(0, 1002)
plt.gca().axes.xaxis.set_ticks([])
plt.plot(timestep, average_node_entropies)
plt.subplot(3, 1, 3)
plt.gca().axes.yaxis.set_ticks([])
ntm.plot_grid(np.array(activities).T.tolist())
HEAD = {"up": 1, "down": 2}
CELL = {"on": 1, "off": 0}
rule_table = {
HEAD['up']: {
CELL['on']: [HEAD['up'], CELL['off'], TuringMachine.RIGHT],
CELL['off']: [HEAD['down'], CELL['on'], TuringMachine.RIGHT]
},
HEAD['down']: {
CELL['on']: [HEAD['up'], CELL['on'], TuringMachine.LEFT],
CELL['off']: [HEAD['down'], CELL['on'], TuringMachine.LEFT]
}
}
tm = TapeCentricTuringMachine(n=21,
rule_table=rule_table,
initial_head_state=HEAD['up'],
initial_head_position=3)
initial_conditions = [0] * 21
activities, _ = ntm.evolve(initial_conditions,
tm.adjacency_matrix,
activity_rule=tm.activity_rule,
timesteps=61)
ntm.plot_grid(activities,
node_annotations=tm.head_activities(activities),
show_grid=True)
import netomaton as ntm
if __name__ == '__main__':
adjacency_matrix = ntm.network.cellular_automaton2d(rows=60,
cols=60,
r=1,
neighbourhood='Moore')
initial_conditions = ntm.init_simple2d(60, 60)
activities, _ = ntm.evolve(
initial_conditions,
adjacency_matrix,
timesteps=30,
activity_rule=lambda ctx: ntm.rules.totalistic_ca(ctx, k=2, rule=126))
ntm.plot_grid(activities, shape=(60, 60))
import netomaton as ntm
if __name__ == '__main__':
adjacency_matrix = ntm.network.cellular_automaton(n=21)
# implements the rule 60 sequential automaton from the NKS Notes on
# Chapter 9, section 10: "Sequential cellular automata"
# http://www.wolframscience.com/nks/notes-9-10--sequential-cellular-automata/
initial_conditions = [0] * 10 + [1] + [0] * 10
r = ntm.AsynchronousRule(
activity_rule=lambda ctx: ntm.rules.nks_ca_rule(ctx, 60),
update_order=range(1, 20))
activities, adjacencies = ntm.evolve(initial_conditions,
adjacency_matrix,
timesteps=19 * 20,
activity_rule=r.activity_rule)
# plot every 19th row, including the first, as a cycle is completed every 19 rows
ntm.plot_grid(activities[::19])
