從選擇的熵到效用函數的愛 — 一種新模型，適用於哲學家、物理學家和機器學習工程師

前言

在前一篇論文（《變分計算作為選擇自由的隱喻》）中，我們提出了概念上的類比：在障礙物場中尋找路徑 — 這是人生選擇的隱喻，而添加隨機性（變異性） — 是自由意志的數學類似物。

不過，這個比喻仍然只是比喻。公式描述了路徑，卻沒有描述它的 價值。演算法找到了軌跡，卻無法區分「好的」選擇與「壞的」。而「愛」、「罪」和「建築師」這些概念則被排除在外——屬於純粹哲學的領域.

新文章的目標是進行下一步.

我們將建立 一個形式化的數學模型 《朝聖者的信仰—源起》，並對

• 可能的人生軌跡空間、

• 選擇的熵作為自由度的衡量、

• 愛的效用函數作為生命的目標函數、

• 罪惡的程度作為對他人熵的減少、

• 建築師作為可能性空間的創造者，而非程式設計師，進行了嚴格的定義。

我們並不主張「哲學上的證明」形而上学。我們提供 一個工作假說，它：

1. 對程式設計師和機器學習工程師有用 — 提供了一種語言來描述搜索中的diversity、隨機優化和multi-agent系統.

2. 對哲學家來說有趣 — 確立了自由、罪與愛的概念，這些概念通常停留在質性思考的範疇內.

3. 物理學家們明白 — 使用變分計算、熵及最小作用原理.

4. 對形而上學家們誠實 — 不隱瞞自己與特定宗教體系的聯繫，但也不強加給他人.

我們也將進行 在MATLAB進行計算實驗，以展示所引入的公式在實際中的運作方式。我們不會「證明」神的存在或自由意志的存在。我們只需展示：

• 如果接受「朝聖者之信」的公理，則會導出某些數學關係

• 這些關係可以在簡單模型上進行數值驗證。

• 實驗結果並不違反原始公理，甚至還能直觀地說明它們。

研究的目標與任務

文章的目標

開發並提出「朝聖者之信——源頭」形而上學的正式數學模型，引入新的符號和自由選擇、生命旅程有用性及「罪」的量化度量，並在 MATLAB 中通過計算實驗展示該模型的運作。

任務

1. 形式化本體論 —確定可能的生命軌跡空間 Ω 具邊界條件與限制.

2. 引入選擇的熵 SS 作為自由意志的衡量標準，並證明決定論對應 S=0，而完全自由則是 S=Smax​.

3. 構建愛的效用函數 U(γ)，使用光滑拉格朗日量。 L, 與傳統宗教的「障礙」功能進行比較。

4. 定義罪惡 ΔS罪惡​ 為減少另一個人（或代理）選擇的熵的行為，並形式化這個概念。

5. 闡述建築師 A 作為創造可能性空間、初始條件和規則的角色，但不是嚴格的軌跡。

   1. 在 MATLAB 中實現計算實驗：

      • 生成多個障礙場中的可能路徑

      • 評估路徑分佈的熵

      • 計算每條路徑的效用

      • 將「錯誤」模擬為強制單一路徑並測量熵的變化

   2. 分析結果 並做出結論關於該模型對於哲學和技術討論的適用性.

邀請您了解文章的結構：

文章結構

1. 引言 （當前部分）— 提出問題、目標和任務.

2. 第一部分。公式中的本體論：可能途徑的空間
   形式定義 Ω, 邊界條件和限制。符號 Ω的引入.

3. 第二部分。選擇的熵：自由度度量
   分配 p(γ), 熵 S, 决定論和自由的解釋.

4. 第三部分。愛的效用函數：生命的目標函數
   拉格朗日函數 L, 函數泛函 U(γ), 光滑度與障礙.

5. 第四部分. 罪惡作為熵減少 (原始概念)
   定義. ΔS罪惡, 例子與討論.

6. 第五部分. 建築師作為空間創造者 (非程式設計師)
   符號 A, 與傳統神學比較.

7. 第六部分. MATLAB中的計算實驗
   模型描述、程式碼、圖表及結果分析.

8. 結論
   新公式的總結，回答「這一切是為何」的問題.

數學總結（預備

那麼，開始吧。

第一部分。公式中的本體論：可能路徑的空間

1.1. 为何需要形式化的本體論

在引入自由度（熵）、有用性（愛）或「罪」之後，我們必須回答一個基礎問題：

從數學角度來看，「生命軌跡」究竟是一種什麼樣的東西？

在經典物理學中，物質點的軌跡是一個函數 r(t)r(t), 滿足運動方程式。在經濟學中—這是一系列選擇，最大化效用。在機器學習中—這是參數空間中的一條路徑，最小化損失函數.

在我們的形而上学「朝聖者的信仰—源頭」 中，路徑 —是狀態空間中的一條連續曲線，連接誕生 A 與死亡（或設定的目標） B，不跨越禁止區域 O （現實的限制）。

但與物理學不同，在物理學中軌跡 是唯一的 （決定論），我們假設，在一般情況下存在 多個選項 可能的途徑。更進一步說，選擇其中之一——就是 自由意志。

1.2. 空間 ΩΩ

的正式定義。

• t — 時間， t∈[0,T]，其中 0 — 個體誕生的時刻， T — 死亡時刻（或規劃時間軸）。

• γ(t) — 描述人在 t （物理、心理、社會、精神）狀態的向量。狀態空間的維度 n 可以是任意值，但為了直觀，我們將使用 n=2。 （平面上的坐標）。

• A=γ(0) — 初始狀態（誕生）。

• B=γ(T) — 終止狀態（死亡或達成目標）。

• O — 多集合「禁止」狀態，無法或不需要訪問（疾病、違反法律、社會禁忌）。

定義 1. 可能的生命軌跡空間 Ω — 這是所有滿足邊界條件和限制的連續函數 γ(t)的集合，

1.3. 以例子說明

考慮最簡單的情況： n=2，場 20×20，障礙 O — 三個圓形和一個矩形, A — 左下角, B — 右上角.

下方展示的是 MATLAB 程式碼，它對空間進行離散化並視覺化幾個來自 Ω 的例子路徑（當然不是全部，僅僅是幾個隨機的）。

% ========================================================================
% 1.3. Визуализация пространства Ω на дискретной сетке
% ========================================================================

clear; clc; close all;

% Размер сетки
N = 30;
x = linspace(0, 20, N);
y = linspace(0, 20, N);
[X, Y] = meshgrid(x, y);

% Препятствия
obstacleMap = zeros(N);
for i = 1:N
    for j = 1:N
        if sqrt((X(i,j)-5)^2 + (Y(i,j)-5)^2) < 2
            obstacleMap(i,j) = 1;
        end
        if sqrt((X(i,j)-12)^2 + (Y(i,j)-12)^2) < 1.5
            obstacleMap(i,j) = 1;
        end
        if sqrt((X(i,j)-17)^2 + (Y(i,j)-7)^2) < 1.8
            obstacleMap(i,j) = 1;
        end
        if X(i,j) > 7 && X(i,j) < 11 && Y(i,j) > 14 && Y(i,j) < 18
            obstacleMap(i,j) = 1;
        end
    end
end

% Старт и финиш (исправлено: [строка, столбец])
start = [N, 1];  % левый нижний угол
goal = [1, N];   % правый верхний угол

% Проверка, что старт и финиш не в препятствиях
if obstacleMap(start(1), start(2)) == 1 || obstacleMap(goal(1), goal(2)) == 1
    error('Старт или финиш находятся внутри препятствия!');
end

% Поиск кратчайшего пути (BFS)
[path_det, ok] = bfs_path(obstacleMap, start, goal);

% Генерация нескольких альтернативных путей
numPaths = 5;
paths = cell(numPaths, 1);
for k = 1:numPaths
    [p, ~] = var_path(obstacleMap, start, goal, 0.5 + k*0.1);
    paths{k} = p;
end

