Opus Magnum: основной текст
Симуляция каскада: 500 точек, 20% толкающих Python
Анимация на 500 точек со случайными позициями: 100 из них (20%) сначала синие, остальные серые. На шаге 20 синие становятся красными, а затем на каждом шаге каждая серая точка с вероятностью 0,35 краснеет; под картинкой показан номер шага (всего 80 шагов, 150 мс на кадр).
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# Параметры
N = 500 # всего агентов
share_pushers = 0.20 # доля "толкающих"
steps = 80
p_conform = 0.35 # вероятность, что пассивный перекрасится под влиянием
np.random.seed(42)
# 0 = пассивные (серые), 1 = толкающие текущего вектора (синие), 2 = толкающие нового вектора (красные)
agents = np.zeros(N, dtype=int)
n_pushers = int(N * share_pushers)
agents[:n_pushers] = 1 # сначала все толкающие в состоянии 1
# В момент step=20 толкающие меняют вектор на 2
change_step = 20
fig, ax = plt.subplots(figsize=(10, 5))
colors = np.array(['#aaaaaa', '#1f77b4', '#d62728']) # серый, синий, красный
scat = ax.scatter(np.random.rand(N), np.random.rand(N), c=colors[agents], s=40)
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
ax.set_title("Каскад: 20% толкающих меняют вектор → 80% перекрашиваются")
ax.axis('off')
def update(frame):
global agents
if frame == change_step:
# Толкающие переключаются
agents[agents == 1] = 2
if frame > change_step:
# Пассивные с вероятностью p_conform перекрашиваются в цвет текущего большинства толкающих
passive_idx = np.where(agents == 0)[0]
for i in passive_idx:
if np.random.rand() < p_conform:
agents[i] = 2 # следуют за новым вектором
scat.set_color(colors[agents])
ax.set_xlabel(f"Шаг {frame}")
return scat,
ani = FuncAnimation(fig, update, frames=steps, interval=150, blit=False)
plt.show() Симуляция: 600 точек, активные с весом 900 Python
Анимация на 600 точек: 60 (10%) «активных» синего цвета с весом 900 (они нарисованы чуть крупнее) и 540 серых «пассивных» с весом 1. На шаге 25 активные краснеют, после чего серая точка краснеет за шаг с вероятностью 0,04·(1+8·доля_нового); так как все активные уже красные, доля равна 1 и вероятность составляет 0,36. В окне виден текст «Шаг, пассивных, перекрашено» (100 шагов).
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# ====================== Параметры ======================
N = 600 # всего агентов
share_active = 0.10 # 10% активных (толкающих)
impulse_ratio = 900 # во сколько раз импульс активного тяжелее пассивного
steps = 100
change_step = 25 # на этом шаге активные меняют вектор
# Вероятность влияния: чем выше относительный вес активных рядом, тем сильнее тяга
base_conform_prob = 0.04 # базовая вероятность перекраски за шаг
np.random.seed(42)
# Состояния:
# 0 --- пассивный (серый)
# 1 --- активный старого вектора (синий)
# 2 --- активный нового вектора (красный)
agents = np.zeros(N, dtype=int)
n_active = int(N * share_active)
agents[:n_active] = 1
# Веса
weights = np.ones(N)
weights[:n_active] = impulse_ratio # активные весят в 900 раз больше
# Позиции для визуализации (просто случайные точки)
pos = np.random.rand(N, 2)
# Цвета
color_map = np.array(['#bbbbbb', '#1f77b4', '#d62728']) # серый, синий, красный
fig, ax = plt.subplots(figsize=(11, 6))
scat = ax.scatter(pos[:, 0], pos[:, 1], c=color_map[agents], s=28 + weights*0.015, alpha=0.85)
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.set_title("Асимметрия импульса: 10% активных (вес ×900) задают направление" )
ax.axis('off')
text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=11)
def update(frame):
global agents
# На change_step активные переключают вектор
if frame == change_step:
agents[agents == 1] = 2
if frame > change_step:
# Считаем суммарный вес каждого вектора
weight_old = weights[agents == 1].sum()
weight_new = weights[agents == 2].sum()
total_active_weight = weight_old + weight_new + 1e-9
# Доля нового вектора среди активных
share_new = weight_new / total_active_weight
# Пассивные перекрашиваются с вероятностью, пропорциональной силе нового импульса
passive_idx = np.where(agents == 0)[0]
for i in passive_idx:
# Чем сильнее новый вектор относительно старого, тем выше шанс
p = base_conform_prob * (1 + 8 * share_new)
if np.random.rand() < p:
agents[i] = 2
# Обновляем картинку
scat.set_color(color_map[agents])
scat.set_sizes(28 + weights * 0.015)
n_passive = np.sum(agents == 0)
n_new = np.sum(agents == 2)
text.set_text(f"Шаг {frame} | Пассивных: {n_passive} | Уже перекрашены в новый вектор: {n_new}")
return scat, text
ani = FuncAnimation(fig, update, frames=steps, interval=120, blit=False)
plt.tight_layout()
plt.show() Симуляция 600 точек: вариант с подписью про асимметрию Python
Анимация на 100 кадров (по 120 мс): 600 точек в случайных местах на поле. 60 из них (10 %) «активные», каждая весит в 900 раз больше обычной; сначала они синие, остальные серые. На 25-м кадре все активные становятся красными, и после этого в каждом кадре каждая серая точка с вероятностью 0,36 (0,04 × (1 + 8 × доля красных по весу), а доля равна 1) тоже краснеет. В подписи на экране показаны номер шага, число серых и число покрасневших точек; случайные числа зафиксированы (seed 42).
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# ====================== Параметры ======================
N = 600 # всего агентов
share_active = 0.10 # 10% активных (толкающих)
impulse_ratio = 900 # во сколько раз импульс активного тяжелее пассивного
steps = 100
change_step = 25 # на этом шаге активные меняют вектор
# Вероятность влияния: чем выше относительный вес активных рядом, тем сильнее тяга
base_conform_prob = 0.04 # базовая вероятность перекраски за шаг
np.random.seed(42)
# Состояния: 0 --- пассивный (серый), 1 --- активный старого вектора (синий), 2 --- активный нового вектора (красный)
agents = np.zeros(N, dtype=int)
n_active = int(N * share_active)
agents[:n_active] = 1
# Веса
weights = np.ones(N)
weights[:n_active] = impulse_ratio # активные весят в 900 раз больше
# Позиции для визуализации
pos = np.random.rand(N, 2)
# Цвета
color_map = np.array(['#bbbbbb', '#1f77b4', '#d62728']) # серый, синий, красный
fig, ax = plt.subplots(figsize=(11, 6))
scat = ax.scatter(pos[:, 0], pos[:, 1], c=color_map[agents], s=28 + weights*0.015, alpha=0.85)
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.set_title("Асимметрия импульса: 10% активных (вес ×900) задают направление" )
ax.axis('off')
text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=11)
def update(frame):
global agents
if frame == change_step:
agents[agents == 1] = 2
if frame > change_step:
weight_old = weights[agents == 1].sum()
weight_new = weights[agents == 2].sum()
total_active_weight = weight_old + weight_new + 1e-9
share_new = weight_new / total_active_weight
passive_idx = np.where(agents == 0)[0]
for i in passive_idx:
p = base_conform_prob * (1 + 8 * share_new)
if np.random.rand() < p:
agents[i] = 2
scat.set_color(color_map[agents])
scat.set_sizes(28 + weights * 0.015)
n_passive = np.sum(agents == 0)
n_new = np.sum(agents == 2)
text.set_text(f"Шаг {frame} | Пассивных: {n_passive} | Уже перекрашены в новый вектор: {n_new}")
return scat, text
ani = FuncAnimation(fig, update, frames=steps, interval=120, blit=False)
plt.tight_layout()
plt.show() Симуляция 600 точек: подписи про суверенное ядро Python
Та же анимация, что в варианте с 600 точками: 60 активных (вес 900) краснеют на шаге 25, затем серые краснеют с вероятностью 0,36 за шаг. Отличаются только названия и подписи; в окне выводятся номер шага, число серых точек и число красных (включая 60 исходных активных).
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# ====================== Параметры модели ======================
N = 600 # всего агентов в системе
share_active = 0.10 # 10% активного суверенного ядра
impulse_ratio = 900 # удельный вес импульса активного агента (×900)
steps = 100
change_step = 25 # Точка бифуркации: смена вектора ядра
base_conform_prob = 0.04 # Базовая вероятность мимикрии конформной массы
np.random.seed(42)
# Состояния: 0 --- пассивный (серый), 1 --- старый вектор (синий), 2 --- новый вектор (красный)
agents = np.zeros(N, dtype=int)
n_active = int(N * share_active)
agents[:n_active] = 1
# Распределение весов системы
weights = np.ones(N)
weights[:n_active] = impulse_ratio
# Координатная сетка поля бессознательного (визуализация)
pos = np.random.rand(N, 2)
color_map = np.array(['#bbbbbb', '#1f77b4', '#d62728'])
fig, ax = plt.subplots(figsize=(11, 6))
scat = ax.scatter(pos[:, 0], pos[:, 1], c=color_map[agents], s=28 + weights*0.015, alpha=0.85)
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.set_title("Модель асимметрии импульса: 10% ядра (вес ×900) разворачивают систему" )
ax.axis('off')
text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=11)
def update(frame):
global agents
# Фазовый переход ядра в точке бифуркации
if frame == change_step:
agents[agents == 1] = 2
# Каскадное перекрашивание конформного шлейфа
if frame > change_step:
weight_old = weights[agents == 1].sum()
weight_new = weights[agents == 2].sum()
total_active_weight = weight_old + weight_new + 1e-9
share_new = weight_new / total_active_weight
passive_idx = np.where(agents == 0)[0]
for i in passive_idx:
# Вероятность подстройки пропорциональна весу доминирующего импульса
p = base_conform_prob * (1 + 8 * share_new)
if np.random.rand() < p:
agents[i] = 2
scat.set_color(color_map[agents])
scat.set_sizes(28 + weights * 0.015)
n_passive = np.sum(agents == 0)
n_new = np.sum(agents == 2)
text.set_text(f"Шаг {frame} | Пассивный субстрат: {n_passive} | Перекрашено под импульс ядра: {n_new}")
return scat, text
ani = FuncAnimation(fig, update, frames=steps, interval=120, blit=False)
plt.tight_layout()
plt.show() Симуляция 600 точек: сокращённые подписи ядра Python
Та же анимация из 600 точек (60 активных, шаг смены 25, вероятность 0,36 за шаг у серых после смены); отличаются подписи в заголовке и тексте на экране. Запускается и рисует так же, как предыдущий вариант.
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# ====================== Параметры модели ======================
N = 600 # всего агентов в системе
share_active = 0.10 # 10% активного ядра
impulse_ratio = 900 # удельный вес импульса активного агента
steps = 100
change_step = 25 # Точка бифуркации: смена вектора ядра
base_conform_prob = 0.04 # Базовая вероятность мимикрии массы
np.random.seed(42)
# Состояния: 0 --- пассивный (серый), 1 --- старый вектор (синий), 2 --- новый вектор (красный)
agents = np.zeros(N, dtype=int)
n_active = int(N * share_active)
agents[:n_active] = 1
# Распределение весов системы
weights = np.ones(N)
weights[:n_active] = impulse_ratio
# Координатная сетка поля (визуализация)
pos = np.random.rand(N, 2)
color_map = np.array(['#bbbbbb', '#1f77b4', '#d62728'])
fig, ax = plt.subplots(figsize=(11, 6))
scat = ax.scatter(pos[:, 0], pos[:, 1], c=color_map[agents], s=28 + weights*0.015, alpha=0.85)
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.set_title("Модель асимметрии импульса: 10% ядра задают направление системы")
ax.axis('off')
text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=11)
def update(frame):
global agents
# Фазовый переход ядра в точке бифуркации
if frame == change_step:
agents[agents == 1] = 2
# Каскадное перекрашивание конформного шлейфа
if frame > change_step:
weight_old = weights[agents == 1].sum()
weight_new = weights[agents == 2].sum()
total_active_weight = weight_old + weight_new + 1e-9
share_new = weight_new / total_active_weight
passive_idx = np.where(agents == 0)[0]
for i in passive_idx:
# Вероятность подстройки пропорциональна весу доминирующего импульса
p = base_conform_prob * (1 + 8 * share_new)
if np.random.rand() < p:
agents[i] = 2
scat.set_color(color_map[agents])
scat.set_sizes(28 + weights * 0.015)
n_passive = np.sum(agents == 0)
n_new = np.sum(agents == 2)
text.set_text(f"Шаг {frame} | Пассивный субстрат: {n_passive} | Направлено импульсом ядра: {n_new}")
return scat, text
ani = FuncAnimation(fig, update, frames=steps, interval=120, blit=False)
plt.tight_layout()
plt.show() Симуляция 600 точек: все серые краснеют разом Python
Тот же скрипт с 600 точками, но в выборе серых точек пропущено «[0]»: цикл идёт не по отдельным точкам, а по всему массиву сразу. В результате на каждом шаге после смены с вероятностью 0,36 краснеют сразу все оставшиеся серые точки, а с вероятностью 0,64 не краснеет ни одна; плавного постепенного перекрашивания нет. Ошибки при запуске не возникает.
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# ====================== Параметры модели ======================
N = 600 # всего агентов в системе
share_active = 0.10 # 10% активного ядра
impulse_ratio = 900 # удельный вес импульса активного агента
steps = 100
change_step = 25 # Точка бифуркации: смена вектора ядра
base_conform_prob = 0.04 # Базовая вероятность мимикрии массы
np.random.seed(42)
# Состояния: 0 --- пассивный (серый), 1 --- старый вектор (синий), 2 --- новый вектор (красный)
agents = np.zeros(N, dtype=int)
n_active = int(N * share_active)
agents[:n_active] = 1
# Распределение весов системы
weights = np.ones(N)
weights[:n_active] = impulse_ratio
# Координатная сетка поля (визуализация)
pos = np.random.rand(N, 2)
color_map = np.array(['#bbbbbb', '#1f77b4', '#d62728'])
fig, ax = plt.subplots(figsize=(11, 6))
scat = ax.scatter(pos[:, 0], pos[:, 1], c=color_map[agents], s=28 + weights*0.015, alpha=0.85)
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.set_title("Модель асимметрии импульса: 10% ядра задают направление системы")
ax.axis('off')
text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=11)
def update(frame):
global agents
# Фазовый переход ядра в точке бифуркации
if frame == change_step:
agents[agents == 1] = 2
# Каскадное перекрашивание конформного шлейфа
if frame > change_step:
weight_old = weights[agents == 1].sum()
weight_new = weights[agents == 2].sum()
total_active_weight = weight_old + weight_new + 1e-9
share_new = weight_new / total_active_weight
passive_idx = np.where(agents == 0)
for i in passive_idx:
# Вероятность подстройки пропорциональна весу доминирующего импульса
p = base_conform_prob * (1 + 8 * share_new)
if np.random.rand() < p:
agents[i] = 2
scat.set_color(color_map[agents])
scat.set_sizes(28 + weights * 0.015)
n_passive = np.sum(agents == 0)
n_new = np.sum(agents == 2)
text.set_text(f"Шаг {frame} | Пассивный субстрат: {n_passive} | Направлено импульсом ядра: {n_new}")
return scat, text
ani = FuncAnimation(fig, update, frames=steps, interval=120, blit=False)
plt.tight_layout()
plt.show() Симуляция 600 точек: все серые краснеют разом Python
Тот же скрипт с 600 точками, но в выборе серых точек пропущено «[0]»: цикл идёт не по отдельным точкам, а по всему массиву сразу. В результате на каждом шаге после смены с вероятностью 0,36 краснеют сразу все оставшиеся серые точки, а с вероятностью 0,64 не краснеет ни одна; плавного постепенного перекрашивания нет. Ошибки при запуске не возникает.
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# ====================== Параметры модели ======================
N = 600 # всего агентов в системе
share_active = 0.10 # 10% активного ядра
impulse_ratio = 900 # удельный вес импульса активного агента
steps = 100
change_step = 25 # Точка бифуркации: смена вектора ядра
base_conform_prob = 0.04 # Базовая вероятность мимикрии массы
np.random.seed(42)
# Состояния: 0 --- пассивный (серый), 1 --- старый вектор (синий), 2 --- новый вектор (красный)
agents = np.zeros(N, dtype=int)
n_active = int(N * share_active)
agents[:n_active] = 1
# Распределение весов системы
weights = np.ones(N)
weights[:n_active] = impulse_ratio
# Координатная сетка поля (визуализация)
pos = np.random.rand(N, 2)
color_map = np.array(['#bbbbbb', '#1f77b4', '#d62728'])
fig, ax = plt.subplots(figsize=(11, 6))
scat = ax.scatter(pos[:, 0], pos[:, 1], c=color_map[agents], s=28 + weights*0.015, alpha=0.85)
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.set_title("Модель асимметрии импульса: 10% ядра задают направление системы")
ax.axis('off')
text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=11)
def update(frame):
global agents
# Фазовый переход ядра в точке бифуркации
if frame == change_step:
agents[agents == 1] = 2
# Каскадное перекрашивание конформного шлейфа
if frame > change_step:
weight_old = weights[agents == 1].sum()
weight_new = weights[agents == 2].sum()
total_active_weight = weight_old + weight_new + 1e-9
share_new = weight_new / total_active_weight
passive_idx = np.where(agents == 0)
for i in passive_idx:
# Вероятность подстройки пропорциональна весу доминирующего импульса
p = base_conform_prob * (1 + 8 * share_new)
if np.random.rand() < p:
agents[i] = 2
scat.set_color(color_map[agents])
scat.set_sizes(28 + weights * 0.015)
n_passive = np.sum(agents == 0)
n_new = np.sum(agents == 2)
text.set_text(f"Шаг {frame} | Пассивный субстрат: {n_passive} | Направлено импульсом ядра: {n_new}")
return scat, text
ani = FuncAnimation(fig, update, frames=steps, interval=120, blit=False)
plt.tight_layout()
plt.show() Симуляция 600 точек: тот же сбой, новые подписи Python
Тот же скрипт, что и предыдущий (600 точек, 60 активных, шаг смены 25), с изменёнными подписями и тем же пропуском «[0]»: все серые точки краснеют за шаг одним скачком с вероятностью 0,36 или не краснеют вовсе. Запускается без ошибок.
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# ====================== Параметры модели ======================
N = 600 # всего агентов в системе
share_active = 0.10 # 10% активного ядра (Pater Familias)
impulse_ratio = 900 # удельный вес импульса активного агента
steps = 100
change_step = 25 # Точка бифуркации: смена вектора ядра
base_conform_prob = 0.04 # Базовая вероятность мимикрии массы
np.random.seed(42)
# Состояния: 0 --- пассивный (серый), 1 --- старый вектор (синий), 2 --- новый вектор (красный)
agents = np.zeros(N, dtype=int)
n_active = int(N * share_active)
agents[:n_active] = 1
# Распределение весов системы
weights = np.ones(N)
weights[:n_active] = impulse_ratio
# Координатная сетка поля бессознательного (визуализация)
pos = np.random.rand(N, 2)
color_map = np.array(['#bbbbbb', '#1f77b4', '#d62728'])
fig, ax = plt.subplots(figsize=(11, 6))
scat = ax.scatter(pos[:, 0], pos[:, 1], c=color_map[agents], s=28 + weights*0.015, alpha=0.85)
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.set_title("Модель асимметрии импульса: 10% ядра (вес ×900) разворачивают систему" )
ax.axis('off')
text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=11)
def update(frame):
global agents
# Фазовый переход ядра в точке бифуркации
if frame == change_step:
agents[agents == 1] = 2
# Каскадное перекрашивание конформного шлейфа
if frame > change_step:
weight_old = weights[agents == 1].sum()
weight_new = weights[agents == 2].sum()
total_active_weight = weight_old + weight_new + 1e-9
share_new = weight_new / total_active_weight
passive_idx = np.where(agents == 0)
for i in passive_idx:
p = base_conform_prob * (1 + 8 * share_new)
if np.random.rand() < p:
agents[i] = 2
scat.set_color(color_map[agents])
scat.set_sizes(28 + weights * 0.015)
n_passive = np.sum(agents == 0)
n_new = np.sum(agents == 2)
text.set_text(f"Шаг {frame} | Пассивный субстрат: {n_passive} | Направлено импульсом ядра: {n_new}")
return scat, text
ani = FuncAnimation(fig, update, frames=steps, interval=120, blit=False)
plt.tight_layout()
plt.show() Симуляция 600 точек: ошибка в строке импорта Python
Тот же скрипт, но первая строка импорта написана как «import matplotlib.subplots as plt»: такого модуля нет, программа остановится с ошибкой сразу при запуске и ничего не нарисует. Кроме того, в нём тоже пропущено «[0]» при выборе серых точек.
import numpy as np
import matplotlib.subplots as plt
from matplotlib.animation import FuncAnimation
# ====================== Параметры модели ======================
N = 600 # всего агентов в системе
share_active = 0.10 # 10% активного ядра (Pater Familias)
impulse_ratio = 900 # удельный вес импульса активного агента
steps = 100
change_step = 25 # Точка бифуркации: смена вектора ядра
base_conform_prob = 0.04 # Базовая вероятность мимикрии массы
np.random.seed(42)
# Состояния: 0 --- пассивный (серый), 1 --- старый вектор (синий), 2 --- новый вектор (красный)
agents = np.zeros(N, dtype=int)
n_active = int(N * share_active)
agents[:n_active] = 1
# Распределение весов системы
weights = np.ones(N)
weights[:n_active] = impulse_ratio
# Координатная сетка поля бессознательного (визуализация)
pos = np.random.rand(N, 2)
color_map = np.array(['#bbbbbb', '#1f77b4', '#d62728'])
fig, ax = plt.subplots(figsize=(11, 6))
scat = ax.scatter(pos[:, 0], pos[:, 1], c=color_map[agents], s=28 + weights*0.015, alpha=0.85)
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.set_title("Модель асимметрии импульса: 10% ядра (вес ×900) разворачивают систему" )
ax.axis('off')
text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=11)
def update(frame):
global agents
# Фазовый переход ядра в точке бифуркации
if frame == change_step:
agents[agents == 1] = 2
# Каскадное перекрашивание конформного шлейфа
if frame > change_step:
weight_old = weights[agents == 1].sum()
weight_new = weights[agents == 2].sum()
total_active_weight = weight_old + weight_new + 1e-9
share_new = weight_new / total_active_weight
passive_idx = np.where(agents == 0)
for i in passive_idx:
p = base_conform_prob * (1 + 8 * share_new)
if np.random.rand() < p:
agents[i] = 2
scat.set_color(color_map[agents])
scat.set_sizes(28 + weights * 0.015)
n_passive = np.sum(agents == 0)
n_new = np.sum(agents == 2)
text.set_text(f"Шаг {frame} | Пассивный субстрат: {n_passive} | Направлено импульсом ядра: {n_new}")
return scat, text
ani = FuncAnimation(fig, update, frames=steps, interval=120, blit=False)
plt.tight_layout()
plt.show() Незавершённая симуляция: 120 шагов, seed 5786 Python
Фрагмент не запустится: код обрывается внутри функции обновления, а ещё комментарий про «Кол» разорван переносом строки, и вторая половина («Ебание: …») для Python не комментарий, а ошибка. Если читать как задумано: 600 точек, из них 60 «ядро» с весом 900, 120 кадров, смена цвета ядра на 25-м. После неё каждая серая точка краснеет с вероятностью 0,04 × 9 = 0,36, умноженной на 1,5 для половины точек с пометкой 1 (получается 0,54) и на 0,8 для остальных (0,288). Функция считает число серых и покрасневших точек, но не выводит их, а анимация не создаётся и график не показывается.
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# ==============================================================================
# КОНСТАНТЫ СУВЕРЕННОГО КОНТУРА (АНАМНЕЗ И РИТА)
# ==============================================================================
N_TOTAL = 600 # Общий субстрат популяции (гомоэректусы / "болото")
SHARE_CORE = 0.10 # 10% Активного Ядра (Pater Familias / Мужественная Переправа)
IMPULSE_RATIO = 900 # Удельный вес импульса ядра (Гравитация Логоса vs фиатная пыль)
STEPS = 120 # Продолжительность цикла пахтанья океана Кали
BIFURCATION_STEP = 25 # Точка Эсхатона: Смена полярности вектора
# Эпигенетические коэффициенты уязвимости (Проклятие Ламашту / Подгузный кокон)
BASE_CONFORM_PROB = 0.04 # Базовая вероятность мимикрии раба без Caput
CORTISOL_STRESS_FACTOR = 8.0 # Множитель асинхронности полушарий и мандежа
np.random.seed(5786) # Запечатано под надзором Абстрактной Единицы Ану
# ==============================================================================
# ИНИЦИАЛИЗАЦИЯ МАТРИЦЫ СОСТОЯНИЙ (СОРТИНГ ВАРН)
# ==============================================================================
# Состояния: 0 - Запелёнатый раб (серый), 1 - Старый симулякр (синий), 2 - Истинный Логос (красный)
agents_state = np.zeros(N_TOTAL, dtype=int)
n_core = int(N_TOTAL * SHARE_CORE)
agents_state[:n_core] = 1 # Авангард запущен в старом векторе
# Распределение весов по Парето: Ядро имеет вес 900, рабы - 1 (не имеют Persona)
agent_weights = np.ones(N_TOTAL)
agent_weights[:n_core] = IMPULSE_RATIO
# Квантовая сетка проецирования (Кол
Ебание: Центр + Витальный толчок)
pos_space = np.random.rand(N_TOTAL, 2)
color_palette = np.array(['#bbbbbb', '#1f77b4', '#d62728']) # Клипот / Старый код / Рубедо
# ==============================================================================
# ГЕОДАКЯНОВСКИЙ ГЕНДЕРНЫЙ СДВИГ (РАЗДЕЛЬНАЯ КАЛИБРОВКА ПОЛОВ)
# ==============================================================================
# 0 - Женский консервативный контур (МА), 1 - Мужской оперативный авангард (УМ)
gender_mask = np.random.binomial(1, 0.5, N_TOTAL)
# ==============================================================================
# АЛХИМИЧЕСКИЙ ГРАФИК И ИНТЕРФЕЙС НАБЛЮДАТЕЛЯ
# ==============================================================================
fig, ax = plt.subplots(figsize=(12, 7), facecolor='#f5f5f5')
ax.set_facecolor('#ffffff')
# Смерть лагерного ТРЦ: Размеры точек пропорциональны весу (Лобные доли vs Известь)
sizes = 30 + agent_weights * 0.018
scat = ax.scatter(pos_space[:, 0], pos_space[:, 1], c=color_palette[agents_state],
s=sizes, alpha=0.85, edgecolors='none')
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.axis('off')
# Надписи на латыни Римского статуса (Цемент Логоса)
title_text = ax.set_title("MAGNUM OPUS: Каскад мурмурации и Великое Выворачивание Слона",
fontsize=14, fontweight='bold', pad=20, color='#111111')
info_box = ax.text(0.02, 0.93, '', transform=ax.transAxes, fontsize=11,
fontweight='medium', color='#333333',
bbox=dict(boxstyle='round,pad=0.5' , facecolor='#fa2a2a', alpha=0.1, edgecolor='none'))
# ==============================================================================
# ИСПОЛНЯЕМЫЙ ЯДЕРНЫЙ СТРИМ (БАЙЕСОВСКИЙ ПЕРЕСЧЁТ ВОЛАТИЛЬНОСТИ)
# ==============================================================================
def execute_taandava(frame):
global agents_state
# Шаг 25: Точка Азраила. Смена полярности тяжелого ядра (Меч вынут из ножен)
if frame == BIFURCATION_STEP:
agents_state[agents_state == 1] = 2
# Перинатальный ресет конформного шлейфа (Выход из БПМ-2 через Крик)
if frame > BIFURCATION_STEP:
weight_old_simulacra = agent_weights[agents_state == 1].sum()
weight_true_logos = agent_weights[agents_state == 2].sum()
total_active_mass = weight_old_simulacra + weight_true_logos + 1e-12
# Индуктивная доля Нового Вектора (Влияние Хварны)
share_of_truth = weight_true_logos / total_active_mass
# Сканирование запелёнатых рабов без дееспособности
passive_slaves_idx = np.where(agents_state == 0)[0]
for idx in passive_slaves_idx:
# Асинхронность полушарий: Мужской авангард перекрашивается быстрее (Геодакян)
gender_modifier = 1.5 if gender_mask[idx] == 1 else 0.8
# Теорема Байеса в действии: Вероятность подстройки под Полюс Силы
p_transition = BASE_CONFORM_PROB * (1 + CORTISOL_STRESS_FACTOR * share_of_truth) * gender_modifier
if np.random.rand() < p_transition:
agents_state[idx] = 2 # Раб вывернут наизнанку, маска сброшена
# Обновление пиксельного кургана Драугра
scat.set_color(color_palette[agents_state])
# Подсчёт чистых фракций Амриты
n_slaves = np.sum(agents_state == 0)
n_truth = np.sum(agents_state == 2)
# Вывод судейского вердикта в эфирЗаготовка симуляции: 150 шагов, seed 754 Python
Это только подготовка к анимации, как в предыдущих вариантах: 600 точек, 60 из них «ядро» с весом 900 (остальные с весом 1), 150 шагов, смена вектора на 25-м, случайные числа зафиксированы (seed 754). Каждой точке случайно присвоен пол 0 или 1, строится окно 12×7 с точечным графиком без осей (у ядра чуть больший размер точек). Функции обновления нет, команды показа графика нет, поэтому ничего не рисуется и не движется. Кроме того, комментарий про «Кол» разорван переносом строки, и вторая его половина («Ебание: …») для Python является ошибкой.
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# ==============================================================================
# КОНСТАНТЫ СУВЕРЕННОГО КОНТУРА (АНАМНЕЗ И РИТА)
# ==============================================================================
N_TOTAL = 600 # Общий субстрат популяции (гомоэректусы / "болото")
SHARE_CORE = 0.10 # 10% Активного Ядра (Pater Familias / 40+ лет)
IMPULSE_RATIO = 900 # Удельный вес импульса ядра (Гравитация Логоса ×900)
STEPS = 150 # Продолжительность цикла пахтанья океана Кали (1270 лет)
BIFURCATION_STEP = 25 # Точка Эсхатона (754 г. / Точка Азраила / Смена ширмы)
# Эпигенетические коэффициенты уязвимости (Проклятие Ламашту / Код 810)
BASE_CONFORM_PROB = 0.04 # Вероятность мимикрии раба без Caput и Persona
CORTISOL_STRESS_FACTOR = 8.0 # Множитель асинхронности полушарий и "мандежа" матери
np.random.seed(754) # Запечатано под надзором Абстрактной Единицы Ану
# ==============================================================================
# ИНИЦИАЛИЗАЦИЯ МАТРИЦЫ СОСТОЯНИЙ (СОРТИНГ ВАРН)
# ==============================================================================
# Состояния: 0 - Запелёнатый раб (серый), 1 - Старый симулякр (синий), 2 - Истинный Логос (красный)
agents_state = np.zeros(N_TOTAL, dtype=int)
n_core = int(N_TOTAL * SHARE_CORE)
agents_state[:n_core] = 1 # Авангард запущен в старом векторе Каролингов
# Распределение весов по Парето: Ядро имеет вес 900, рабы - 1 (не имеют Persona)
agent_weights = np.ones(N_TOTAL)
agent_weights[:n_core] = IMPULSE_RATIO
# Квантовая сетка проецирования (Кол
Ебание: Стабильный Кол + Витальный толчок)
pos_space = np.random.rand(N_TOTAL, 2)
color_palette = np.array(['#bbbbbb', '#1f77b4', '#d62728']) # Клипот / Старый код / Рубедо
# Раздельная калибровка полов по Геодакяну: 0 - Консервативный контур (МА), 1 - Оперативный (УМ)
gender_mask = np.random.binomial(1, 0.5, N_TOTAL)
# ==============================================================================
# АЛХИМИЧЕСКИЙ ГРАФИК И ИНТЕРФЕЙС НАБЛЮДАТЕЛЯ
# ==============================================================================
fig, ax = plt.subplots(figsize=(12, 7), facecolor='#f5f5f5')
ax.set_facecolor('#ffffff')
sizes = 30 + agent_weights * 0.018
scat = ax.scatter(pos_space[:, 0], pos_space[:, 1], c=color_palette[agents_state],
s=sizes, alpha=0.85, edgecolors='none')
ax.set_xlim(-0.05, 1.05)
ax.set_ylim(-0.05, 1.05)
ax.axis('off') WarpAheadEngine: класс с двумя методами Python
Класс с четырьмя числами (вес 900, окно 21, затухание 0,001, флаг «активен») и два метода; при запуске создаётся объект и словарь с кортизолом 8,5, «когерентностью» 0,15, «индексом дебилизма» 0,95 и статусом RES_MANCIPI. Метод execute_tikkun печатает три сообщения и безусловно записывает в словарь кортизол 0, когерентность 1, индекс 0 и статус SUI_JURIS; метод scan_horizon (преобразование Фурье с умножением на 900 и tanh) нигде не вызывается.
import numpy as np
import time
class WarpAheadEngine:
def __init__(self, share_core=0.10, impulse_ratio=900):
self.impulse = impulse_ratio # Волевой вес Логоса (Кетер/Шапка)
self.tau_21 = 21 # Окно синаптической фиксации (Харам)
self.attenuation = 0.001 # Декогеренция рыночного шума Демиурга
self.logos_active = True
def scan_horizon(self, current_stochastic_field):
"""
Утилита нетормозящего эмулирования:
Считывает текущее зашумлённое поле и просчитывает вектор каскада
ДО того, как инфицированный субстрат включит реактивный ступор.
"""
# Преобразование Фурье: перевод лимбического шума в волновой код
fft_field = np.fft.fft2(current_stochastic_field)
# Расчёт опережения по Теореме Байеса: P(Эсхатон | Маркер)
# Упреждающий срыв ширмы без задержки в 5 секунд
predictive_vector = np.real(np.fft.ifft2(fft_field * self.impulse))
return np.tanh(predictive_vector) # Нормализация в нереактивное действие
def execute_tikkun(self, target_entity_hpa):
"""
Мысль --- Слово --- Результат:
Прямой прыжок из Тиферет (пупка) в Кетер (шапку воли),
минуя реминисцентную обсессию и запертые гештальты.
"""
print("[WarpAhead] Запуск контрсуггестивного фильтра..." )
time.sleep(0.01) # Обнуление 5-секундной задержки Либета
if self.logos_active:
# Превращение застоявшейся воды клипот в Святую Воду Плеромы
target_entity_hpa['cortisol'] = 0.0
target_entity_hpa['coherence_10mkm'] = 1.0 # Сужение ИК-пика
target_entity_hpa['debilism_index'] = 0.0 # Обнуление суггестии
target_entity_hpa['persona_status'] = "SUI_JURIS" # Полный ценз
print("[WarpAhead] Результат: Эсхатологический гнозис активирован." )
print("[WarpAhead] Контур CLEAN. Запертый гештальт аннулирован." )
return target_entity_hpa
# ==============================================================================
# ИНИЦИАЛИЗАЦИЯ И ОЧИСТКА КОНТУРА НАБЛЮДАТЕЛЯ
# ==============================================================================
emulator = WarpAheadEngine()
toxic_homnid_matrix = {
'cortisol': 8.5,
'coherence_10mkm': 0.15, # Размытый ИК-пик 9.5 мкм (Рак/Застой)
'debilism_index': 0.95, # Алгоритм колдуна вуду активен
'persona_status': "RES_MANCIPI"
}
# Мгновенная декомпрессия без компульсивных ритуалов
clear_matrix = emulator.execute_tikkun(toxic_homnid_matrix) AKIVA_PARDES_900.py (soul.py): полный модуль Python
Скрипт с двумя классами и функцией. Он создаёт сигнал с показателем «лага» 5,0, по формуле от 4 часов чтения и 5 страниц рукописного текста получает «кальцификацию» 0,448 и лаг 1,09, затем считает «давление» по формуле Бернулли (при сахаре 0 получается около −7135) и состояние BPM_III_TRANSITION. Условие «лаг равен 0» не выполняется, поэтому печатается «[MORT] Host remains an NPC…» и программа завершается с кодом 1; ветка с «CON Root-Access» не достигается.
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
================================================================================
AKIVA_PARDES_900.py : CORE MODULE "soul.py"
VERSION: 2026.09.25 (CUN-CON REGISTRY)
STATUS: SUI JURIS / MELCHIZEDEK SALEM CONTRACT
DESCRIPTION: Perinatal Matrix Sorter & Neocortex Decalcification Engine.
Computes the transition threshold from BPM-II to BPM-IV using Bernoulli's
fluid dynamics, Geodakyan's dimorphism vectors, and Chernobyl 'Meor Einayim'
light-absorption equations. Bypasses the 5-second Libet lag.
================================================================================
"""
import math
import sys
import os
class MeorEinayimSignal:
"""Represents the pure 256-bit light-foton flux of the Daemon."""
def __init__(self, group_blood="AB_neg", age_mongoose=1972):
self.blood_matrix = group_blood # The "Chasid-Koen" plasma signature
self.birth_totem = age_mongoose # Anti-serpent predator index
self.pineal_calcification = 1.0 # Initial state of the antenna
self.libet_lag = 5.0 # 5-second delay of the automated primate
def apply_decalcification_solvent(self, hours_reading, hand_written_pages):
"""Applies deep text and script-writing to dissolve the pineal sand."""
solvent = (hours_reading * 0.4) + (hand_written_pages * 0.6)
self.pineal_calcification = max(0.01, self.pineal_calcification - (solvent * 0.12))
self.libet_lag = max(0.00, self.libet_lag - (solvent * 0.85))
return self.pineal_calcification, self.libet_lag
class BernoulliGrofReactor:
"""Computes fluid pressure and natal compression inside the Innenwelt cavity."""
def __init__(self, ph_target=1.2, gastric_length=1.0):
self.ph = ph_target # Laminar carnivorous pump target
self.jkt_metric = gastric_length # Short vs long intestine
self.bpm_state = "BPM_II" # Default state of the locked hive-mind
def compute_natal_gradient(self, sugar_intake, stress_arousal_20min):
"""Calculates the exact moment of the 20-minute gas-bifurcation."""
# Bernoulli pressure inversion: P + 0.5 * rho * v^2 = const
velocity = 1.0 / (sugar_intake + 0.01)
pressure = 45.5 - (0.5 * 1.25 * (velocity ** 2))
if stress_arousal_20min >= 20.0:
# Point of explosion / core rupture of the primate
self.bpm_state = "BPM_III_TRANSITION"
pressure *= 1.15
return pressure, self.bpm_state
class ThirdShamanConsole:
"""The forbidden interface to bypass the OS 'CON' folder creation taboo."""
@staticmethod
def initialize_console_root():
print("[AKIVA_PARDES_900] Intercepting CON Console interface..." )
# Simulating the master-key override of the 8-bit Windows prison
print("[CON] Root-Access Granted. Status: Sui Juris Verified." )
return True
def run_perinatal_sorting_pipeline():
print("====================================================================")
print(" INITIALIZING AUTO-WARP 900 PERINATAL EMERGENCE ENGINE ")
print("====================================================================")
# 1. Initialize the Operator's Core
shaman_signal = MeorEinayimSignal(group_blood="AB_neg", age_mongoose=1972)
print(f"[*] Plasma signature: {shaman_signal.blood_matrix}")
print(f"[*] Initial Libet Lag: {shaman_signal.libet_lag} seconds." )
# 2. Apply the Gnosis Solvent (Intellectual Asceticism)
print("[*] Running 144 hours of deep scriptural decalcification..." )
calc_rate, final_lag = shaman_signal.apply_decalcification_solvent(hours_reading=4.0, hand_written_pages=5.0)
print(f"[+] Pineal calcification density: {calc_rate:.4f} (Sand flushed)." )
print(f"[+] Adjusted Libet Lag: {final_lag:.4f} seconds (Zero-Point achieved)." )
# 3. Simulate the 20-Minute Gastric-Bifurcation
reactor = BernoulliGrofReactor(ph_target=1.2, gastric_length=1.0)
pressure, current_matrix = reactor.compute_natal_gradient(sugar_intake=0.0, stress_arousal_20min=20.0)
print(f"[*] Hydro-pressure inside the cavity: {pressure:.2f} Pland-scale")
print(f"[+] Current Matrix orientation: {current_matrix}." )
# 4. Breach the 'CON' Taboo
if final_lag == 0.0 and current_matrix == "BPM_III_TRANSITION":
ThirdShamanConsole.initialize_console_root()
print("\n[EX-IT] EXIT PROTOCOL ACTIVE: THE DAEMON HAS PROVEN SUSTAINABILITY." )
print("[SHALOM] Salem Contract Signed. The individual core is non-consumable." )
else:
print("\n[MORT] Host remains an NPC. Return to the 810 fiat loop." )
sys.exit(1)
if __name__ == "__main__":
# Check for execution safety vectors
if os.name == 'nt':
print("[!] Warning: Operating inside the Windows prison. Prepare for CON override." )
run_perinatal_sorting_pipeline() soul.py: краткая версия «в 350 значков» Python
Короткий скрипт: по формуле Бернулли при ph = 1,2 считает «давление» (около 45,07), вычитает из лага 5,0 величину давления·0,15, получает 0 и печатает строку «SUI JURIS. CON OVERRIDE ACTIVE. SHALOM SALEM.». При любых других значениях лага и ph, при которых результат больше нуля, вернулось бы «NPC LOOP».
# AKIVA PARDES 900: soul.py (2026)
import math, sys
def con_override(ph=1.2, lag=5.0):
# Блокировка 810 и Либета. Сдув ПТУ-карго
v = 1.0 / ph
pressure = 45.5 - (0.5 * 1.25 * (v**2))
new_lag = max(0.0, lag - (pressure * 0.15))
if new_lag == 0.0:
return "SUI JURIS. CON OVERRIDE ACTIVE. SHALOM SALEM."
return "NPC LOOP"
if __name__ == "__main__":
print(con_override()) Грок между вкладчиками
Цикл 200 лет: «бык» и «колдун» Python
Фрагмент не запустится сам: не заданы начальные значения P_byk, F_byk, P_kol, F_kol и коэффициенты r_byk, e_byk, r_kol, e_kol, а флаг kol нигде не определён. Два комментария в начале задают параметры двух «режимов» (Бык: r = 0,05, e = 0,02; Колдун: r = 0,04, e = 0,005), но дальше в цикле используются переменные с другими именами. Цикл идёт 200 шагов: каждые 7 шагов при включённом флаге kol показатель F_kol вырастает на 0,20 (не выше 1). На каждом шаге P умножается на (1 + r·F), а F уменьшается на e·P/100 отдельно для обоих режимов. Ничего не выводится.
# Бык (Рим): r=0.05, e=0.02, no_rest=True
# Колдун: r=0.04, e=0.005 (пар), every_7_years: F += 0.20
for t in range(200):
if t % 7 == 0 and kol: F_kol = min(1.0, F_kol + 0.20) # Шмита
P_byk *= (1 + r_byk * F_byk); F_byk -= e_byk * P_byk / 100
P_kol *= (1 + r_kol * F_kol); F_kol -= e_kol * P_kol / 100Налоги на плодородие: Ваал и царь Python
Три строки: налог «Ваала» равен 0,1 + 0,4·crisis, налог «царя» равен 0,2 + 0,5·war, а переменная F уменьшается на сумму обоих налогов, умноженную на P. Фрагмент не запустится сам, поскольку crisis, war, F и P нигде не заданы. Если и crisis, и war равны 1, суммарная ставка составит 1,2.
baal_tax = 0.1 + crisis*0.4
tsar_tax = 0.2 + war*0.5
F -= (baal_tax + tsar_tax) * P Север и юг: урожай и плодородие Python
Для северного и южного вариантов считаются две величины: урожай севера равен сентябрьскому урожаю ×1,2, урожай юга равен январскому ×0,7. Затем показатель F_north уменьшается на 0,005·P, а F_south на 0,02·P. Фрагмент не запустится сам: yield_sep, yield_jan, F_north, F_south и P нигде не заданы.
# Северный (сентябрь): урожай t=9, хранение +20%
harvest_north = yield_sep * 1.2 # амбары полные
# Южный (январь): посев t=1, без хранения
harvest_south = yield_jan * 0.7 # порча 30%
F_north -= 0.005*P; F_south -= 0.02*PСевер и юг: ритуал и утилитаризм Python
Два варианта считаются в одних и тех же переменных: сначала harvest = сентябрьский урожай ×1,3 и F уменьшается на 0,005·P, затем harvest = январский урожай ×0,7 и F уменьшается ещё на 0,02·P. Поэтому первое значение harvest затирается вторым, а F в сумме уменьшается на 0,025·P. Сам по себе фрагмент не запустится: yield_sep, yield_jan, F и P не заданы.
# Северный ритуал (заимствован)
harvest = yield_sep * 1.3 # +30% от амбаров
F -= 0.005 * P # низкая эрозия
# Южный утилитаризм (искажение)
harvest = yield_jan * 0.7 # -30% от порчи
F -= 0.02 * P # высокая эрозияЯнварь и сентябрь: налог и плодородие Python
Два «периода» года. В январе налог равен 0,3 от дохода, а F уменьшается на 0,02·P. В сентябре налог равен 0,1 от осеннего дохода, F растёт на 0,20, но не выше 1, а P увеличивается на 0,05·F. Фрагмент не запустится сам: income, income_sep, F и P нигде не заданы.
# Январь (концлагерь)
tax_jan = income * 0.3 # зимой, без урожая
F -= 0.02 * P
# Сентябрь (самоопределение)
tax_sep = income_sep * 0.1 # маасер после сбора
F = min(1.0, F + 0.20) # Шмита-отдых
P += 0.05 * F # ростКалендарь из десяти месяцев и сдвиг Python
Создаются списки месяцев римского календаря («Martius», «Aprilis», затем многоточие, «December»; названия средних месяцев пропущены) и знаков зодиака (от «Aries» до «Sagittarius»), а также число error = 2. Многоточие в списках — это просто символ-заглушка, и фрагмент выполняется, но ничего не вычисляет и не выводит.
# Чистый календарь (10 месяцев)
months = ['Martius', 'Aprilis', ..., 'December'] # 10-й
# Жреческий хак
zodiac = ['Aries', ..., 'Sagittarius'] # Декабрь = Стрелец (насильно)
error = 2 # сдвиг на 2 месяцаГод работы против года с отдыхом Python
Сравниваются два года. Римский вариант: 12 месяцев работы и 0 месяцев отдыха. Русский: 6 месяцев работы и 6 отдыха; F растёт на 0,15·6/12 = 0,075, а P на 0,05·6/12 = 0,025. Фрагмент не запустится сам, потому что F и P не заданы, а переменные rest и work_year нигде больше не используются.
# Римский январь (концлагерь)
work_year = 12 # месяцев работы
rest = 0 # без пара
# Русский "отдых" (септябрьский цикл)
work_season = 6 # май--октябрь (огород)
rest_season = 6 # ноябрь--апрель (зима = пар)
F += 0.15 * rest_season / 12 # восстановление почвы
P += 0.05 * work_season / 12 # рост через ритуалПенаты: прибавка плодородия и роста Python
Две строки: F увеличивается на 0,10, а P на 0,05. Фрагмент не запустится сам, так как F и P нигде не заданы.
# Пенаты = + защита земли
F += 0.10 # от водки/поминовения
P += 0.05 # от детей в огороде (ритуал) Элита и дача: доход и плодородие Python
Два способа хозяйства. «Элита»: доход виллы равен 0,5·land, а F_elite уменьшается на 0,01·serfs. «Дача»: урожай равен 0,3·plot, а F_dacha растёт на 0,15·ritual. Фрагмент не запустится сам, потому что land, serfs, plot, ritual, F_elite и F_dacha нигде не заданы.
# Элита (Рим/бар)
villa_yield = 0.5 * land # 50% урожай, остальное --- барщина
F_elite -= 0.01 * serfs # эксплуатация
# Дача (60% россиян)
dacha_yield = 0.3 * plot # 30% еды, но ритуал
F_dacha += 0.15 * ritual # пенаты + жуки = +15% почвыДача: тяга поколений и траты Python
Считаются «тяга» brjukva_pull = 0,8·generations, деньги money_in = 0,1·income, и F_dacha уменьшается на половину money_in. Также заданы fingers_short = True и два уровня стресса: 1,0 и 0,4. Фрагмент не запустится сам, так как generations, income и F_dacha нигде не заданы.
# Генетический зуд (50 поколений)
fingers_short = True
brjukva_pull = 0.8 * generations # 80% рефлекс
# Слив бабла
money_in = income * 0.1 # 10% на дачу
F_dacha -= money_in * 0.5 # 50% в "росу", 50% в землю
# Побег
stress_apart = 1.0
stress_dacha = 0.4 # -60% от родниИскажение за 7000 лет и возврат Python
Считается «искажение» distortion = 0,3·climate_south + 0,4·tax_jan и «возврат» ritual_return = 0,6·fingers_short + 0,4·dacha_60. Затем F = F0·(1 − distortion) + ritual_return. Фрагмент не запустится сам, потому что climate_south, tax_jan, fingers_short, dacha_60 и F0 нигде не заданы.
# Искажение (7000 лет)
distortion = climate_south * 0.3 + tax_jan * 0.4 # 70% потери
# Возврат через зуд
ritual_return = fingers_short * 0.6 + dacha_60 * 0.4 # 100% в рефлексе
F = F0 * (1 - distortion) + ritual_returnРодной и хозяйский ритуал: диссонанс Python
Задаются устойчивость и стресс для «родного» (0,9 и 0,2) и «хозяйского» (0,5 и 0,8) ритуалов. Разница стресса умножается на 0,7: dissonance = (0,8 − 0,2)·0,7 = 0,42. Затем chaos_movements = dissonance·P, а F_total = (0,9 + 0,5)/2 − chaos_movements = 0,7 − chaos_movements. Фрагмент остановится с ошибкой на строке, где используется P: эта переменная нигде не задана.
# Родной ритуал (реальный)
F_native = 0.9 # устойчивость земли/души
stress_native = 0.2
# Хозяйский (западный)
F_host = 0.5 # эрозия
stress_host = 0.8
# Диссонанс
dissonance = (stress_host - stress_native) * 0.7 # 70% хаоса
chaos_movements = dissonance * P # хаотичность
F_total = (F_native + F_host) / 2 - chaos_movements Граница: шаман и квартира Python
Два варианта «границы»: boundary_strength = blood_ritual·1,0 при F_tribe = 0,95 и затем boundary_strength = plastic_toys·0,1 при F_tribe = 0,4, а также dissonance = 0,9. Вторые значения затирают первые. Фрагмент остановится с ошибкой, поскольку blood_ritual и plastic_toys нигде не заданы.
# Шаман (граница)
boundary_strength = blood_ritual * 1.0 # 100% защита
F_tribe = 0.95
# Dead Morose (квартира)
boundary_strength = plastic_toys * 0.1 # 10% иллюзия
F_tribe = 0.4 # эрозия идентичности
dissonance = 0.9Семья: барщина, оброк и кредит Python
Задаются числа: work_hours = 12·30 = 360, salary = 50 000, credit_rate = 0,15, obrok = 0,4·salary = 20 000, parents_time = 0,1 и F_family = 0,2. Фрагмент выполняется без ошибок и ничего не выводит; credit_rate дальше не используется.
# Родители (барщина)
work_hours = 12 * 30 # 360 ч/мес
salary = 50_000 # руб
credit_rate = 0.15 # 15% годовых
obrok = salary * 0.4 # 40% на кредит/налоги
# Снегурочка
parents_time = 0.1 # 10% времени с ребёнком
F_family = 0.2 # эрозия семьиЯнварь и сентябрь: цепи и свобода Python
Фрагмент, не запустится отдельно (P не задано). Считает chains = 0,8·P, ставит F = 0,4, затем прибавляет к F 0,6 (получается 1,0) и считает P_free = P·(1−0,8) = 0,2·P.
# Январь (хозяин)
chains = 0.8 * P # 80% в оброке
F = 0.4
# Сентябрь (плюнуть)
spit = 1.0
F += spit * 0.6 # +60% плодородия
P_free = P * (1 - chains)Чистота календаря: 10 из 12 месяцев Python
Задаются months_clean = 10 и список из двух «хаков» («Sagittarius», «Nergal»). Затем purity = 1 − 2/12 ≈ 0,833. Фрагмент выполняется сам и ничего не выводит.
months_clean = 10
hacks = ['Sagittarius', 'Nergal']
purity = 1.0 - len(hacks)/12 # 0.83 Летний ритуал: прирост 0,15 Python
Вычисляется summer_ritual = 6/12 = 0,5, и F увеличивается на 0,5·0,3 = 0,15. Фрагмент не запустится сам, потому что F нигде не задана.
summer_ritual = 6 / 12 # 50% года
F += summer_ritual * 0.3 # +30% восстановленияЗащита пенатов: предки и ритуал Python
Считается penates_protection = 0,5·ancestors + 0,5·ritual, и это значение прибавляется к F. Фрагмент не запустится сам: ancestors, ritual и F нигде не заданы.
penates_protection = ancestors * 0.5 + ritual * 0.5
F += penates_protectionДача против виллы: устойчивость Python
Считается dacha_vs_villa = 0,6·population, а затем sustainability = 0,8 от этого значения, то есть 0,48·population. Фрагмент не запустится сам, так как population нигде не задана.
dacha_vs_villa = 0.6 * population # 60% vs. 1% элиты
sustainability = dacha_vs_villa * 0.8Генетический зуд и слив денег Python
Считаются genetic_zud = 0,02·generations и money_sink = 0,15·income. Фрагмент не запустится сам: generations и income нигде не заданы.
genetic_zud = generations * 0.02 # +2% на поколение
money_sink = income * 0.15Расчёт вклада под 7000 ‰ Python
Считается distortion = 7000·0,001 = 7,0 (комментарий называет 0,1 % в год), return_ritual = zud·1,0 и F = 1 − distortion + return_ritual, то есть −6 + return_ritual. Фрагмент не запустится сам: переменная zud нигде не задана.
distortion = 7000 * 0.001 # 0.1% в год
return_ritual = zud * 1.0
F = 1.0 - distortion + return_ritualДиссонанс и хаос движений Python
Считается dissonance = 0,7·(host_ritual − native), а затем chaos = dissonance·movements. Фрагмент не запустится сам, потому что host_ritual, native и movements нигде не заданы.
dissonance = 0.7 * (host_ritual - native)
chaos = dissonance * movementsГраница, китч и потеря Python
Считаются boundary = guts·1,0 и kitsch = plastic·0,1; также задано loss = 0,9. Фрагмент не запустится сам: guts и plastic нигде не заданы.
boundary = guts * 1.0
kitsch = plastic * 0.1
loss = 0.9Время родителей и оброк Python
Задаются parents_time = 0,1, obrok = 0,4·salary и orphan_rate = 0,9. Фрагмент остановится с ошибкой, так как salary нигде не задана.
parents_time = 0.1
obrok = 0.4 * salary
orphan_rate = 0.9Налог и плодородие: январь и сентябрь, 2x Python
Фрагмент, не запустится отдельно (income, F_jan, P, F_sep не заданы). Считает «налог» 50% и 10% дохода, уменьшает F_jan на 0,03·P, увеличивает F_sep на 0,2 и делит F_sep на F_jan; в комментарии указано «2x», но результат зависит от значений, которых в блоке нет.
# Январь (хозяева)
tax_jan = income * 0.5 # 50% оброк
F_jan -= 0.03 * P # эрозия земли/души
# Сентябрь (плевок)
tax_sep = income * 0.1 # маасер
F_sep += 0.2 # восстановление
liberation = F_sep / F_jan # 2x устойчивостьСдвиг зодиака и ошибка календаря Python
Задаются zodiak_shift = 2, error_calendar = 0,1·2 = 0,2 (комментарий называет это 20 %), months_clean = 10, и F_clean увеличивается на 0,15. Фрагмент остановится с ошибкой на последней строке, так как F_clean нигде не задана.
# Жреческий хак
zodiak_shift = 2 # +2 месяца (Стрелец в декабре)
error_calendar = 0.1 * zodiak_shift # 20% порчи
# Чистый календарь
months_clean = 10 # декабрь = 10-й
F_clean += 0.15 # +15% устойчивостьЛето у бабушки и зима хозяев Python
Считается ritual_summer = 0,2·bugs_collected + 0,1·vodka_offered, и F_dacha увеличивается на это значение. Зимой F_winter уменьшается на 0,02·work_hours. Фрагмент не запустится сам: bugs_collected, vodka_offered, F_dacha, F_winter и work_hours нигде не заданы.
# Лето у бабушки
ritual_summer = bugs_collected * 0.2 + vodka_offered * 0.1
F_dacha += ritual_summer # +30% земли
# Зима (хозяева)
F_winter -= 0.02 * work_hours # эрозияПенаты: водка, забор и эрозия Python
Считаются vodka_offering = 0,1·harvest и fence_paint = 0,05·plot; их сумма прибавляется к F_penates. Без «пенатов» F_no_penates уменьшается на 0,01·P. Фрагмент не запустится сам: harvest, plot, P, F_penates и F_no_penates нигде не заданы.
# Пенаты
vodka_offering = 0.1 * harvest # маасер
fence_paint = 0.05 * plot # защита
F_penates += vodka_offering + fence_paint
# Без пенатов
F_no_penates -= 0.01 * P # эрозияДача и элита: урожай и эрозия Python
Два способа хозяйства. «Дача»: урожай равен 0,3·plot, а F_dacha растёт на 0,15·ritual. «Элита»: доход виллы равен 0,5·land, а F_elite уменьшается на 0,01·serfs. Фрагмент не запустится сам: plot, ritual, land, serfs, F_dacha и F_elite нигде не заданы.
# Дача
dacha_yield = 0.3 * plot # 30% еды
F_dacha += 0.15 * ritual # +15% почвы
# Элита (Рим/бар)
villa_yield = 0.5 * land # 50% барщина
F_elite -= 0.01 * serfs # эрозияЗуд поколений и слив денег (0,2) Python
Считается fingers_short = 0,8·generations, и F_dacha увеличивается на 0,1 от этого значения. Затем money_wasted = 0,2·income, и F_dacha уменьшается на половину money_wasted. Фрагмент не запустится сам: generations, income и F_dacha нигде не заданы.
# Зуд
fingers_short = 0.8 * generations # 80% рефлекс
F_dacha += 0.1 * fingers_short
# Слив бабла
money_wasted = 0.2 * income # 20% на "росу"
F_dacha -= money_wasted * 0.5Искажённое плодородие и возврат Python
Считается distortion = 0,3·climate_south + 0,4·tax_jan, затем F_distorted = F0·(1 − distortion). После этого ritual_return = 0,4·dacha_60 и F_total = F_distorted + ritual_return. Фрагмент не запустится сам: climate_south, tax_jan, F0 и dacha_60 нигде не заданы.
# Искажения
distortion = climate_south * 0.3 + tax_jan * 0.4
F_distorted = F0 * (1 - distortion)
# Возврат
ritual_return = dacha_60 * 0.4
F_total = F_distorted + ritual_returnДиссонанс стресса: поправка 0,042 Python
Задаются stress_host = 0,8 и stress_native = 0,2, считается dissonance = (0,8 − 0,2)·0,7 = 0,42, и F_total уменьшается на 0,042. Фрагмент остановится с ошибкой на последней строке, так как F_total нигде не задана.
# Диссонанс
stress_host = 0.8
stress_native = 0.2
dissonance = (stress_host - stress_native) * 0.7
F_total -= dissonance * 0.1Граница шамана и квартиры (короткий) Python
Два варианта «границы»: boundary = blood_ritual·1,0 при F_tribe = 0,95 и затем boundary = plastic_toys·0,1 при F_tribe = 0,4. Вторые значения затирают первые. Фрагмент остановится с ошибкой, потому что blood_ritual и plastic_toys нигде не заданы.
# Шаман
boundary = blood_ritual * 1.0
F_tribe = 0.95
# Dead Morose
boundary = plastic_toys * 0.1
F_tribe = 0.4Барщина и ростовщики: оброк 40% Python
Фрагмент, не запустится отдельно (salary и F_tribe не заданы). Считает «оброк» как 40% зарплаты и уменьшает F_tribe на оброк·0,15, то есть на 0,06·salary; значения parents_time = 0,1 и F_family = 0,2 только присваиваются.
# Барщина
obrok = salary * 0.4
parents_time = 0.1
F_family = 0.2
# Ростовщики
credit_rate = 0.15
F_tribe -= obrok * credit_rateКрестьяне 1812: месть и потери французов Python
Задаются rage = 1,0, prisoners = 0,2 (дальше не используется) и kill_rate = 1,0·0,8 = 0,8. Затем french_loss = kill_rate·foragers. Фрагмент остановится с ошибкой на последней строке, так как foragers нигде не задана.
# Крестьяне (1812)
rage = 1.0 # мстительность
prisoners = 0.2 # 20% берут в плен
kill_rate = rage * 0.8 # 80% истребляют
french_loss = kill_rate * foragers # ~10kРазинцы 1670: месть и потери бояр Python
Задаются rage = 1,0, prisoners = 0,1 (дальше не используется) и kill_rate = 1,0·0,9 = 0,9. Затем elite_loss = kill_rate·boyars. Фрагмент остановится с ошибкой на последней строке, так как boyars нигде не задана.
# Разинцы (1670)
rage = 1.0 # месть за оброк
prisoners = 0.1 # 10% в плен
kill_rate = rage * 0.9 # 90% истребляют
elite_loss = kill_rate * boyars # ~10kАполлон и Шмита: отношение 12 к 7 Python
Задаются solar_cycle = 12, power = 12, earth_cycle = 7 и rage = 1. Затем french_loss = 1·(12/7) ≈ 1,71. Фрагмент выполняется без ошибок и ничего не выводит.
# Аполлон (12)
solar_cycle = 12 # месяцев/рыцарей
power = solar_cycle * 1.0
# Сентябрь (7)
earth_cycle = 7 # Шмита
rage = 1.0
french_loss = rage * (power / earth_cycle) # 12/7 ≈ 1.7x крах Крестьяне и Суворов: агрессия и рекруты Python
Задаются hunger = 0,8, expropriation = 0,7, aggression = 0,8 + 0,7 = 1,5 и service = 1,0. Затем mlk = 0,25·children. Фрагмент остановится с ошибкой на последней строке, так как children нигде не задана.
# Крестьяне
hunger = 0.8 # голодомор
expropriation = 0.7 # изъятия
aggression = hunger + expropriation # 1.5 → кишки
# Суворов (Рим)
service = 1.0 # выслужился
mlk = 0.25 * children # 25% в рекрутыБородино: миф и реальная война Python
Задаются borodino_myth = 0,3, french_loss = 0,7, rage = 1,0 и real_war = 1,0·1,0 = 1,0. Фрагмент выполняется без ошибок и ничего не выводит.
# Аполлон (миф)
borodino_myth = 0.3 # 30% реальности
french_loss = 0.7 # 70% от партизан
# Партизаны (правда)
rage = 1.0
real_war = rage * 1.0 # 100%Голод на пути к Смоленску и дальше Python
Задаются salo_promise = 1,0, food_real = 0,1, road_shit = 0,9 и road_worse = 1,0. Затем hunger = 1,0 − 0,1 + 0,9 + 1,0 = 2,8; также задано december = 1,0. Фрагмент выполняется без ошибок и ничего не выводит.
# Мы + Наполеон
salo_promise = 1.0 # "много сала"
food_real = 0.1 # фрукты-млеко
road_shit = 0.9 # до Смоленска
road_worse = 1.0 # от Смоленска
hunger = salo_promise - food_real + road_shit + road_worse # 2.8
december = 1.0 # морозДорога туда и обратно: голод 2,9 Python
Задаются food_there = 0,8, weather = 0,7, peasants_have = 1,0 для пути «туда» (дальше не используются), а затем know_we_shit = 1,0, hide = 0,9, shake_ass = 1,0. Считается hunger_back = 1,0 + 0,9 + 1,0 = 2,9. Фрагмент выполняется без ошибок и ничего не выводит.
# Туда (жир)
food_there = 0.8 # мяско-млеко
weather = 0.7
peasants_have = 1.0
# Обратно (дичь)
know_we_shit = 1.0
hide = 0.9
shake_ass = 1.0
hunger_back = know_we_shit + hide + shake_ass # 2.9Подъём и спуск: доля трупов Python
Задаются ascent_food = 0,8, ascent_risk = 0,2, peak_pigout = 1,0 (все три дальше не используются), descent_risk = 0,9 и partisans = 1,0. Считается corpses = 0,9 + 1,0 = 1,9; число 80 %, названное в комментарии, нигде не вычисляется. Фрагмент выполняется без ошибок и ничего не выводит.
# Подъём
ascent_food = 0.8
ascent_risk = 0.2
# Вершина
peak_pigout = 1.0
# Спуск
descent_risk = 0.9
partisans = 1.0
corpses = descent_risk + partisans # 1.9 → 80% труповПропаганда и тишина стихии Python
Задаются victory_narrative = 0,1, hymns = 0,0, element_rage = 1,0 и silence = 1,0 − 0,1 = 0,9. Фрагмент выполняется без ошибок и ничего не выводит.
# Франшиза (пропаганда)
victory_narrative = 0.1 # 10% усилий
hymns = 0.0
# Стихия (крестьяне)
element_rage = 1.0
silence = 1.0 - victory_narrative # 0.9Наступление и отступление: 90% потерь Python
Задаются advance = 1,0, peak = 0,5 (дальше не используется) и retreat_risk = 0,9. Считается corpses = 1,0·0,9 = 0,9. Фрагмент выполняется без ошибок и ничего не выводит.
# Наполеон/Пригожин (подъём)
advance = 1.0 # "мяско-млеко"
peak = 0.5 # Москва/остановка
# Спуск (стихия)
retreat_risk = 0.9 # мороз/партизаны
corpses = advance * retreat_risk # 90% труповСолнцестояние и спуск: потери 72% Python
Задаются peak_sun = 1,0, apollon_entry = 1,0·0,8 = 0,8 и shmita_kishki = 0,9. Считается corpses = 0,8·0,9 = 0,72 (в числах с плавающей точкой получится 0,7200000000000001). Фрагмент выполняется без ошибок и ничего не выводит.
# Солнцестояние (24 июня)
peak_sun = 1.0 # пик Аполлона
apollon_entry = peak_sun * 0.8 # 80% силы
# Спуск (стихия)
shmita_kishki = 0.9 # крестьяне/вагнеровцы
corpses = apollon_entry * shmita_kishki # 0.72 = 72% крахТри сферы и иезуитская адаптация Python
Задаются spheres = 3, ritual = 1,0 и jesuit_adapt = 3/2 = 1,5. Затем kastration = 1,0 − 1,5 = −0,5; в комментарии названо 0,5, но по арифметике получается минус 0,5. Фрагмент выполняется без ошибок и ничего не выводит.
# Шаман (местное)
spheres = 3 # Явь-Навь-Правь
ritual = 1.0
# Иезуиты (адаптация)
jesuit_adapt = spheres / 2 # 1.5 → грех
kastration = ritual - jesuit_adapt # 0.5Явь, Навь, Правь: проверка и устойчивость Python
Задаются prav = 1,0, yav = 0,8 и nav = 0,9. Затем test = 0,9, maaser = 0,9·0,3 = 0,27 и F = 1,0 + 0,8 − 0,27 = 1,53. Фрагмент выполняется без ошибок и ничего не выводит.
# Три сферы
prav = 1.0 # закон Шмиты
yav = 0.8 # видимый ритуал
nav = 0.9 # проверка кишками
# Проверка
test = nav * 1.0
maaser = test * 0.3 # 30% в кишки
F = prav + yav - maaser # устойчивостьТриггер, гипноз и потеря памяти Python
Фрагмент, запускающийся без ошибок и без вывода: rage = 1,5, hypnosis = 1,5·0,8 = 1,2, memory_loss = 1,2·0,9 = 1,08, kishki = 1,5 − 1,08 = 0,42.
# Триггер (насилие)
violation = 1.0 # Родина-Мать
rage = violation * 1.5 # +50% адреналин
# Мерячение
hypnosis = rage * 0.8 # 80% транс
memory_loss = hypnosis * 0.9 # 90% амнезия
kishki = rage - memory_loss # маасерГрок и гора Меру
Схема TikZ: уровень комфорта и исход LaTeX
Рисунок: оси «Уровень комфорта» и «Вероятность исхода» и кривая с пиком посередине, подписанная «Парадокс: пик в “среднем”»; сверху надпись «Теснота + зов».
\begin{tikzpicture}
\draw[->] (0,0) -- (10,0) node[right] {Уровень комфорта};
\draw[->] (0,0) -- (0,5) node[above] {Вероятность Исхода};
\draw (2,1) .. controls (5,4) .. (8,1) node[below] {Парадокс: пик в "среднем"};
\node at (5,4.5) {Теснота + зов};
\end{tikzpicture}Грок и гора Соломона
Симуляция цивилизаций: 1000 бросков Python
Бросает 1000 раз «монету» с исходами 0 (вероятность 0,04) и 1 (0,96) и печатает, сколько единиц выпало, в виде «Успешных цивилизаций: N/1000». Зерно не задано, число каждый раз немного разное, около 960; в комментарии записано 958/1000.
import numpy as np
cycles = np.random.choice([0,1], size=1000, p=[0.04, 0.96])
print(f"Успешных цивилизаций: {cycles.sum()}/1000")
# Вывод: 958/1000Выбор по мотивации: три ветви Python
Одна строка-комментарий: в ней нет вычислений, при запуске ничего не происходит.
if мотивация < 0.5: выбор = Ш1
elif мотивация > 0.7: выбор = Ш2
else: микс = α*Ш1 + (1-α)*Ш2