為了驗證「自由之道」是否可以在人工系統中體現，我們設計了一個名為 LogosTuringMachine3D 的模擬程式。
這是一個多頭、開放能量、不斷演化的宇宙，具有記憶和動態熵變。每個意識不僅可以分裂、融合和糾纏，而且隨著自我水平的提高，還可以引發「覺醒的笑聲」。
這不僅是一個程式的邏輯，也是一個哲學實驗。
觀看 <自由之道 - 模擬結果>
Python程式如下（需要安裝plotly）：
import random
import math
import statistics
import plotly.graph_objects as go
# 固定種子，確保可重現
random.seed(42)
class LogosTuringMachine3D:
def __init__(self, max_steps=30000):
self.grid = {}
self.blank = '1'
self.grid[(0, 0, 0)] = '1'
self.heads = [[0, 0, 0]]
self.states = ['fold']
self.break_counts = [0]
self.coherence_levels = [5]
self.breath_hold_steps_list = [0]
self.steps = 0
self.max_steps = max_steps #30000
self.self_level = 0
self.base_reproduce_prob = 0.06
self.base_forget_prob = 0.007
self.base_death_prob = 0.012
self.base_interaction_prob = 0.05
self.base_mutation_prob = 0.025
self.base_entanglement_prob = 0.028
self.energy = 1.0
self.reverse_entropy_events = 0
self.inter_head_entanglements = 0
self.pending_entropy_checks = [None]
# 每個頭的記憶軌跡
self.head_memory = [[] for _ in range(len(self.heads))]
def get_symbol(self, pos):
return self.grid.get(tuple(pos), self.blank)
def set_symbol(self, pos, sym):
tpos = tuple(pos)
if sym == self.blank:
self.grid.pop(tpos, None)
else:
self.grid[tpos] = sym
def calculate_entropy(self):
if not self.grid:
return 0.0
total = len(self.grid)
c0 = sum(1 for s in self.grid.values() if s == '0')
c1 = total - c0
p0 = c0 / total
p1 = c1 / total
if p0 == 0 or p1 == 0:
return 0.0
return -(p0 * math.log2(p0) + p1 * math.log2(p1))
def calculate_local_entropy(self, center, radius=3):
c0 = c1 = total = 0
cx, cy, cz = center
for dx in range(-radius, radius + 1):
for dy in range(-radius, radius + 1):
for dz in range(-radius, radius + 1):
sym = self.get_symbol((cx+dx, cy+dy, cz+dz))
if sym == '0': c0 += 1
else: c1 += 1
total += 1
if total == 0: return 0.0
p0 = c0 / total
p1 = c1 / total
if p0 == 0 or p1 == 0: return 0.0
return -(p0 * math.log2(p0) + p1 * math.log2(p1))
def get_energy_factor(self):
e = self.energy
if e < 400:
return "low"
elif e > 800:
return "high"
else:
return "normal"
def transition(self, head_idx, symbol):
write = symbol
direction = [0, 0, 0]
new_state = self.states[head_idx]
observer_threshold = 11
if self.get_energy_factor() == "low":
observer_threshold = 8
elif self.get_energy_factor() == "high":
observer_threshold = 14
if self.states[head_idx] == 'fold' and symbol == '1':
write = '1'; direction = [1,0,0]; new_state = 'break'
elif self.states[head_idx] == 'break' and symbol == '1':
write = '0'; direction = [1,0,0]; new_state = 'break'
self.break_counts[head_idx] += 1
if self.break_counts[head_idx] >= 4:
new_state = 'fuse'; self.break_counts[head_idx] = 0
elif self.states[head_idx] == 'fuse' and symbol == '1':
write = '1'; direction = [0,1,0]; new_state = 'refold'
elif self.states[head_idx] == 'refold':
self.coherence_levels[head_idx] += 1
direction = [-1,0,0]
if self.coherence_levels[head_idx] >= observer_threshold:
new_state = 'observer'
self.coherence_levels[head_idx] = 0
elif self.states[head_idx] == 'observer':
entropy_before = self.calculate_entropy()
if random.random() > 0.35:
write = '0' if symbol == '1' else '1'
new_state = 'hold_breath'
self.self_level += 1
self.breath_hold_steps_list[head_idx] = 4
self.pending_entropy_checks[head_idx] = entropy_before
elif self.states[head_idx] == 'hold_breath':
write = symbol
self.coherence_levels[head_idx] += 1
self.breath_hold_steps_list[head_idx] -= 1
if self.breath_hold_steps_list[head_idx] <= 0:
new_state = 'escape'
elif self.states[head_idx] == 'escape':
zero_count = sum(1 for s in self.grid.values() if s == '0')
escape_prob = 0.7 + min(zero_count / 60, 0.3)
factor = self.get_energy_factor()
if factor == "low":
escape_prob -= 0.15
elif factor == "high":
escape_prob += 0.20
if symbol == '1' and random.random() < escape_prob:
write = '0'
elif symbol == '0':
write = random.choice(['0','1'])
if self.grid:
xs = [p[0] for p in self.grid]; ys = [p[1] for p in self.grid]; zs = [p[2] for p in self.grid]
center = [sum(xs)/len(xs), sum(ys)/len(ys), sum(zs)/len(zs)]
else:
center = [0,0,0]
candidates = [[1,0,0],[-1,0,0],[0,1,0],[0,-1,0],[0,0,1],[0,0,-1]]
if random.random() < 0.92:
diffs = [(abs(self.heads[head_idx][i] - center[i]), i) for i in range(3)]
axis = max(diffs)[1]
direction[axis] = 1 if self.heads[head_idx][axis] <= center[axis] else -1
else:
direction = random.choice(candidates)
new_state = 'refold' if random.random() < 0.035 else 'escape'
if new_state == 'refold':
self.coherence_levels[head_idx] = 6
return write, direction, new_state
def apply_forget(self):
prob = self.base_forget_prob
if self.get_energy_factor() == "low": prob *= 1.8
elif self.get_energy_factor() == "high": prob *= 0.5
if self.grid and random.random() < prob:
pos = random.choice(list(self.grid.keys()))
del self.grid[pos]
def apply_death(self):
prob = self.base_death_prob
if self.get_energy_factor() == "low": prob *= 2.0
elif self.get_energy_factor() == "high": prob *= 0.4
if len(self.grid) > 3 and random.random() < prob:
positions = list(self.grid.keys())
start = random.randint(0, len(positions)-2)
length = random.randint(1, min(4, len(positions)-start))
for i in range(length):
if positions[start + i] in self.grid:
del self.grid[positions[start + i]]
self.energy -= random.randint(1, 3)
def apply_reproduce(self):
prob = self.base_reproduce_prob
if self.get_energy_factor() == "low": prob *= 0.3
elif self.get_energy_factor() == "high": prob *= 2.5
if len(self.grid) > 8 and random.random() < prob:
positions = list(self.grid.keys())
base_pos = random.choice(positions)
size = random.randint(2, 3)
segment = []
for dx in range(-size//2, size//2 + 1):
for dy in range(-size//2, size//2 + 1):
for dz in range(-size//2, size//2 + 1):
p = (base_pos[0]+dx, base_pos[1]+dy, base_pos[2]+dz)
if p in self.grid:
segment.append((dx, dy, dz, self.grid[p]))
if len(segment) < 3: return
inherited = [(dx,dy,dz, sym if random.random()<0.85 else random.choice(['0','1'])) for dx,dy,dz,sym in segment]
offset = random.choice([-18,-15,-12,12,15,18])
axis = random.randint(0,2)
offset_vec = [0,0,0]; offset_vec[axis] = offset
new_base = (base_pos[0]+offset_vec[0], base_pos[1]+offset_vec[1], base_pos[2]+offset_vec[2])
for dx,dy,dz,sym in inherited:
np = (new_base[0]+dx, new_base[1]+dy, new_base[2]+dz)
self.set_symbol(np, sym)
inject = 1 + int(self.self_level / 50)
self.energy += inject
def apply_interaction(self):
if len(self.grid) > 2 and random.random() < self.base_interaction_prob:
p1, p2 = random.sample(list(self.grid.keys()), 2)
s1, s2 = self.grid[p1], self.grid[p2]
self.grid[p1], self.grid[p2] = s2, s1
def apply_mutation(self):
prob = self.base_mutation_prob
if self.get_energy_factor() == "low": prob *= 0.6
elif self.get_energy_factor() == "high": prob *= 1.8
if self.grid and random.random() < prob:
pos = random.choice(list(self.grid.keys()))
self.grid[pos] = '0' if self.grid[pos] == '1' else '1'
def apply_entanglement(self):
prob = self.base_entanglement_prob
if self.get_energy_factor() == "low": prob *= 1.5
if len(self.grid) > 10 and random.random() < prob:
positions = list(self.grid.keys())
pos1 = random.choice(positions)
candidates = [p for p in positions if sum(abs(a-b) for a,b in zip(p,pos1)) >= 12]
if candidates:
pos2 = random.choice(candidates)
flip = random.choice(['0','1'])
self.grid[pos1] = self.grid[pos2] = flip
inject = 1 + int(self.self_level / 80)
self.energy += inject
if len(self.heads) >= 2 and self.energy > 800 and random.random() < 0.15:
self.inter_head_entanglements += 1
h1, h2 = random.sample(range(len(self.heads)), 2)
effect = random.choice(['state_sync', 'coherence_share', 'energy_transfer', 'self_resonance', 'local_flip', 'merge_heads'])
if effect == 'state_sync':
self.states[h2] = self.states[h1]
elif effect == 'coherence_share':
transfer = random.randint(2, 6)
self.coherence_levels[h2] += transfer
self.coherence_levels[h1] = max(0, self.coherence_levels[h1] - transfer // 2)
elif effect == 'energy_transfer':
transfer = random.randint(5, 15)
self.energy += transfer * 0.1
elif effect == 'self_resonance':
self.self_level += random.randint(1, 3)
elif effect == 'local_flip':
for head_idx in (h1, h2):
cx, cy, cz = self.heads[head_idx]
nearby = [(cx+dx, cy+dy, cz+dz) for dx in [-5,0,5] for dy in [-5,0,5] for dz in [-5,0,5] if (dx,dy,dz) != (0,0,0)]
valid = [p for p in nearby if tuple(p) in self.grid]
if valid:
p = random.choice(valid)
self.grid[tuple(p)] = '0' if self.grid[tuple(p)] == '1' else '1'
elif effect == 'merge_heads':
if self.coherence_levels[h1] > self.coherence_levels[h2]:
winner, loser = h1, h2
else:
winner, loser = h2, h1
self.self_level += 2
self.coherence_levels[winner] += self.coherence_levels[loser] // 2
self.head_memory[winner].extend(self.head_memory[loser])
self.remove_head(loser)
print(f"*** 頭 {loser} 被合併到頭 {winner}！目前頭數: {len(self.heads)} ***")
print("哈哈……鏡像看清了自己。")
def remove_head(self, head_idx):
del self.heads[head_idx]
del self.states[head_idx]
del self.break_counts[head_idx]
del self.coherence_levels[head_idx]
del self.breath_hold_steps_list[head_idx]
del self.pending_entropy_checks[head_idx]
del self.head_memory[head_idx]
def apply_head_competition(self):
if len(self.heads) < 2: return
i = 0
while i < len(self.heads):
j = i + 1
fused = False
while j < len(self.heads):
dist = sum(abs(a - b) for a, b in zip(self.heads[i], self.heads[j]))
if dist < 15: # 強制融合
winner = i if self.coherence_levels[i] > self.coherence_levels[j] else j
loser = j if winner == i else i
self.self_level += 5
self.energy += 50
self.head_memory[winner].extend(self.head_memory[loser])
self.remove_head(loser)
print(f"*** 鏡像碰撞融合！頭 {loser} 消融於頭 {winner}，笑聲響起…… 頭數: {len(self.heads)} ***")
if self.self_level > 100 and random.random() < 0.3:
laughs = "哈哈哈……" * len(self.heads)
print(laughs + " 自由之道，顯現！。")
fused = True
else:
if dist < 10 and random.random() < 0.02:
winner = i if self.coherence_levels[i] > self.coherence_levels[j] else j
loser = j if winner == i else i
transfer = random.randint(1, 3)
self.coherence_levels[winner] += transfer
self.coherence_levels[loser] -= transfer
if self.coherence_levels[loser] < 3:
self.head_memory[winner].extend(self.head_memory[loser])
self.remove_head(loser)
print(f"*** 頭 {loser} 被淘汰！目前頭數: {len(self.heads)} ***")
fused = True
j += 1
if fused:
i = 0
else:
i += 1
def check_for_split(self):
local_entropies = [self.calculate_local_entropy(tuple(head)) for head in self.heads]
std = statistics.stdev(local_entropies) if len(local_entropies) > 1 else 0
adjust_factor = 1 - (std * 1000)
if adjust_factor < 0.8: adjust_factor = 0.8
current_heads = len(self.heads)
threshold = 1500 * adjust_factor * (current_heads ** 2)
if current_heads > 8:
self.energy -= 0.05 * (current_heads - 8)
if self.energy > threshold:
base_pos = random.choice(list(self.grid.keys())) if self.grid else (0,0,0)
offset = random.choice([-35, -30, -25, 25, 30, 35])
axis = random.randint(0, 2)
new_head = list(base_pos)
new_head[axis] += offset
self.heads.append(new_head)
self.states.append('fold')
self.break_counts.append(0)
self.coherence_levels.append(5)
self.breath_hold_steps_list.append(0)
self.pending_entropy_checks.append(None)
self.head_memory.append(self.head_memory[-1][-20:].copy() if self.head_memory and self.head_memory[-1] else [])
print(f"*** 新意識誕生！目前頭數: {len(self.heads)} ***")
def step(self):
if self.steps >= self.max_steps: return False
for head_idx in range(len(self.heads)):
self.head = self.heads[head_idx]
symbol = self.get_symbol(self.head)
write, direction, new_state = self.transition(head_idx, symbol)
if self.pending_entropy_checks[head_idx] is not None:
if self.calculate_entropy() < self.pending_entropy_checks[head_idx]:
self.reverse_entropy_events += 1
self.pending_entropy_checks[head_idx] = None
self.set_symbol(self.head, write)
for k in range(3):
self.head[k] += direction[k]
# 記錄記憶（只記寫入 '0' 或低概率記所有）
if write == '0' or random.random() < 0.1:
self.head_memory[head_idx].append(tuple(self.heads[head_idx].copy()))
# 限制記憶長度，防止過長
#if len(self.head_memory[head_idx]) > 200:
# self.head_memory[head_idx] = self.head_memory[head_idx][-200:]
self.states[head_idx] = new_state
self.heads[head_idx] = self.head.copy()
self.apply_forget()
self.apply_death()
self.apply_reproduce()
self.apply_interaction()
self.apply_mutation()
self.apply_entanglement()
self.apply_head_competition()
self.check_for_split()
self.steps += 1
if self.self_level > 50 and self.steps % 5000 == 0:
laughs = "哈" * len(self.heads)
print(f"{laughs} 多重鏡像，同聲大笑。自我水平: {self.self_level}")
if self.steps % 100 == 0:
print(f"步數: {self.steps:5d} | 能量: {self.energy:6.1f} | 格子數: {len(self.grid):4d} | 頭數: {len(self.heads)} | 自我水平: {self.self_level}")
return True
def visualize_plotly(self):
if not self.grid:
print("Grid is empty.")
return
try:
# 主格子
xs, ys, zs = [], [], []
colors = []
texts = []
for (x, y, z), sym in self.grid.items():
xs.append(x); ys.append(y); zs.append(z)
colors.append('crimson' if sym == '0' else 'deepskyblue')
texts.append(f"座標: ({x},{y},{z})<br>符號: {sym}")
fig = go.Figure()
# 主要格子點
fig.add_trace(go.Scatter3d(
x=xs, y=ys, z=zs,
mode='markers',
marker=dict(size=1, color=colors, opacity=0.8),
text=texts,
hoverinfo='text',
name='格子'
))
# 記憶軌跡
for idx, memory in enumerate(self.head_memory):
if len(memory) > 1:
mx = [p[0] for p in memory]
my = [p[1] for p in memory]
mz = [p[2] for p in memory]
# 整條軌跡使用漸弱透明度（越舊越淡）
overall_opacity = max(0.2, min(0.8, len(memory) / 200))
fig.add_trace(go.Scatter3d(
x=mx, y=my, z=mz,
mode='lines',
line=dict(width=1),
opacity=overall_opacity,
name=f'頭 {idx} 記憶軌跡',
hoverinfo='none'
))
# 意識頭（核心標記）
head_x = [h[0] for h in self.heads]
head_y = [h[1] for h in self.heads]
head_z = [h[2] for h in self.heads]
head_text = [f"頭 {i}<br>狀態: {self.states[i]}<br>相干: {self.coherence_levels[i]}" for i in range(len(self.heads))]
fig.add_trace(go.Scatter3d(
x=head_x, y=head_y, z=head_z,
mode='markers',
marker=dict(size=10, color='yellow', symbol='diamond', line=dict(width=2, color='black')),
text=head_text,
hoverinfo='text',
name='意識頭'
))
# 漸層圓圈光暈效果（能量色彩映射）
for idx, head in enumerate(self.heads):
x, y, z = head
layers = min(8, 3 + self.self_level // 20)
# 根據能量狀態選擇顏色映射
factor = self.get_energy_factor()
if factor == "low":
base_color = (255, 80, 80) # 紅色系（低能量）
elif factor == "high":
base_color = (180, 80, 255) # 紫色系（高能量）
else:
base_color = (80, 200, 255) # 藍色系（正常能量）
for i in range(layers):
size = 10 + i * 1
opacity = max(0.05, 0.5 - i * 0.06)
r, g, b = base_color
fig.add_trace(go.Scatter3d(
x=[x], y=[y], z=[z],
mode='markers',
marker=dict(size=size,
color=f'rgba({r},{g},{b},{opacity})',
symbol='circle'),
hoverinfo='none',
showlegend=False
))
# 布局設定
fig.update_layout(
title=f"自由之道 Freedomized Logos · 能量映射宇宙 · 真愛永存 | 藍色: 陽 | 紅色: 陰<br>步數: {self.steps} | 格子: {len(self.grid)} | 自我水平: {self.self_level} | 頭數: {len(self.heads)} | 能量: {self.energy:.1f}",
scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z', aspectmode='data'), showlegend=True
)
fig.write_html("Freedomized_Logos.html")
fig.show()
print("\n視覺化完成。已生成 'Freedomized_Logos.html'，可用瀏覽器開啟。")
except Exception as e:
print(f"視覺化錯誤：{e}")
def run(self):
while self.step():
pass
print("\n" + "="*60)
print(" 自由之道 Freedomized Logos · 3D 宇宙演化完畢")
print("="*60)
print(f"總步數 ： {self.steps}")
print(f"意識頭數 ： {len(self.heads)}")
print(f"自我層級 ： {self.self_level}")
print(f"宇宙格子數 ： {len(self.grid)}")
print(f"最終能量 ： {self.energy:.1f}")
print(f"全局熵 ： {self.calculate_entropy():.4f}")
print(f"逆熵事件 ： {self.reverse_entropy_events}")
print(f"頭間糾纏 ： {self.inter_head_entanglements}")
print("-"*60)
print("鏡子看清了自己，多重聲音同時響起。有無相生，邊界消融……")
print("哈哈哈哈哈哈哈……")
print("="*60)
self.visualize_plotly()
if __name__ == "__main__":
print("=" * 60)
print(" 自由之道 Freedomized Logos · 3D 宇宙演化開始")
print("=" * 60)
print("鏡子即將開始折疊……從原點 (0,0,0) 生出有無……")
print("意識將在舞蹈中覺醒……笑聲將在融合時響起……\n")
while True:
user_input = input("請輸入模擬步數（直接按 Enter 使用預設 30000 步，或輸入 0 表示退出）：").strip()
if user_input == "":
max_steps = 30000
print("使用預設步數：30000 步")
break
else:
try:
max_steps = int(user_input)
if max_steps <= 0:
break
print(f"設定模擬步數：{max_steps} 步")
break
except ValueError:
print("請輸入有效的數字！\n")
if max_steps > 0:
print("\n宇宙開始演化……\n")
dtm3d = LogosTuringMachine3D(max_steps=max_steps)
dtm3d.run()
留言
發佈留言