% Визуализация
figure('Name', 'Пространство возможных путей Ω', 'NumberTitle', 'off');
imagesc(x, y, obstacleMap');
colormap([1 1 1; 0.5 0.5 0.5]);
axis xy; axis equal;
title('\Omega: множество возможных траекторий');
xlabel('X'); ylabel('Y');
hold on;

% Рисуем детерминированный путь
if ok && ~isempty(path_det)
    plot(path_det(:,2), path_det(:,1), 'b-', 'LineWidth', 2);
end

% Рисуем альтернативные пути
colors = ['r', 'g', 'c', 'm', 'y'];
for k = 1:numPaths
    if ~isempty(paths{k})
        plot(paths{k}(:,2), paths{k}(:,1), '--', 'Color', colors(mod(k-1,5)+1), 'LineWidth', 1.5);
    end
end

plot(x(start(2)), y(start(1)), 'go', 'MarkerSize', 10, 'LineWidth', 2);
plot(x(goal(2)), y(goal(1)), 'ro', 'MarkerSize', 10, 'LineWidth', 2);
legend('Оптимальный путь', 'Альтернативные пути', 'Старт', 'Финиш', 'Location', 'best');
hold off;

disp('Готово!');

% ========================================================================
% Функция BFS для поиска кратчайшего пути
% ========================================================================
function [path, found] = bfs_path(map, start, goal)
    [rows, cols] = size(map);
    
    % Направления: вверх, вниз, влево, вправо
    directions = [-1 0; 1 0; 0 -1; 0 1];
    
    % Очередь для BFS
    queue = [start, 0];  % [row, col, distance]
    visited = false(rows, cols);
    parent = zeros(rows, cols, 2);  % для восстановления пути
    
    visited(start(1), start(2)) = true;
    found = false;
    
    while ~isempty(queue)
        current = queue(1, :);
        queue(1, :) = [];
        
        if current(1) == goal(1) && current(2) == goal(2)
            found = true;
            % Восстановление пути
            path = reconstruct_path(parent, start, goal);
            return;
        end
        
        % Проверка соседей
        for d = 1:4
            newRow = current(1) + directions(d, 1);
            newCol = current(2) + directions(d, 2);
            
            if newRow >= 1 && newRow <= rows && newCol >= 1 && newCol <= cols
                if ~visited(newRow, newCol) && map(newRow, newCol) == 0
                    visited(newRow, newCol) = true;
                    parent(newRow, newCol, 1) = current(1);
                    parent(newRow, newCol, 2) = current(2);
                    queue(end+1, :) = [newRow, newCol, current(3)+1];
                end
            end
        end
    end
    
    path = [];
    found = false;
end

% ========================================================================
% Функция восстановления пути
% ========================================================================
function path = reconstruct_path(parent, start, goal)
    path = [goal];
    current = goal;
    
    while ~(current(1) == start(1) && current(2) == start(2))
        prevRow = parent(current(1), current(2), 1);
        prevCol = parent(current(1), current(2), 2);
        
        if prevRow == 0 && prevCol == 0
            break;  % нет пути
        end
        
        current = [prevRow, prevCol];
        path = [current; path];
    end
end

% ========================================================================
% Функция генерации альтернативных путей (вариационный метод с шумом)
% ========================================================================
function [path, success] = var_path(map, start, goal, noise_level)
    % Сначала находим оптимальный путь через BFS
    [opt_path, found] = bfs_path(map, start, goal);
    
    if ~found
        path = [];
        success = false;
        return;
    end
    
    % Добавляем случайные отклонения от оптимального пути
    path = opt_path;
    
    % Для каждого внутреннего узла (не старт и не финиш) добавляем случайное смещение
    for i = 2:size(path, 1)-1
        % Пробуем сместиться в случайном направлении
        for attempt = 1:10  % несколько попыток
            delta_row = randi([-1, 1]) * noise_level;
            delta_col = randi([-1, 1]) * noise_level;
            
            new_row = round(path(i, 1) + delta_row);
            new_col = round(path(i, 2) + delta_col);
            
            % Проверка границ и препятствий
            if new_row >= 1 && new_row <= size(map, 1) && ...
               new_col >= 1 && new_col <= size(map, 2) && ...
               map(new_row, new_col) == 0
                path(i, 1) = new_row;
                path(i, 2) = new_col;
                break;
            end
        end
    end
    
    % Убираем повторяющиеся точки
    path = unique(path, 'rows', 'stable');
    success = true;
end

結果： 在圖表（圖1）中展示了幾個 Ω元素。 — 確定性（藍色）與替代（彩色虛線）路徑，繞過障礙物。請注意：它們都不同，但都滿足邊界條件且不與障礙物相交。

1.4. 邊界條件作為形而上學常數

在我們的形而上學中 AA 和 BB 已設定。人類無法選擇自己的出生，也（通常）無法選擇死亡。但之間的一切—— 自由之場——是

• A ——建築師的賜予。起始條件（家庭、健康、天賦）無法選擇，但它們並不決定嚴格的途徑。

• B—可能既是客觀的死亡，也是主觀的目標（「生命的意義」）。在後者情況下，人可以選擇 B，但這已經是路徑的一部分。

1.5. 限制 O：自然法則和社會規範

O —這些是「空間 Ω的牆壁」。它們不能被忽略。在我們的模型中：

• 物理限制： 萬有引力、資源有限、疾病.

• 社會限制： 法律、規範、禁忌.

• 道德限制： 在《朝聖者的信仰》中，它們不是外在的，而是內在的（良心）。

重點： O 並不使道路唯一。它僅僅收窄了可能性空間。

1.6. 這個定義對以下部分

1. 選擇的熵 S (第二部分)將是衡量 p(γ) 在 Ω.

2. 上的概率分佈均匀程度的指標。 效用函數 U(γ) (第三部分)將是對__JHSNS_SEG_47ae784f_213__γ的積分。 — 也就是在 Ω上的功能.

3. 罪 ΔS罪 (第四部分)將會測量單一代理人的行為如何收窄 Ω 對方的.

1.7. 第一部分簡要總結

• 我們正式定義了 可能的生命軌跡空間 Ω.

• Ω 取決於 邊界條件 A,B и 限制 喔.

• 在典型配置中 Ω 包含 無限多 元素是自由選擇的數學表達式。

• MATLAB 的視覺化直觀地展示了多種路徑。

我們進入第二部分： 現在，當可能性空間確定後，我們將引入 選擇的熵 S —衡量人類在決策上自由程度的指標。

第二部分。選擇的熵：自由度的指標

2.1. 從可能性空間到機率分配

在第一部分中，我們定義了可能的生命軌跡空間 Ω —滿足邊界條件和限制的所有路徑的集合。然而，僅僅知道 Ω 包含很多元素，還不能提供選擇自由度的量化度量 .

的確，想像兩種情況：

1. 所有來自 Ω 的途徑都是等可能的. 人確實可以選擇任何一個——這是最大的自由.

2.  Ω 中的一條途徑具有接近1的機率，而所有其他的幾乎是0. 形式上 Ω 仍然包含很多元素，但實際上沒有選擇的空間.

因此，我們需要 概率分佈 p(γ) 在集合 Ω__上.__它反映了人（或算法）選擇特定軌跡的頻率.

備註： 對於人 p(γ) — 是一種主觀的自由度（我多麼願意選擇不同的選項）。對於算法（例如，路徑搜索）— 這是在隨機參數變化的情況下產生軌跡的客觀頻率.

2.2. 選擇的熵定義

在信息理論中，香農熵是衡量分配不確定性的度量。對於連續空間 Ω (路徑連續體) 它被定義為：

這裡積分是對所有可能的軌跡進行的。對於離散化空間（如在MATLAB實驗中）積分被替換為對所有找到的路徑的總和，而 p(γ) 被估計為變分算法多次執行時每個路徑出現的頻率。

熵 S的性質：

• S≥0.

• S=0 當且僅當分佈是退化時：一條路徑具有概率 1，所有其他路徑 — 0。這是 完全決定論.

• S=Smax​ 當所有可能的路徑都等概率時達到。這是 最大自由度 (在固定集合中) Ω).

2.3. 决定論是特殊情況

在經典路徑搜尋算法（例如，無隨機性的BFS）中，分配 p(γ) 是退化：

因此， S=0。這是沒有選擇的數學表達式。

在傳統宗教中，「正確的道路」已被永遠設定（教條、戒律），而任何偏離都被視為罪惡，事實上假設了 S=0。選擇是虛假的.

2.4. 自由作為高熵

在《朝聖者的信仰——出埃及記》中，自由並非缺乏限制，而是 存在多樣性。熵越高 S，人類的自由度就越多.

如果 S 接近 Smax​，那麼人類確實可以從許多平等（從某些標準來看）的道路中選擇.

值得注意的是，高熵並不意味著混亂。它意味著 可能性豐富。. 正是從這份豐富中誕生了創造力、愛、責任感.

2.5. 計算實驗：在 MATLAB 中評估熵

我們將修改第一部分的變分算法，以達到：

1. 生成 N 個不同路徑（更改隨機數的種子）。

2. 評估每個路徑的頻率。

3. 計算 S 的熵

% ========================================================================
% 2.5. Оценка энтропии выбора
% ========================================================================

clear; clc; rng(42);

% Создание карты препятствий
N = 30;
x = linspace(0, 20, N);
y = linspace(0, 20, N);
[X, Y] = meshgrid(x, y);

obstacleMap = zeros(N);
for i = 1:N
    for j = 1:N
        if sqrt((X(i,j)-5)^2 + (Y(i,j)-5)^2) < 2 || ...
           sqrt((X(i,j)-12)^2 + (Y(i,j)-12)^2) < 1.5 || ...
           sqrt((X(i,j)-17)^2 + (Y(i,j)-7)^2) < 1.8 || ...
           (X(i,j) > 7 && X(i,j) < 11 && Y(i,j) > 14 && Y(i,j) < 18)
            obstacleMap(i,j) = 1;
        end
    end
end

start = [N, 1]; 
goal = [1, N];

% Генерация множества путей
N_paths = 200;
paths = cell(N_paths, 1);

fprintf('Генерация %d путей...\n', N_paths);
for i = 1:N_paths
    if mod(i, 50) == 0
        fprintf('  Прогресс: %d/%d\n', i, N_paths);
    end
    paths{i} = var_path(obstacleMap, start, goal, 0.5);
end

% Фильтрация пустых путей
valid_paths = paths(~cellfun(@isempty, paths));
fprintf('Успешно сгенерировано: %d/%d\n', length(valid_paths), N_paths);

% Преобразование путей в уникальные строковые ключи
path_keys = cell(length(valid_paths), 1);
for i = 1:length(valid_paths)
    p = valid_paths{i};
    % Создаем ключ как строку координат
    key = '';
    for j = 1:size(p, 1)
        key = [key, sprintf('(%d,%d)', p(j,1), p(j,2))];
    end
    path_keys{i} = key;
end

% Подсчет уникальных путей
[unique_keys, ~, ic] = unique(path_keys, 'stable');
counts = accumarray(ic, 1);
probs = counts / sum(counts);

% Энтропия Шеннона
entropy = -sum(probs .* log2(probs));

% Результаты
fprintf('\n========== РЕЗУЛЬТАТЫ ==========\n');
fprintf('Сгенерировано путей: %d\n', N_paths);
fprintf('Уникальных путей: %d\n', length(unique_keys));
fprintf('Энтропия выбора: %.4f бит\n', entropy);
fprintf('Макс. возможная энтропия: %.4f бит\n', log2(length(unique_keys)));
fprintf('Относительная энтропия: %.2f%%\n', entropy/log2(length(unique_keys))*100);
fprintf('================================\n');

% Визуализация
figure('Name', 'Распределение путей', 'Position', [100, 100, 800, 400]);

subplot(1,2,1);
bar(probs(1:min(10, length(probs))));
title(sprintf('Распределение вероятностей (H = %.4f бит)', entropy));
xlabel('Тип пути');
ylabel('Вероятность');
grid on;

subplot(1,2,2);
stairs(cumsum(sort(probs, 'descend')), 'LineWidth', 2);
title('Кумулятивное распределение');
xlabel('Количество типов путей');
ylabel('Суммарная вероятность');
grid on;
xlim([1, length(probs)]);

disp('Готово!');

% ========================================================================
% ФУНКЦИИ
% ========================================================================

function [path, found] = bfs(map, start, goal)
    [rows, cols] = size(map);
    directions = [-1 0; 1 0; 0 -1; 0 1];
    
    queue = start;
    visited = false(rows, cols);
    visited(start(1), start(2)) = true;
    parent = zeros(rows, cols, 2);
    found = false;
    
    while ~isempty(queue)
        current = queue(1, :);
        queue(1, :) = [];
        
        if isequal(current, goal)
            found = true;
            path = reconstruct_path(parent, start, goal);
            return;
        end
        
        for d = 1:4
            nr = current(1) + directions(d, 1);
            nc = current(2) + directions(d, 2);
            
            if nr >= 1 && nr <= rows && nc >= 1 && nc <= cols
                if ~visited(nr, nc) && map(nr, nc) == 0
                    visited(nr, nc) = true;
                    parent(nr, nc, 1) = current(1);
                    parent(nr, nc, 2) = current(2);
                    queue(end+1, :) = [nr, nc];
                end
            end
        end
    end
    
    path = [];
    found = false;
end

function path = reconstruct_path(parent, start, goal)
    path = goal;
    current = goal;
    
    while ~isequal(current, start)
        prev = [parent(current(1), current(2), 1), parent(current(1), current(2), 2)];
        if all(prev == 0)
            break;
        end
        current = prev;
        path = [current; path];
    end
end

function path = var_path(map, start, goal, sigma)
    [opt_path, ok] = bfs(map, start, goal);
    
    if ~ok || isempty(opt_path)
        path = [];
        return;
    end
    
    if size(opt_path, 1) <= 2
        path = opt_path;
        return;
    end
    
    path = opt_path;
    max_offset = max(1, round(sigma));
    
    for i = 2:size(path, 1)-1
        for attempt = 1:10
            dr = randi([-max_offset, max_offset]);
            dc = randi([-max_offset, max_offset]);
            
            nr = path(i, 1) + dr;
            nc = path(i, 2) + dc;
            
            if nr >= 1 && nr <= size(map, 1) && ...
               nc >= 1 && nc <= size(map, 2) && ...
               map(nr, nc) == 0
                path(i, :) = [nr, nc];
                break;
            end
        end
    end
    
    % Удаление последовательных дубликатов
    unique_path = path(1, :);
    for i = 2:size(path, 1)
        if ~isequal(path(i, :), unique_path(end, :))
            unique_path(end+1, :) = path(i, :);
        end
    end
    path = unique_path;
end

分析結果：

• 200 次執行都產生了獨特的路徑 沒有一次重複

• 熵達到了理論上的最大值 對於此集合的路徑（log⁡2200≈7.64）。

• 這意味著 路徑的分佈是均勻的：所有可用的軌跡是等概率的。

當 σ = 0（確定性算法）：
Уникальных путей = 1, Энтропия = 0 бит, Относительная энтропия = 0% —完全的確定性。

當 σ 增加時，熵增加，追求最大值，該最大值由 Ω中可能的路徑數量決定。在我們的實驗中，我們達到了極限：算法研究所有可能性空間。

2.6. 超物理學中熵的解釋

在《朝聖者的信仰——源頭》中，熵 S —是 自由意志的度量。

• S=0 (決定論):
  按照嚴格劇本的生活，其中每個行為都被預定。人類如同木偶。自由是虛幻的.

• S=Smax​ (最大熵):
  自由的理想。在任何時刻，人類可以選擇任何一個允許的軌跡。所有可能性都是平等的（從自由的觀點來看，但不一定從價值的觀點來看）。

• 0<S<Smax​ (中間情況):
  部分自由。有些路徑比其他路徑更可能，但選擇仍然存在.

我們的實驗達到 極限情況 S=Smax. 這表明，即使在簡單的網格路徑搜索任務中也可能存在 完整的選擇多樣性。算法中沒有任何「隱藏的決定性」.

重點： 自由並非無所不能。限制 O （障礙物）並未消失。但在這些限制的範圍內存在 平等機會空間.

2.7. 從熵到效用

自由本身無法回答 「該選擇什麼？」的問題。如果所有路徑都是等概率的（S=Smax），那麼人類是自由的，但沒有指導方向。他需要 目標函數，它區分「好」的軌跡與「壞」的軌跡。

在下一節中，我們將介紹 效用函數愛 U(γ) — 一個類似拉格朗日函數的東西，它將評估路徑的價值.

2.8. 第二節簡要總結

• 分配 p(γ) 設定從 Ω

• 中選擇每個軌跡的概率.熵 S — 自由的量化度量： S=0S=0 對於決定論， S>0 對於自由。

• MATLAB 中的實驗顯示，當變異性足夠大（σ=0.8）時，算法達到 最大熵：所有200條路徑都是獨特的，分佈是均勻的.

• 在《朝聖者的信仰》的形而上学中，熵被解釋為 自由意志的程度.

 現在，當我們能夠測量選擇的自由時，我們需要理解， 哪條路徑更好。為此，我們將引入 愛的效用函數 U(γ) — 优化問題中的目標函數。

第三部分。愛的效用函數：生命的目標函數

3.1. 沒有目標的自由就是混亂

在第二部分，我們學會了測量 選擇的自由 的 SS。我們證明了，在空間 ΩΩ 中可能存在龐大（甚至無限）多個等概率的路徑。但自由本身無法回答問題： 「哪條路徑更好？」

如果給人無限多選擇卻不給評判標準，他就無法做出決定。他需要 目標函數 — 「羅盤」，指示方向.

在「朝聖者之信 — 出發」中，這個羅盤是 愛。無條件的愛，不要求犧牲，不進行交易，不威脅地獄.

3.2. 數學形式化：效用泛函

設每條路徑 γ(t)∈Ω 對應數字 U(γ)，表達其 價值 （效用、「愛的數量」）。

我們定義：

其中：

• L — 愛的拉格朗日量 （依賴於狀態、速度和時間的函數）；

• T — 生命線（死亡或達成目標）。

 U(γ)愈大，路徑愈「好」。

備註： 這是與 物理學中最小作用量原理 的直接類比，但差一個符號。那裡尋找作用量的最小值，這裡尋找有用性的最大值。

3.3. 選擇拉格朗日量：平滑性 vs 障礙物

在拉格朗日经典变分问题中 L — 是一個規定「遊戲規則」的函數。它的選擇決定了哪些路徑會被認為是最佳選項.

方案 A：光滑拉格朗日量（無條件的愛）

拉格朗日量是光滑的、連續的，並且沒有奇異的障礙。它可以依賴於：

• 自由 (熵 S),

• 創作 (行動多樣性),

• 愛近人 (與其他代理人之互動).

所有要素都是平滑函數。沒有無窮的罰款因「不聽話」。這符合一個理念： 神不懲罰，而是等待.

變種 Б: 隔離拉格朗日式 (傳統宗教)

拉格朗日式包含 奇點障礙 (超出範圍的無窮大罰款)。例如：

這導致了嚴格的決定性：任何偏離「正確」的途徑都具有無窮小的效用。這是 愛如交易: «聽從我 — 我會救你，不聽從 — 我會懲罰你».

3.4. 實驗中的例子：兩條具有不同效用值的路徑

我們回到有障礙物的場地。假設：

• 藍色路徑（確定性）— 路徑短，但它靠近「危險區域」（例如，靠近壓力來源）。

• 紅色路徑（變異性）— 路徑較長，但它通過「美麗的地方」（公園、寧靜）。

定義一個簡單的拉格朗日量：

其中 α 和 β — 是權重。

那麼，這裡我們想起過往有關路徑的文章（圖4），沒有讀過的請先了解，否則會不明白：

• 藍色路徑：長度較短，舒適度低 → 效用中等。

• 紅色路線：距離雖遠，但舒適度高 → 實用性可能更高（如果 β 足夠大）。

結論如下： 最佳路徑不僅取決於外部限制，也取決於內在價值體系（拉格朗日函數）。

3.5. 計算實驗：在MATLAB中評估實用性

我們為模型添加效用函數。讓每個場地格子擁有自己的「舒適度」（熱力圖）。那麼路徑的效用就是訪問過的格子舒適度總和減去長度罰分。

% ========================================================================
% 3.5. Оценка полезности пути
% ========================================================================

clear; clc; rng(42);

% Создание карты препятствий и поля комфорта
N = 30;
x = linspace(0, 20, N);
y = linspace(0, 20, N);
[X, Y] = meshgrid(x, y);

% Препятствия
obstacleMap = zeros(N);
for i = 1:N
    for j = 1:N
        if sqrt((X(i,j)-5)^2 + (Y(i,j)-5)^2) < 2 || ...
           sqrt((X(i,j)-12)^2 + (Y(i,j)-12)^2) < 1.5 || ...
           sqrt((X(i,j)-17)^2 + (Y(i,j)-7)^2) < 1.8 || ...
           (X(i,j) > 7 && X(i,j) < 11 && Y(i,j) > 14 && Y(i,j) < 18)
            obstacleMap(i,j) = 1;
        end
    end
end

% Поле комфорта (случайное с гладким градиентом)
comfort = imgaussfilt(randn(N), 5);
comfort = (comfort - min(comfort(:))) / (max(comfort(:)) - min(comfort(:)));

% Старт и финиш
start = [N, 1];
goal = [1, N];

% Поиск путей
[path_det, ~] = bfs(obstacleMap, start, goal);
path_var = var_path(obstacleMap, start, goal, 0.5);

% Функция полезности
alpha = 0.5;  % штраф за длину
beta = 1;     % коэффициент полезности комфорта

if ~isempty(path_det)
    idx_det = sub2ind(size(comfort), path_det(:,1), path_det(:,2));
    U_det = beta * sum(comfort(idx_det)) - alpha * size(path_det, 1);
else
    U_det = -inf;
end

if ~isempty(path_var)
    idx_var = sub2ind(size(comfort), path_var(:,1), path_var(:,2));
    U_var = beta * sum(comfort(idx_var)) - alpha * size(path_var, 1);
else
    U_var = -inf;
end

% Вывод результатов
fprintf('\n========== ПОЛЕЗНОСТЬ ПУТЕЙ ==========\n');
fprintf('Детерминированный путь: %.4f\n', U_det);
fprintf('Вариационный путь: %.4f\n', U_var);
fprintf('Разница: %.4f\n', U_var - U_det);
fprintf('=======================================\n');

% Визуализация
figure('Name', 'Поле комфорта и пути', 'Position', [100, 100, 800, 600]);
imagesc(x, y, comfort');
colorbar;
axis xy;
axis equal;
title('Поле комфорта (чем светлее, тем лучше)');
xlabel('X');
ylabel('Y');
hold on;

if ~isempty(path_det)
    plot(path_det(:,2), path_det(:,1), 'b-', 'LineWidth', 2.5);
end
if ~isempty(path_var)
    plot(path_var(:,2), path_var(:,1), 'r--', 'LineWidth', 2.5);
end

plot(x(start(2)), y(start(1)), 'go', 'MarkerSize', 12, 'LineWidth', 2);
plot(x(goal(2)), y(goal(1)), 'ro', 'MarkerSize', 12, 'LineWidth', 2);
legend('Детерминированный', 'Вариационный', 'Старт', 'Финиш', 'Location', 'best');
hold off;

% ========================================================================
% ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
% ========================================================================

function [path, found] = bfs(map, start, goal)
    [rows, cols] = size(map);
    dirs = [-1 0; 1 0; 0 -1; 0 1];
    queue = start;
    visited = false(rows, cols);
    visited(start(1), start(2)) = true;
    parent = zeros(rows, cols, 2);
    found = false;
    
    while ~isempty(queue)
        curr = queue(1,:);
        queue(1,:) = [];
        
        if isequal(curr, goal)
            found = true;
            path = goal;
            while ~isequal(curr, start)
                curr = squeeze(parent(curr(1), curr(2), :))';
                path = [curr; path];
            end
            return;
        end
        
        for d = 1:4
            nr = curr(1) + dirs(d,1);
            nc = curr(2) + dirs(d,2);
            if nr>=1 && nr<=rows && nc>=1 && nc<=cols && ~visited(nr,nc) && map(nr,nc)==0
                visited(nr,nc) = true;
                parent(nr,nc,:) = curr;
                queue(end+1,:) = [nr, nc];
            end
        end
    end
    path = [];
    found = false;
end

function path = var_path(map, start, goal, sigma)
    [opt, ok] = bfs(map, start, goal);
    if ~ok || size(opt,1) <= 2
        path = opt;
        return;
    end
    
    path = opt;
    for i = 2:size(path,1)-1
        for attempt = 1:10
            dr = randi([-round(sigma), round(sigma)]);
            dc = randi([-round(sigma), round(sigma)]);
            nr = path(i,1) + dr;
            nc = path(i,2) + dc;
            if nr>=1 && nr<=size(map,1) && nc>=1 && nc<=size(map,2) && map(nr,nc)==0
                path(i,:) = [nr, nc];
                break;
            end
        end
    end
    path = unique(path, 'rows', 'stable');
end

結果圖表和代碼結果：

結果： 根據 α  β 「最佳」可能會是兩條路徑中的任何一條。這說明了 最適性是主觀的。沒有一條「正確」的路徑適用於所有人 — 而是那條最大化你自身效用函數的路徑。

3.6. 與形而上學的關聯

在《朝聖者的信仰 — 出發》 愛 — 這不是順從的獎賞，而是 本身就是存在的結構。建築師創造了空間 Ω 並設定拉格朗日 L，其中：

• 沒有無窮的罰款（地獄作為永恆的懲罰）。

• 路徑的價值不由恐懼決定，而是 自由、 創造力 和 關心他人.

• 人可以自行選擇自己的重量 α,β 在自己的良知範圍內.

這是 圓滑的倫理觀 與 障壁式倫理觀 傳統宗教不同，後者認為任何「錯誤」的行為都會導致無盡的苦難。

3.7. 第三部分簡要總結

• 有用性功能 U(γ) 設定目標函數

• 拉格朗日函數 L 確定什麼是寶貴的：自由、創造力、愛近處的人

• 光滑拉格朗日函數 對應無條件的愛 障礙 — 對愛如交易（恐懼地獄）。

• MATLAB實驗 顯示，改變權重 α,β 可以使任何路徑變成「最佳」路徑。最優性是主觀的。

現在我們有了自由度的度量（熵）和價值的度量（效用），我們可以引入罪惡的概念  — 行為，會減少另一個人的自由。

第四部分。罪惡如同減少熵（原創概念)

4.1. 拒絕傳統的罪惡概念

在大多數宗教中 罪惡 — 這是違反神聖法律、禁止、戒律。罪惡會帶來懲罰（地獄、因果報應、轉世為低等生物）。這個模式提醒 法律體系：有規則，有違規，有處罰.

在《朝聖者的信仰—源頭》中，我們提供 另一種定義，不依賴於外在法律，而是基於 內在的自由度量.

罪過是一種行為，有意識地減少了選擇的熵 SS 另一個人（或另一個生物）。

換句話說，犯罪—就是 縮小另一方的可能性空間, 強加自己的意志於他，剝奪自由。

4.2. 形式定義

讓代理人到行動 X 選擇代理人的熵 Y 曾是 S到。行動之後— S後。那麼：

• 如果 ΔS罪>0 —熵 Y 減少了，自由度減少了。這是 罪 從 X那邊。.

• 若 ΔSгрех=0 — 極熵不變，自由保持原狀。這是中性行為.

• 若 ΔSгрех<0 — 極熵增加，自由 Y 提升。這是 福祉。

注意： 罪過不需要外在的審判者。它客觀地被測量為熵變化的變化。這不是「上帝將懲罰」，而是「你自己縮減了別人的自由，這是事實」.

4.3. 生活中的例子

例子 1：以懲罰為要挟強加道路

父母對孩子說：「你將成為醫生，否則我將剝奪你的繼承權」。可能職業的空間 Ω 對孩子來說，從多個選項縮減到一個。 S 的熵劇烈下降。這是 罪過，即使父母誠心希望孩子「好處」。

例子 2：關係中的操縱

「如果你愛我，你就會照我想要的做」。愛變成了強迫的工具。選擇伴侶的空間收縮了。這是 罪.

範例 3: 地獄的威脅

宗教體系說：『如果你不遵守儀式，你會在地獄中燒盡』。可能的人生道路空間 Ω 收縮成狹窄的小徑，任何偏離都會受到無盡痛苦的懲罰。選擇的熵降為零。這是 制度性的罪過，即使個別神父誠心誠意。

4.4. 與傳統概念的差異

4.5. 計算實驗：在MATLAB中模擬罪惡

我們可以將「罪惡」模擬為迫使代理人走唯一路徑.

假設有兩個代理人：

• 代理人 A （自由）尋找從起點到終點的路徑，使用變異算法（S≈Smax）。

• 代理人 B (罪人) 強加給代理 A 自身的唯一「正確」路徑 (例如，確定性的 BFS)。

衡量代理 A 在干預前後的選擇熵。

% ========================================================================
% 4.5. Моделирование греха
% ========================================================================

clear; clc; rng(42);

% Создание карты препятствий
N = 30;
x = linspace(0, 20, N);
y = linspace(0, 20, N);
[X, Y] = meshgrid(x, y);

obstacleMap = zeros(N);
for i = 1:N
    for j = 1:N
        if sqrt((X(i,j)-5)^2 + (Y(i,j)-5)^2) < 2 || ...
           sqrt((X(i,j)-12)^2 + (Y(i,j)-12)^2) < 1.5 || ...
           sqrt((X(i,j)-17)^2 + (Y(i,j)-7)^2) < 1.8 || ...
           (X(i,j) > 7 && X(i,j) < 11 && Y(i,j) > 14 && Y(i,j) < 18)
            obstacleMap(i,j) = 1;
        end
    end
end

start = [N, 1];
goal = [1, N];

% Параметры симуляции
N_sim = 100;
entropy_before = zeros(N_sim, 1);
entropy_after = zeros(N_sim, 1);

fprintf('Моделирование греха (%d симуляций)...\n', N_sim);

for sim = 1:N_sim
    if mod(sim, 20) == 0
        fprintf('  Прогресс: %d/%d\n', sim, N_sim);
    end
    
    % Генерируем множество свободных путей (без принуждения)
    paths_free = cell(200, 1);
    for i = 1:200
        paths_free{i} = var_path(obstacleMap, start, goal, 0.8);
    end
    
    % Энтропия до
    entropy_before(sim) = compute_entropy(paths_free);
    
    % Навязываем один «правильный» путь (детерминированный)
    fixed_path = bfs_path(obstacleMap, start, goal);
    
    paths_constrained = cell(200, 1);
    for i = 1:200
        if rand < 0.9   % 90% вероятности идти по навязанному пути
            paths_constrained{i} = fixed_path;
        else
            paths_constrained{i} = var_path(obstacleMap, start, goal, 0.8);
        end
    end
    
    % Энтропия после
    entropy_after(sim) = compute_entropy(paths_constrained);
end

% Результаты
delta_S = mean(entropy_before - entropy_after);
fprintf('\n========== РЕЗУЛЬТАТЫ ==========\n');
fprintf('Средняя энтропия до: %.4f бит\n', mean(entropy_before));
fprintf('Средняя энтропия после: %.4f бит\n', mean(entropy_after));
fprintf('Среднее уменьшение энтропии ΔS_грех = %.4f бит\n', delta_S);
fprintf('================================\n');

% Визуализация
figure('Name', 'Моделирование греха', 'Position', [100, 100, 800, 400]);

subplot(1,2,1);
histogram(entropy_before, 20, 'FaceColor', 'b', 'FaceAlpha', 0.5);
hold on;
histogram(entropy_after, 20, 'FaceColor', 'r', 'FaceAlpha', 0.5);
xlabel('Энтропия (бит)');
ylabel('Частота');
legend('До греха', 'После греха');
title('Распределение энтропии');
grid on;

subplot(1,2,2);
plot(1:N_sim, entropy_before, 'b.', 'MarkerSize', 10);
hold on;
plot(1:N_sim, entropy_after, 'r.', 'MarkerSize', 10);
xlabel('Номер симуляции');
ylabel('Энтропия (бит)');
legend('До греха', 'После греха');
title('Энтропия по симуляциям');
grid on;

disp('Готово!');

% ========================================================================
% ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
% ========================================================================

function [path, found] = bfs_path(map, start, goal)
    [rows, cols] = size(map);
    dirs = [-1 0; 1 0; 0 -1; 0 1];
    queue = start;
    visited = false(rows, cols);
    visited(start(1), start(2)) = true;
    parent = zeros(rows, cols, 2);
    found = false;
    
    while ~isempty(queue)
        curr = queue(1,:);
        queue(1,:) = [];
        
        if isequal(curr, goal)
            found = true;
            path = goal;
            while ~isequal(curr, start)
                curr = squeeze(parent(curr(1), curr(2), :))';
                path = [curr; path];
            end
            return;
        end
        
        for d = 1:4
            nr = curr(1) + dirs(d,1);
            nc = curr(2) + dirs(d,2);
            if nr>=1 && nr<=rows && nc>=1 && nc<=cols && ~visited(nr,nc) && map(nr,nc)==0
                visited(nr,nc) = true;
                parent(nr,nc,:) = curr;
                queue(end+1,:) = [nr, nc];
            end
        end
    end
    path = [];
    found = false;
end

function path = var_path(map, start, goal, sigma)
    [opt, ok] = bfs_path(map, start, goal);
    if ~ok || size(opt,1) <= 2
        path = opt;
        return;
    end
    
    path = opt;
    for i = 2:size(path,1)-1
        for attempt = 1:10
            dr = randi([-round(sigma), round(sigma)]);
            dc = randi([-round(sigma), round(sigma)]);
            nr = path(i,1) + dr;
            nc = path(i,2) + dc;
            if nr>=1 && nr<=size(map,1) && nc>=1 && nc<=size(map,2) && map(nr,nc)==0
                path(i,:) = [nr, nc];
                break;
            end
        end
    end
    path = unique(path, 'rows', 'stable');
end

function entropy = compute_entropy(paths)
    % Фильтрация пустых путей
    valid = ~cellfun(@isempty, paths);
    paths_valid = paths(valid);
    
    if length(paths_valid) < 2
        entropy = 0;
        return;
    end
    
    % Создание ключей для путей
    keys = cell(length(paths_valid), 1);
    for i = 1:length(paths_valid)
        p = paths_valid{i};
        key = '';
        for j = 1:size(p, 1)
            key = [key, sprintf('(%d,%d)', p(j,1), p(j,2))];
        end
        keys{i} = key;
    end
    
    % Подсчёт уникальных путей
    [~, ~, ic] = unique(keys, 'stable');
    counts = accumarray(ic, 1);
    probs = counts / sum(counts);
    
    % Энтропия Шеннона
    entropy = -sum(probs .* log2(probs));
end

結果分析：

• 在強制之前，代理 A 擁有幾乎 最大的自由度 (熵為 7.64 位元 — 所有 200 個路徑都是獨特的)。

• 在強加「正確」的道路後，熵跌至 0.92 位選擇空間收縮為一條主導路徑和罕見的偏離。

• 減少熵 ΔS罪孽≈6.73 位 — 這是 對自由造成的數量衡量，由「罪惡」代理人所施加的

結論： 強迫單一道路幾乎完全摧毀選擇自由。與最大值相比，熵減少了88%。這是對傳統宗教強加唯一「正確」道路，並以地獄相威脅所犯下的 巨大罪愆 對人類自由而言。

我們來到重點。

4.6. 賠罪與恢復熵

如果罪過是熵的減少，那麼 賠罪 — 這是它的恢復。

在我們的實驗中，如果「有罪」的代理停止強加自己的路徑並允許代理 A 再次自由選擇，熵將恢復到最初的 7.64 位。這就是 賠罪：回歸自由.

在《朝聖者的信仰》中，赦免並非「取消處罰」，而是 增加另一個人自由的行為.神並非在法律意義上赦免罪過。神創造了一個世界，其中熵能夠透過愛與意識恢復.

第五章。建築師作為空間的創造者（不是程式設計師）

5.1.「神程式設計師」的問題

在傳統宗教中，神常被描繪為 全能力且全知全能的程式設計師，他：

• 根據預先寫好的計畫創造了世界.

• 知道所有將會發生的事（包括我們的「自由」選擇）。

• 任何時候都可以介入並覆寫現實的程式碼。

這個模型產生了一個無法解決的悖論：如果神知道一切並掌控一切，那麼 自由意志——只是一種幻象。如果自由存在，那麼神要么不是全知，要么不是全能。神學家們世世代代都在爭論這個矛盾，卻找不到邏輯上無矛盾的答案.

《朝聖者的信仰——出埃及記》提出了 第三條道路，拒絕「神明程式設計師」的形象，改為採用「空間可能性建築師」 的形象。

5.2. 建築師的正式定義

在我們的模型中 建築師 — 不是個體，不是審判者，不是坐在寶座上的君主。它是 操作員，制定：

1. 可能軌跡空間 Ω (所有生命道路的集合)

2. 限制 O (自然法則、社會規範、疾病)

3. 效用函數 L (愛的拉格朗日函數)

4. 初始條件 A (誕生、啟動資金、才能).

5. 邊界條件 B (死亡或設定目標).

建築師 不選擇 具體軌跡 γ(t)γ(t). 他創造 潛能領域，其中人（代理人）自由尋找自己的道路.

備註： 物理學類比：建築師設定空間-時間和運動定律（艾爾拉格-拉格朗日方程式），但不為粒子求解。粒子「選擇」符合初始條件和最小作用原理的軌跡.

5.3. 與傳統神學比較

5.4. 但為何建築師不要求犧牲？

在傳統宗教中，神明經常「需要」犧牲、儀式、順從。這意味著神 體驗到需求 — 在崇拜、在血液、在遵守規則。

我們的模型中的建築師 在什麼方面都不需要。他是完美無缺的。他不會感到憤怒，不渴望讚美，也不害怕競爭。他只是創造了充滿可能性的空間 ΩΩ ，並給予代理選擇的自由.

結論： 這個系統中的愛情並非交易（「我給你——服從，你給我——天堂」），而是 存在的自然屬性。建築師並不說：「愛，否則懲罰」。他說：「愛是通往最大效用之路。自行選擇」

5.5。建築師與惡的問題

如果建築師是仁慈的，為何世界存在惡與苦難？

「朝聖者信仰」的答案：

• 惡並非建築師錯誤的結果。這是 自由選擇的後果 減少其他代理人的熵的（ΔSгрех>0）。

• 苦難不是懲罰，而是 信息 ，表明選擇的路徑遠離最優化 L.

• 建築師不干預，因為 干預會取消自由. 他創造了一個可以犯錯、學習和再次嘗試的空間.

5.6. 計算元比喻：建築師作為環境

想像一下，建築師正在創造 一個環境 (World)，其中代理可以行動。他確定了：

• 可能的軌跡空間 Ω,

• 限制 O (障礙),

• 愛的拉格朗日點 L,

• 起始條件 A 與 B.

但祂 不引導 方法 act() 給代理人。代理人自行做出決定，而設計師僅僅提供 遊戲規則 與 所代表的潛力空間。

以下是一段簡短的MATLAB程式碼，模擬這個概念。

% ========================================================================
% 5.6. Архитектор как среда: агент выбирает путь сам
% ========================================================================

clear; clc; close all; rng(42);

% Создание карты препятствий
N = 30;
x = linspace(0, 20, N);
y = linspace(0, 20, N);
[X, Y] = meshgrid(x, y);

obstacleMap = zeros(N);
for i = 1:N
    for j = 1:N
        if sqrt((X(i,j)-5)^2 + (Y(i,j)-5)^2) < 2 || ...
           sqrt((X(i,j)-12)^2 + (Y(i,j)-12)^2) < 1.5 || ...
           sqrt((X(i,j)-17)^2 + (Y(i,j)-7)^2) < 1.8 || ...
           (X(i,j) > 7 && X(i,j) < 11 && Y(i,j) > 14 && Y(i,j) < 18)
            obstacleMap(i,j) = 1;
        end
    end
end

start = [N, 1];
goal = [1, N];

% Функции для BFS
function [path, found] = bfs(map, s, g)
    dirs = [-1 0; 1 0; 0 -1; 0 1];
    queue = s;
    visited = false(size(map));
    visited(s(1), s(2)) = true;
    parent = zeros([size(map), 2]);
    found = false;
    
    while ~isempty(queue)
        curr = queue(1,:);
        queue(1,:) = [];
        if isequal(curr, g)
            found = true;
            path = g;
            while ~isequal(curr, s)
                curr = squeeze(parent(curr(1), curr(2), :))';
                path = [curr; path];
            end
            return;
        end
        for d = 1:4
            nr = curr(1) + dirs(d,1);
            nc = curr(2) + dirs(d,2);
            if nr>=1 && nr<=size(map,1) && nc>=1 && nc<=size(map,2)
                if ~visited(nr,nc) && map(nr,nc)==0
                    visited(nr,nc) = true;
                    parent(nr,nc,:) = curr;
                    queue(end+1,:) = [nr, nc];
                end
            end
        end
    end
    path = [];
    found = false;
end

function path = var_path(map, s, g, sigma)
    [opt, ok] = bfs(map, s, g);
    if ~ok || size(opt,1) <= 2
        path = opt;
        return;
    end
    path = opt;
    for i = 2:size(path,1)-1
        for a = 1:10
            dr = randi([-round(sigma), round(sigma)]);
            dc = randi([-round(sigma), round(sigma)]);
            nr = path(i,1) + dr;
            nc = path(i,2) + dc;
            if nr>=1 && nr<=size(map,1) && nc>=1 && nc<=size(map,2) && map(nr,nc)==0
                path(i,:) = [nr, nc];
                break;
            end
        end
    end
    path = unique(path, 'rows', 'stable');
end

% Архитектор создаёт мир (определяет параметры)
world.Omega = @() var_path(obstacleMap, start, goal, 0.8); % пространство путей
world.O = obstacleMap;   % ограничения (препятствия)
world.L = @(path) -size(path,1); % лагранжиан: короткий путь = лучше
world.A = start;         % начальные условия
world.B = goal;          % цель

% Агент сам ищет путь, максимизирующий полезность
% (Архитектор не вмешивается)
agent_find_path = @(world) world.Omega(); % агент выбирает любой путь из Omega

% Агент действует
path = agent_find_path(world);

% Архитектор лишь наблюдает (или оценивает результат)
if ~isempty(path)
    utility = world.L(path);
    fprintf('Агент выбрал путь с полезностью: %.2f\n', utility);
    fprintf('Длина пути: %d шагов\n', size(path,1));
else
    fprintf('Агент не смог найти путь\n');
    path = [start; goal];
end

% Визуализация
figure('Name', 'Путь, выбранный агентом', 'NumberTitle', 'off');
imagesc(x, y, world.O');
colormap([1 1 1; 0.5 0.5 0.5]);
axis xy; axis equal;
title('Агент выбрал путь самостоятельно (Архитектор не вмешивался)');
xlabel('X'); ylabel('Y');
hold on;
if ~isempty(path)
    plot(path(:,2), path(:,1), 'r-', 'LineWidth', 2, 'Marker', 'o', 'MarkerSize', 4);
end
plot(x(world.A(2)), y(world.A(1)), 'go', 'MarkerSize', 12, 'LineWidth', 2, 'MarkerFaceColor', 'g');
plot(x(world.B(2)), y(world.B(1)), 'ro', 'MarkerSize', 12, 'LineWidth', 2, 'MarkerFaceColor', 'r');
legend('Путь агента', 'Старт', 'Финиш', 'Location', 'best');
hold off;

Агент выбрал путь с полезностью: -53.00
Длина пути: 53 шагов

這個結果代表什麼

1. 代理人獨立行動。 建築師並未為代理人選擇路徑，僅僅提供了環境（空間 Ω，限制） 喔, 拉格朗日 L，初始和終止條件)。

2. 有用性 = -53.00。 在我們的簡化拉格朗日分析中 L=−長度 路徑。負值表示，效用越高，路徑越短。數字53是離散網格中的路徑長度（步數）。

3. 路徑長度：53步。 這是所選路徑的客觀特性。為了比較：確定性算法（BFS）可能會找到更短的路徑，但代理選擇了 可能 路徑中的一條在 Ω，不一定是最優的.

從形而上学角度解釋

• 建築師不強加「正確」的路徑。 即使存在更短的路徑（具有更大的效用），代理可以自由選擇 Ω中的任何一個。架構師不會因非最佳選擇而懲罰.

• 選擇的自由是現實的. 代理可以選擇另一條路徑（另一個隨機數生成器），結果將會不同。熵 S  在這個實驗中仍然很高，因為路徑分佈是均勻的。

• 負面效用—不是懲罰。  這只是 選擇路徑的客觀特徵 。建築師不會說：「你選擇得不好，現在我要懲罰你」。他只是陳述：「這條路徑有53步」。這是自然的結果，而不是懲罰。

 在下一部分，我們將進行 MATLAB中的完整計算實驗，結合 Ω、 S的熵、 U的有用性、 ΔSгрех​的罪過 以及建築師的角色，並展示整個模型如何實際運作. 

因此，我們進入了最終實驗。

第六節. 在MATLAB中的計算實驗

6.1. 實驗目的

在前面的部分中，我們引入了形式定義:

• 可能軌跡空間 Ω

• 選擇的熵 S 作為自由度的度量

• 愛的效用函數 Uγ),

• 罪 ΔS罪​ 如同另一種熵的減少,

• 建築師 A 如同可能性空間的創造者.

現在我們將所有這些概念整合在一個計算實驗中，並展示它們在實際中的運作方式.

% ========================================================================
% 6.3. Полный вычислительный эксперимент (ИСПРАВЛЕННЫЙ)
% ========================================================================

clear; clc; close all; rng('shuffle');

% ========================================================================
% 1. Инициализация поля и препятствий
% ========================================================================
N = 30;
x = linspace(0, 20, N);
y = linspace(0, 20, N);
[X, Y] = meshgrid(x, y);

obstacleMap = zeros(N);
for i = 1:N
    for j = 1:N
        if sqrt((X(i,j)-5)^2 + (Y(i,j)-5)^2) < 2
            obstacleMap(i,j) = 1;
        end
        if sqrt((X(i,j)-12)^2 + (Y(i,j)-12)^2) < 1.5
            obstacleMap(i,j) = 1;
        end
        if sqrt((X(i,j)-17)^2 + (Y(i,j)-7)^2) < 1.8
            obstacleMap(i,j) = 1;
        end
        if X(i,j) > 7 && X(i,j) < 11 && Y(i,j) > 14 && Y(i,j) < 18
            obstacleMap(i,j) = 1;
        end
    end
end

start = [N, 1];
goal = [1, N];

% ========================================================================
% ФУНКЦИИ (определены до вызова)
% ========================================================================

function [path, found] = bfs_path(map, start, goal)
    [rows, cols] = size(map);
    dirs = [-1 0; 1 0; 0 -1; 0 1];
    queue = start;
    visited = false(rows, cols);
    visited(start(1), start(2)) = true;
    parent = zeros(rows, cols, 2);
    found = false;
    
    while ~isempty(queue)
        curr = queue(1,:);
        queue(1,:) = [];
        
        if isequal(curr, goal)
            found = true;
            path = goal;
            while ~isequal(curr, start)
                curr = squeeze(parent(curr(1), curr(2), :))';
                path = [curr; path];
            end
            return;
        end
        
        for d = 1:4
            nr = curr(1) + dirs(d,1);
            nc = curr(2) + dirs(d,2);
            if nr>=1 && nr<=rows && nc>=1 && nc<=cols && ~visited(nr,nc) && map(nr,nc)==0
                visited(nr,nc) = true;
                parent(nr,nc,:) = curr;
                queue(end+1,:) = [nr, nc];
            end
        end
    end
    path = [];
    found = false;
end

function path = var_path(map, start, goal, sigma)
    [opt, ok] = bfs_path(map, start, goal);
    if ~ok || size(opt,1) <= 2
        path = opt;
        return;
    end
    path = opt;
    for i = 2:size(path,1)-1
        for attempt = 1:10
            dr = randi([-round(sigma), round(sigma)]);
            dc = randi([-round(sigma), round(sigma)]);
            nr = path(i,1) + dr;
            nc = path(i,2) + dc;
            if nr>=1 && nr<=size(map,1) && nc>=1 && nc<=size(map,2) && map(nr,nc)==0
                path(i,:) = [nr, nc];
                break;
            end
        end
    end
    path = unique(path, 'rows', 'stable');
end

function entropy = compute_entropy(paths)
    valid = ~cellfun(@isempty, paths);
    keys = cell(sum(valid), 1);
    j = 1;
    for i = 1:length(paths)
        if valid(i)
            p = paths{i};
            key = '';
            for k = 1:size(p,1)
                key = [key sprintf('(%d,%d)', p(k,1), p(k,2))];
            end
            keys{j} = key;
            j = j + 1;
        end
    end
    [~, ~, ic] = unique(keys, 'stable');
    counts = accumarray(ic, 1);
    probs = counts / sum(counts);
    entropy = -sum(probs .* log2(probs));
end

% ========================================================================
% 2. Генерация пространства Ω (200 путей)
% ========================================================================
num_paths = 200;
sigma = 0.8;
fprintf('Генерация %d путей...\n', num_paths);
paths = cell(num_paths, 1);
for i = 1:num_paths
    if mod(i,50)==0, fprintf('  %d/%d\n', i, num_paths); end
    paths{i} = var_path(obstacleMap, start, goal, sigma);
end

% ========================================================================
% 3. Энтропия выбора S
% ========================================================================
entropy = compute_entropy(paths);
fprintf('\n========== РЕЗУЛЬТАТЫ ==========\n');
fprintf('Энтропия выбора S = %.4f бит\n', entropy);

% ========================================================================
% 4. Полезность U(γ) (тепловая карта комфорта)
% ========================================================================
comfort = imgaussfilt(randn(N), 3);
comfort = (comfort - min(comfort(:))) / (max(comfort(:)) - min(comfort(:)));

alpha = 0.5;
beta = 1;

U_vals = zeros(num_paths, 1);
for i = 1:num_paths
    if ~isempty(paths{i})
        idx = sub2ind(size(comfort), paths{i}(:,1), paths{i}(:,2));
        U_vals(i) = beta * sum(comfort(idx)) - alpha * size(paths{i}, 1);
    else
        U_vals(i) = -Inf;
    end
end

valid_U = U_vals(U_vals > -Inf);
fprintf('Средняя полезность U = %.4f\n', mean(valid_U));
fprintf('Максимальная полезность U_max = %.4f\n', max(valid_U));

% ========================================================================
% 5. Моделирование греха: принуждение к единственному пути
% ========================================================================
fixed_path = bfs_path(obstacleMap, start, goal);

paths_constrained = cell(num_paths, 1);
for i = 1:num_paths
    if rand < 0.9
        paths_constrained{i} = fixed_path;
    else
        paths_constrained{i} = var_path(obstacleMap, start, goal, sigma);
    end
end

entropy_c = compute_entropy(paths_constrained);
delta_S = entropy - entropy_c;

fprintf('Энтропия после принуждения S_c = %.4f бит\n', entropy_c);
fprintf('Уменьшение энтропии ΔS_грех = %.4f бит\n', delta_S);
fprintf('Относительное уменьшение: %.1f%%\n', delta_S/entropy*100);
fprintf('================================\n');

% ========================================================================
% 6. Визуализация
% ========================================================================

% Рис. 1: Тепловая карта комфорта и лучший путь
[~, best_idx] = max(U_vals);
best_path = paths{best_idx};

figure('Name', 'Тепловая карта комфорта и лучший путь', 'Position', [100,100,600,500]);
imagesc(x, y, comfort');
colorbar; axis xy; axis equal;
title('Тепловая карта комфорта (светлее = лучше) и путь с max U');
xlabel('X'); ylabel('Y');
hold on;
if ~isempty(best_path)
    plot(best_path(:,2), best_path(:,1), 'r-', 'LineWidth', 2);
end
plot(x(start(2)), y(start(1)), 'go', 'MarkerSize', 10, 'LineWidth', 2, 'MarkerFaceColor', 'g');
plot(x(goal(2)), y(goal(1)), 'ro', 'MarkerSize', 10, 'LineWidth', 2, 'MarkerFaceColor', 'r');
legend('Лучший путь', 'Старт', 'Финиш', 'Location', 'best');

% Рис. 2: Распределение полезности
figure('Name', 'Распределение полезности', 'Position', [100,100,600,400]);
histogram(valid_U, 20, 'FaceColor', 'b', 'FaceAlpha', 0.7);
title('Распределение полезности U(γ) среди всех путей');
xlabel('Полезность'); ylabel('Частота'); grid on;

% Рис. 3: Сравнение энтропии до и после греха
figure('Name', 'Влияние греха на энтропию', 'Position', [100,100,500,400]);
bar([entropy, entropy_c], 'FaceColor', [0.3 0.6 0.9]);
set(gca, 'XTickLabel', {'Свобода (S)', 'После греха (S_c)'});
ylabel('Энтропия (бит)');
title(sprintf('Уменьшение энтропии ΔS = %.4f бит', delta_S));
grid on;

% Рис. 4: Два пути — свободный и навязанный
figure('Name', 'Свободный путь vs навязанный', 'Position', [100,100,600,500]);
imagesc(x, y, obstacleMap');
colormap([1 1 1; 0.5 0.5 0.5]);
axis xy; axis equal;
title('Свободный выбор (красный) vs принуждение (синий)');
xlabel('X'); ylabel('Y');
hold on;
if ~isempty(best_path)
    plot(best_path(:,2), best_path(:,1), 'r-', 'LineWidth', 2);
end
if ~isempty(fixed_path)
    plot(fixed_path(:,2), fixed_path(:,1), 'b--', 'LineWidth', 2);
end
plot(x(start(2)), y(start(1)), 'go', 'MarkerSize', 10, 'LineWidth', 2, 'MarkerFaceColor', 'g');
plot(x(goal(2)), y(goal(1)), 'ro', 'MarkerSize', 10, 'LineWidth', 2, 'MarkerFaceColor', 'r');
legend('Свободный путь', 'Навязанный путь', 'Старт', 'Финиш', 'Location', 'best');

fprintf('\nГотово!\n');

• 

  

  

  ========================================
  Энтропия выбора S = 7.6439 бит
  Средняя полезность U = 5.2176
  Максимальная полезность U_max = 6.6279
  Энтропия после принуждения S_c = 0.6773 бит
  Уменьшение энтропии ΔS_грех = 6.9665 бит
  Относительное уменьшение: 91.1%
  ========================================

  結果分析：

  1. 空間 Ω 和熵 S=7.64比特

  生成了200條獨特的路徑。熵達到了理論上的極限 log₂200≈7.64 位。

  結論： 代理擁有 最大自由選擇 在限制範圍內 喔所有可用的軌跡都是等概率的。沒有任何軌跡是被預先決定的。

  2. 实用性 U

  平均效用 U=5.22, 最大值 Umax=6.63。變動範圍顯示，即使選擇完全自由，並非所有路徑在舒適度和長度上都同樣有價值.

  結論： 自由不代表等價。某些路徑客觀上更好（穿過更「舒適」的區域），但設計師並未強加這些選擇.

  3. 罪惡（ΔS罪惡=6.97 位元，相對減少量91.1%）

  被迫走上單一「正確」的道路（遵循教条的機率為90%）導致了熵的災難性下降：

  • 犯罪之前： S=7.64 位元（最大多樣性）。

  • 犯罪之後： Sc=0.68 位元（幾乎完全的決定性）。

  選擇的自由度減少了 91.1%。.

  結論： 以懲罰為要挾強加唯一「正確」的道路——這是 一種可以用數學衡量到的罪過。這名「罪人」代理者（在我們的情況下——強迫走向確定性道路的系統）幾乎徹底摧毀了另一名代理者的自由。

  為了比較：在完全決定論（一條路徑有100%的機率）的情況下，熵會等於0，而減少量則是100%。我們的實驗顯示，即使90%的強迫也足以壓制自由達到91%。

  4. 從形而上的角度來解釋

  • 建築師並不犯罪. 他創造了空間 Ω 具有最大熵（7.64位）。罪過在於強迫他人走自己的路（或系統）。

  • 自由是脆弱的。 要幾乎完全摧毀自由，90%的遵循教條的機率就夠了。威脅違反「正確」道路者下地獄的宗教體系，正是創造了這種強迫。

  • 罪過可以衡量。 我們可以量化評估，某種系統（教條、法律、社會壓力）減少了多少選擇的自由。這開啟了通往「自由科學」的道路。

  6.6. 第6部分總結

  計算實驗確認了《朝聖者的信仰—源頭》的所有關鍵論點：

  

  走過這麼長的距離，我們終於達到了最重要的地方：達到結局，達到我們所擁有的。讓我們把事情理清。

  在 第一部分 我們沉浸於變分學的基礎，並意識到尋找泛函的極值並非僅僅是一項技術任務，而是一種深刻的選擇象徵。歐拉—拉格朗日方程式突顯出「最佳」路徑，但僅在嚴格規定的邊界條件下。若邊界條件放鬆，便會出現 解的家族 — 可能性的空間.

  在 第二部分 我們在MATLAB中建立了計算實驗，並直觀地看到了確定性算法（BFS）如何找到唯一路徑，而變分算法（帶隨機權重的Dijkstra）產生了 多個軌跡。多樣性不是錯誤，而是特性。我們引入了 選擇的熵 S 作為自由度的量化度量.

   第三部分 我們確定了 愛的效用函數 U(γ) —優化問題中的目標函數類似物。展示了 光滑拉格朗日乘數 (無條件的愛)與 障礙函數之間的差異。 (愛情如交易，帶著地獄的威脅)。實驗表明，路徑的優效性是主觀的，取決於內在的價值體系。

  在 第4部分 中，我們提出了 罪的原創定義 —不僅僅是違反外部規則，而是減少他人選擇熵的行為： ΔS罪=S前−S後>0. 實驗顯示，強制單一路徑摧毀了 91% 的選擇自由 。

  在 第 5 部分 中，我們闡述了 建築師 A=⟨Ω,O,L,A,B⟩ 的角色—不僅僅是作為管理每個步驟的程式設計師，更是作為創造者 發展空間。建築師不會懲罰也不會獎勵，他只是提供環境並等待

  在 第6部分 我們將所有概念整合在一個完整的計算實驗中。結果確認：選擇的自由是實際且可測量的，罪惡具有數量上的度量，而愛情可以被形式化為一個光滑的目標函數。

  我們在這六個部分中明白了

  1. 自由並非沒有規則，而是有變化的空間
     熵 S —這個空間的度量。決定論（S=0）是按照嚴格劇本生活。自由（S>0）是選擇的可能性

  2. 無條件的愛是一個平滑的目標函數。
     她不包含無窮盡的錯誤罰款。她不以地獄要挾。她只是指出方向：更多自由，更多創造力，更多關心他人.

  3. 罪惡—不是違反規則，而是減少他人的自由.
     ΔS罪惡>0. 強加自己的道路，威脅，操縱—這些都可以用失去的熵來衡量。

  4. 建築師 — 不是程式設計師，也不是裁判。
     他創造了可能性空間、初始條件和遊戲規則。但他不為我們選擇。他將自由交給我們 — 這是至高的賜予。

  5. 數學不會摧毀信仰，而是賦予它語言。
     我們沒有「證明」神的存在。我們建立了 一套可行的模型，它允許嚴肅地討論自由、愛與罪，而不帶虛無縹緲的聲明。

  這篇文章並非最終真理。這是 一個邀請。邀請你思考、爭論、驗證。

  如果你認同自由是熵、愛是平滑的效用函數、罪是減少選擇另一種的行為——我們說著同一種語言。

  如果您發現了錯誤、弱點或想提出改進建議 — 請寫下。我會回應。我敢打賭，但我不會生氣。

  如果您感覺傳統宗教形式沒有給您足夠的空間去呼吸，而世俗的視角留下問題沒有答案 — 您可能會喜歡這條路。朝聖者的路。

  您可以透過以下連結繼續對話：

  • 我的Telegram頻道「信仰朝聖者—源頭」 —這裡我會發布宣言、沉思、新的想法，這些無法放入文章中
    👉 https://t.me/VerapalomnikaIsxod

  • 討論和問題的群組 —我邀請所有想提問、釐清、爭論或只是發表看法的人。沒有責備，沒有惡意騷擾
    👉 https://t.me/+ApgozeWvVoNjZDZi

  在結尾，我想以奧地利著名詩人兼翻譯家雷內·卡爾·威廉·約翰·約瑟夫·瑪利亞·里爾克的終結性語句作結。他在《致年輕詩人書》中寫道：

  「活著就是提問。或許，當時你並未察覺，會逐漸地、遠遠地，終有一天會得到答案」.

  我不給予答案。我提出 問題 和 搜索工具 ，其餘由你決定。

  感謝你閱讀全文。