{"id":30188,"date":"2026-07-11T10:02:43","date_gmt":"2026-07-11T01:02:43","guid":{"rendered":"https:\/\/123210.net\/wordpress\/tatenaoshi\/?p=30188"},"modified":"2026-07-13T14:44:17","modified_gmt":"2026-07-13T05:44:17","slug":"%e5%86%8d%e5%b8%b0qrm%e3%82%b3%e3%83%bc%e3%83%89","status":"publish","type":"post","link":"https:\/\/123210.net\/wordpress\/tatenaoshi\/%e5%86%8d%e5%b8%b0qrm%e3%82%b3%e3%83%bc%e3%83%89\/","title":{"rendered":"\u518d\u5e30QRM\u30b3\u30fc\u30c9260711J+++++++++Qualia\uff06\u7948\u308a"},"content":{"rendered":"

\/\/***************************************************************************
\n\/\/ GraphSpatialStructure.h
\n\/\/***************************************************************************
\n#ifndef GraphSpatialStructureH
\n#define GraphSpatialStructureH<\/p>\n

#include
\n#include<\/p>\n

class RecursiveLoop;<\/p>\n

class GraphSpatialStructure {
\npublic:
\nGraphSpatialStructure(){}
\n~GraphSpatialStructure();<\/p>\n

int AddLoop(RecursiveLoop* loop);
\nvoid AddEdge(int fromIndex, int toIndex);<\/p>\n

std::vector<RecursiveLoop*> GetAllLoops() const;
\nstd::vector<RecursiveLoop*> GetNeighbors(int index) const;<\/p>\n

void UpdateAll(double dt);
\nvoid DumpToMemo(TMemo* memo, int step = -1);<\/p>\n

\/\/ \u5e73\u5747\u5024\u53d6\u5f97\uff08\u89aa\u304c\u5b50\u3092\u53c2\u7167\u3059\u308b\u3068\u304d\u306b\u4fbf\u5229\uff09
\ndouble GetAveragePhase() const;<\/p>\n

std::vector<RecursiveLoop*> loops;
\nstd::vector<RecursiveLoop*> neighbors;<\/p>\n

\/\/ GraphSpatialStructure.h \u306b\u5ba3\u8a00\u3092\u8ffd\u52a0
\nvoid DebugDump(TMemo* memo);<\/p>\n

\/\/void AddLoop(RecursiveLoop* loop);
\nvoid DebugDump(TMemo* memo, int indent = 0);<\/p>\n

private:
\nstd::vector<RecursiveLoop*> nodes_;
\nstd::vector<std::vector > adjList_; \/\/ \u2190 \u30b9\u30da\u30fc\u30b9\u5fc5\u9808\uff01
\n};<\/p>\n

#endif<\/p>\n

\/\/***************************************************************************
\n\/\/ GraphSpatialStructure.cpp
\n\/\/***************************************************************************
\n#include “GraphSpatialStructure.h”
\n#include
\n#include “Unit1.h”
\n\/\/—————————————————————————<\/p>\n

GraphSpatialStructure::~GraphSpatialStructure()
\n{
\nfor (std::vector<RecursiveLoop*>::iterator it = loops.begin();
\nit != loops.end(); ++it) {
\ndelete *it; \/\/ \u5404Loop\u3092\u89e3\u653e
\n}
\nloops.clear();
\n}<\/p>\n

int GraphSpatialStructure::AddLoop(RecursiveLoop* loop) {
\nif (loop != NULL) {
\nloops.push_back(loop);
\nreturn loops.size() – 1; \/\/ \u8ffd\u52a0\u3057\u305f\u4f4d\u7f6e\u3092\u8fd4\u3059
\n}
\nreturn -1;
\n}<\/p>\n

void GraphSpatialStructure::AddEdge(int fromIndex, int toIndex) {
\nif (fromIndex >= 0 && fromIndex < (int)adjList_.size() && toIndex >= 0 && toIndex < (int)adjList_.size()) {
\nadjList_[fromIndex].push_back(toIndex);
\n}
\n}<\/p>\n

std::vector<RecursiveLoop*> GraphSpatialStructure::GetAllLoops() const {
\n\/\/return nodes_;
\nreturn loops; \/\/ nodes_ \u2192 loops \u306b\u5909\u66f4
\n}<\/p>\n

std::vector<RecursiveLoop*> GraphSpatialStructure::GetNeighbors(int index) const {
\nstd::vector<RecursiveLoop*> result;
\nif (index >= 0 && index < (int)adjList_.size()) {
\nconst std::vector& indices = adjList_[index];
\nfor (size_t i = 0; i < indices.size(); i++) { int idx = indices[i]; if (idx >= 0 && idx < (int)nodes_.size()) {
\nresult.push_back(nodes_[idx]);
\n}
\n}
\n}
\nreturn result;
\n}<\/p>\n

void GraphSpatialStructure::DumpToMemo(TMemo* memo, int indent) {
\nAnsiString pad = AnsiString::StringOfChar(‘ ‘, indent * 3);
\nfor (std::vector<RecursiveLoop*>::iterator it = loops.begin();
\nit != loops.end(); ++it) {
\nRecursiveLoop* loop = *it;
\nmemo->Lines->Add(pad + Format(“ID:%d Phase:%.4f Winding:%.2f”,
\nARRAYOFCONST((loop->id, loop->phase, loop->winding))));<\/p>\n

if (loop->subStructure) {
\nmemo->Lines->Add(pad + ” \u2514\u2500\u2500 [SubStructure]”);
\nloop->subStructure->DumpToMemo(memo, indent + 1);
\n}
\n}
\n}<\/p>\n

void GraphSpatialStructure::UpdateAll(double dt)
\n{
\n\/\/ \u5b50\u69cb\u9020\u66f4\u65b0
\nfor (std::vector<RecursiveLoop*>::iterator it = loops.begin(); it != loops.end(); ++it) {
\nRecursiveLoop* loop = *it;
\nif (loop && loop->subStructure) {
\nloop->subStructure->UpdateAll(dt);
\n}
\n}<\/p>\n

\/\/ \u81ea\u30ec\u30d9\u30eb\u66f4\u65b0
\nfor (std::vector<RecursiveLoop*>::iterator it = loops.begin(); it != loops.end(); ++it) {
\nRecursiveLoop* loop = *it;
\nif (loop) loop->update(dt);
\n}
\n}<\/p>\n

double GraphSpatialStructure::GetAveragePhase() const {
\nif (loops.empty()) return 0.0;
\ndouble sum = 0.0;
\nfor (std::vector<RecursiveLoop*>::const_iterator it = loops.begin();
\nit != loops.end(); ++it) {
\nsum += (*it)->phase;
\n}
\nreturn sum \/ loops.size();
\n}<\/p>\n

void GraphSpatialStructure::DebugDump(TMemo* memo, int indent)
\n{
\nif (memo == NULL) return;<\/p>\n

AnsiString pad = AnsiString::StringOfChar(‘ ‘, indent * 3);<\/p>\n

memo->Lines->Add(pad + “=== DebugDump Start ===”);
\nmemo->Lines->Add(pad + Format(“loops.size() = %d”, ARRAYOFCONST(((int)loops.size()))));<\/p>\n

if (loops.empty()) {
\nmemo->Lines->Add(pad + “\u2192 loops\u304c\u7a7a\u3067\u3059\uff01”);
\nreturn;
\n}<\/p>\n

int count = 0;
\nfor (std::vector<RecursiveLoop*>::iterator it = loops.begin(); it != loops.end(); ++it) {
\nRecursiveLoop* lp = *it;
\ncount++;<\/p>\n

if (lp == NULL) {
\nmemo->Lines->Add(pad + Format(“Loop[%d] = NULL”, ARRAYOFCONST((count))));
\ncontinue;
\n}<\/p>\n

\/\/ === \u3053\u3053\u3092 RecursiveLoop \u306e\u62e1\u5f35DebugDump\u306b\u59d4\u8b72 ===
\nlp->DebugDump(memo, indent);<\/p>\n

\/\/ \u5b50\u69cb\u9020\u306e\u518d\u5e30\u30c0\u30f3\u30d7
\nif (lp->subStructure) {
\nmemo->Lines->Add(pad + ” \u2514\u2500 SubStructure:”);
\nlp->subStructure->DebugDump(memo, indent + 1);
\n}
\n}<\/p>\n

memo->Lines->Add(pad + Format(“=== DebugDump End (\u5408\u8a08 %d \u500b) ===”, ARRAYOFCONST((count))));
\n}<\/p>\n

\/\/***************************************************************************
\n\/\/ Unit1.h
\n\/\/***************************************************************************
\n\/\/—————————————————————————
\n#ifndef Unit1H
\n#define Unit1H
\n\/\/—————————————————————————<\/p>\n

#include
\n#include
\n#include
\n#include #include
\n#include
\n#include “Chart.hpp”
\n#include “Series.hpp”
\n#include “TeEngine.hpp”
\n#include “TeeProcs.hpp”
\n#include<\/p>\n

#include
\n#include<\/p>\n #include \/\/ FormatFloat
\n#include<\/map>\n

#include “GraphSpatialStructure.h”<\/p>\n

\/\/—————————————————————————
\n\/\/ === Vector3\u69cb\u9020\u4f53\uff08\u30d5\u30a1\u30a4\u30eb\u4e0a\u90e8\u306b\u8ffd\u52a0\uff09===
\nstruct Vector3 {
\ndouble x, y, z;
\nVector3() : x(0.0), y(0.0), z(0.0) {}
\nVector3(double xx, double yy, double zz) : x(xx), y(yy), z(zz) {}
\nVector3 operator+(const Vector3& o) const { return Vector3(x+o.x, y+o.y, z+o.z); }
\nVector3 operator-(const Vector3& o) const { return Vector3(x-o.x, y-o.y, z-o.z); }
\nVector3 operator*(double s) const { return Vector3(x*s, y*s, z*s); }
\nVector3& operator+=(const Vector3& o) { x+=o.x; y+=o.y; z+=o.z; return *this; }
\n};<\/p>\n

\/\/—————————————————————————
\n\/\/ RecursiveLoop\u5b9a\u7fa9\uff08\u3053\u3053\u3060\u3051\u6b8b\u3059\uff09
\nclass RecursiveLoop {
\npublic:
\nint id;
\ndouble phase;
\ndouble winding;
\ndouble fixation;
\nint x, y, z;
\ndouble memory;<\/p>\n

std::vector<RecursiveLoop*> neighbors;
\nRecursiveLoop* parent; \/\/ \u89aa\u30eb\u30fc\u30d7
\nGraphSpatialStructure* subStructure; \/\/ \u5b50\u30b0\u30e9\u30d5\uff08\u3053\u308c\u304c\u518d\u5e30\u306e\u9375\uff09<\/p>\n

\/\/ ===== \u65b0\u898f\u7269\u7406\u30d5\u30a3\u30fc\u30eb\u30c9 =====
\nstd::complex chi; \/\/ \u03c7\u5834\uff08\u8907\u7d20\uff09
\nVector3 A, E, B, prev_A;
\ndouble negentropy;<\/p>\n

double topological_winding; \/\/ \u2190 \u3053\u308c\u3092\u8ffd\u52a0\uff08\u521d\u671f\u50240\uff09<\/p>\n

\/\/ \u30af\u30aa\u30ea\u30a2\u6307\u6a19\u306e\u5b9a\u7fa9\uff08\u63d0\u6848\uff09QualiaIntensity = |TopoW| \u00d7 negentropy \u00d7 coherence
\n\/\/ |TopoW|\uff1a\u30c8\u30dd\u30ed\u30b8\u30ab\u30eb\u79e9\u5e8f\u306e\u5f37\u3055
\n\/\/ negentropy\uff1a\u5168\u4f53\u306e\u79e9\u5e8f\u5ea6
\n\/\/ coherence\uff1a\u4f4d\u76f8\u540c\u671f\u5ea6\uff08\u7d61\u307f\u5408\u3044\u306e\u5f37\u3055\uff09
\ndouble qualiaIntensity; \/\/ \u30af\u30aa\u30ea\u30a2\u6307\u6a19
\ndouble beforeQualia; \/\/\u30ed\u30b0\u306e\u3055\u3089\u306a\u308b\u5145\u5b9f\uff08Memo\u306bstrength\u3068\u5909\u5316\u7387\u3092\u8868\u793a<\/p>\n

\/\/ \u63d0\u6848B: \u7948\u308a\u5c02\u7528\u30a2\u30ad\u30e5\u30e0\u30ec\u30fc\u30bf\u3092\u8ffd\u52a0\uff08\u6700\u3082\u304a\u3059\u3059\u3081\uff09
\ndouble prayer_accumulator; \/\/ \u521d\u671f\u53160.0<\/p>\n

\/\/ \u30b3\u30f3\u30b9\u30c8\u30e9\u30af\u30bf\u62e1\u5f35
\nRecursiveLoop(int id_, double phase_ = 0.0, double winding_ = 0.0,
\ndouble fixation_ = 0.5, double x_ = 0, double y_ = 0, double z_ = 0);<\/p>\n

~RecursiveLoop(){}<\/p>\n

void update(double dt);
\ndouble compute_interaction() const;
\nvoid compute_E_B(double dt); \/\/ \u65b0\u898f
\nvoid update_winding_irreversible(double dt);\/\/ \u65b0\u898f
\nvoid update_chi_and_phase(); \/\/ \u65b0\u898f<\/p>\n

bool check_preservation() const; \/\/\u4e0d\u8981\u304b\uff1f
\nvoid add_neighbor(RecursiveLoop* neighbor); \/\/\u4e0d\u8981\u304b\uff1f<\/p>\n

AnsiString GetStateDescription() const;
\nvoid PrintNeighbors(TMemo* memo, int indent = 0) const;<\/p>\n

\/\/ \u30b5\u30d6\u69cb\u9020\u3092\u30a2\u30bf\u30c3\u30c1\u3059\u308b\u5c02\u7528\u30e1\u30bd\u30c3\u30c9
\nvoid AttachSubStructure(GraphSpatialStructure* sub);<\/p>\n

\/\/ \u89aa\u8a2d\u5b9a\uff08\u5185\u90e8\u7528\uff09
\nvoid SetParent(RecursiveLoop* p) { parent = p; }<\/p>\n

void DebugDump(TMemo* memo, int indent = 0) const; \/\/ \u62e1\u5f35<\/p>\n

\/\/\u968e\u5c64\u7684Gauss\/Stokes\u7c21\u6613\u30c1\u30a7\u30c3\u30af\u8ffd\u52a0\uff08\u4fdd\u5b58\u5247\u691c\u8a3c\uff09
\ndouble compute_local_divergence() const; \/\/ Gauss\u7528\u7c21\u6613<\/p>\n

\/\/Winding\u6570\uff08\u5dfb\u304d\u6570\uff09\u306e\u8a08\u7b97\u8a73\u7d30 : \u5b50\u69cb\u9020\u3092\u74b0\u72b6\u306b\u4e26\u3079\u305f\u4eee\u60f3\u30eb\u30fc\u30d7\u3068\u3057\u3066\u7dcf\u4f4d\u76f8\u5909\u5316\u3092\u6c42\u3081\u308b
\ndouble compute_winding_number() const;
\n\/\/\u8fd1\u508d\u5e73\u5747\u3068\u306e\u5dee\uff08\u7c21\u6613\u7248\uff09
\ndouble compute_winding_number_simple() const;<\/p>\n

\/\/CPT\u5909\u63db\u95a2\u6570\u3092\u8ffd\u52a0\uff1a
\nvoid ApplyCPT();<\/p>\n

\/\/\u300c\u89b3\u6e2c \u2192 \u73fe\u5b9f\u518d\u7de8\u300d \u3092\u660e\u78ba\u306b\u30e2\u30c7\u30eb\u5316\u3057\u307e\u3057\u3087\u3046\u3002\u63d0\u6848: Observe\u95a2\u6570\u3092\u65b0\u898f\u8ffd\u52a0
\nvoid Observe(double observation_strength);<\/p>\n

private:
\n\/\/\u65b0\u3057\u3044\u30d8\u30eb\u30d1\u30fc\u95a2\u6570\u3092\u8ffd\u52a0
\ndouble compute_winding_on_plane(int plane) const; \/\/ \u65b0\u898f\uff1a\u7279\u5b9a\u5e73\u9762\u3067\u306e\u5dfb\u304d\u6570<\/p>\n

\/\/\u5b50\u69cb\u9020\u306eTopoW\u3092neighbor\u30d9\u30fc\u30b9\u3067\u8a08\u7b97\u3059\u308b\u65b9\u5411
\ndouble compute_local_winding_from_neighbors() const; \/\/ \u65b0\u898f\uff1a\u8fd1\u508d\u30d9\u30fc\u30b9\u306e\u5dfb\u304d\u6570<\/p>\n

};<\/p>\n

\/\/—————————————————————————
\nclass TForm1 : public TForm
\n{
\n__published: \/\/ IDE-managed Components
\nTMemo *Memo1;
\nTButton *Button3;
\nTStringGrid *GridPhase;
\nTButton *Button4;
\nTTimer *Timer1;
\nTButton *Button5;
\nTLabel *Label1;
\nTMemo *Memo2;
\nTChart *Chart1;
\nTLineSeries *Negentropy;
\nTLineSeries *Total_TopoW;
\nTLabel *Label2;
\nTButton *ButtonCPT;
\nTCheckBox *CheckBox1;
\nTLineSeries *Series1;
\nTButton *Button6;
\nTButton *ButtonObserve;
\nTTrackBar *TrackBar_Observation_strength;
\nTLabel *Label3;
\nTButton *Button1;
\nvoid __fastcall Button3Click(TObject *Sender);
\nvoid __fastcall GridPhaseDrawCell(TObject *Sender, int ACol, int ARow,
\nTRect &Rect, TGridDrawState State);
\nvoid __fastcall Button4Click(TObject *Sender);
\nvoid __fastcall Timer1Timer(TObject *Sender);
\nvoid __fastcall FormClose(TObject *Sender, TCloseAction &Action);
\nvoid __fastcall FormCreate(TObject *Sender);
\nvoid __fastcall FormDestroy(TObject *Sender);
\nvoid __fastcall Button5Click(TObject *Sender);
\nvoid __fastcall ButtonCPTClick(TObject *Sender);
\nvoid __fastcall CheckBox1Click(TObject *Sender);
\nvoid __fastcall Button6Click(TObject *Sender);
\nvoid __fastcall ButtonObserveClick(TObject *Sender);
\nvoid __fastcall TrackBar_Observation_strengthChange(TObject *Sender);
\nvoid __fastcall Button1Click(TObject *Sender);
\nprivate:<\/p>\n

GraphSpatialStructure* graph;
\nbool graphInitialized;<\/p>\n

void __fastcall UpdatePhaseGrid();<\/p>\n

public:
\n__fastcall TForm1(TComponent* Owner);<\/p>\n

int Counter; \/\/\u30bf\u30a4\u30de\u30fc\u51e6\u7406\u306e\u56de\u6570\u30ab\u30a6\u30f3\u30c8
\n};
\n\/\/—————————————————————————
\nextern PACKAGE TForm1 *Form1;
\n\/\/—————————————————————————
\n#endif<\/p>\n

\/\/***************************************************************************
\n\/\/ Unit1.cpp
\n\/\/***************************************************************************
\n\/\/—————————————————————————
\n#pragma hdrstop<\/p>\n

#include
\n#include #include
\n#include \/\/ \u3067\u306f\u306a\u304f
\n#include “Unit1.h”
\n\/\/—————————————————————————
\n#pragma package(smart_init)
\n#pragma link “Chart”
\n#pragma link “Series”
\n#pragma link “TeEngine”
\n#pragma link “TeeProcs”
\n#pragma resource “*.dfm”
\nTForm1 *Form1;
\n\/\/—————————————————————————
\n__fastcall TForm1::TForm1(TComponent* Owner)
\n: TForm(Owner)
\n{
\n}
\n\/\/—————————————————————————
\n\/\/ \u30b3\u30f3\u30b9\u30c8\u30e9\u30af\u30bf\uff08\u65e2\u5b58\u306e\u3082\u306e\u3092\u62e1\u5f35\uff09
\nRecursiveLoop::RecursiveLoop(int id_, double phase_, double winding_,
\ndouble fixation_, double x_, double y_, double z_)
\n: id(id_), phase(phase_), winding(winding_), fixation(fixation_),
\nx((int)x_), y((int)y_), z((int)z_), memory(0.0),
\nparent(NULL), subStructure(NULL),
\nchi(0.0, 0.0), negentropy(0.0),
\ntopological_winding(0.0), \/\/ \u2190 \u8ffd\u52a0
\nqualiaIntensity(0.0), \/\/ \u2190 \u8ffd\u52a0
\nbeforeQualia(0.0)
\n{
\nA = Vector3(); E = Vector3(); B = Vector3(); prev_A = Vector3();
\n}<\/p>\n

\/\/ update\u95a2\u6570\uff08\u65e2\u5b58 + \u65b0\u7269\u7406\u547c\u3073\u51fa\u3057\uff09
\nvoid RecursiveLoop::update(double dt)
\n{
\nupdate_chi_and_phase(); \/\/ \u65b0\u898f
\nupdate_winding_irreversible(dt); \/\/ \u65b0\u898f
\ncompute_E_B(dt); \/\/ \u65b0\u898f<\/p>\n

\/\/ \u65e2\u5b58\u306e\u4f4d\u76f8\/Winding\u66f4\u65b0\uff08\u5e72\u6e09\u3092\u7dad\u6301\uff09
\ndouble interaction = compute_interaction();
\nphase += dt * (2.0 + interaction * 8.0 + sin(phase * 3.0 + x + y + z) * 0.3);
\nwinding = winding * 0.95 + interaction * 0.2;
\nmemory = memory * 0.9 + phase * 0.1;<\/p>\n

const double PI = 3.1415926535;
\nwhile (phase > PI) phase -= 2*PI;
\nwhile (phase < -PI) phase += 2*PI;
\n}<\/p>\n

\/\/ compute_interaction\u95a2\u6570
\ndouble RecursiveLoop::compute_interaction() const
\n{
\ndouble inter = 1.0;<\/p>\n

for (std::vector<RecursiveLoop*>::const_iterator it = neighbors.begin();
\nit != neighbors.end(); ++it) {
\nRecursiveLoop* neigh = *it;
\nif (neigh) {
\ndouble dphase = phase – neigh->phase;<\/p>\n

\/\/ \u8ddd\u96e2\u8a08\u7b97\uff08dx, dy, dz \u3092\u3059\u3079\u3066\u5b9a\u7fa9\uff09
\ndouble dx = (double)(x – neigh->x);
\ndouble dy = (double)(y – neigh->y);
\ndouble dz = (double)(z – neigh->z);
\ndouble r2 = dx*dx + dy*dy + dz*dz + 0.1;<\/p>\n

\/\/ E\u5834\u306b\u3088\u308bCoulomb\u9805\u8ffd\u52a0
\ndouble e_force = (E.z + neigh->E.z) * 2.0; \/\/ \u7c21\u6613\u7d50\u5408<\/p>\n

inter += sin(dphase) * 5.0 \/ r2 + e_force * 0.3;
\n}
\n}<\/p>\n

if (parent) {
\ninter += 0.8 * (parent->phase – phase);
\n}<\/p>\n

if (subStructure) {
\ndouble avg = subStructure->GetAveragePhase();
\ninter += 0.5 * (avg – phase);
\n}<\/p>\n

return inter;
\n}<\/p>\n

\/\/ check_preservation\u95a2\u6570
\nbool RecursiveLoop::check_preservation() const
\n{
\nreturn (phase > -10000.0 && phase < 10000.0);
\n}<\/p>\n

\/\/ add_neighbor\u95a2\u6570
\nvoid RecursiveLoop::add_neighbor(RecursiveLoop* neighbor)
\n{
\nif (neighbor != NULL && neighbor != this) {
\nneighbors.push_back(neighbor);
\n}
\n}<\/p>\n

void RecursiveLoop::AttachSubStructure(GraphSpatialStructure* sub)
\n{
\nif (subStructure) {
\ndelete subStructure; \/\/ \u3059\u3067\u306b\u3042\u3063\u305f\u3089\u89e3\u653e
\n}
\nsubStructure = sub;
\nif (subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = subStructure->loops.begin();
\nit != subStructure->loops.end(); ++it) {
\nRecursiveLoop* child = *it;
\nif (child) {
\nchild->SetParent(this);
\n}
\n}
\n}
\n}<\/p>\n

\/\/ \u65b0\u898f\u30e1\u30bd\u30c3\u30c9\u7fa4
\nvoid RecursiveLoop::update_chi_and_phase()
\n{
\n\/\/\u5b50\u69cb\u9020\u306e\u03c7\u4f4d\u76f8\u66f4\u65b0\u3092\u5f37\u5316\uff08update_chi_and_phase\uff09
\ndouble abs_chi = std::abs(chi);
\nif (abs_chi < 1e-8) {
\nchi = std::complex(0.1, 0.0);
\nphase = 0.0;
\n} else {
\nphase = std::arg(chi);
\n}<\/p>\n

if (subStructure) {
\ndouble avg = subStructure->GetAveragePhase();
\n\/\/ \u4f4d\u76f8\u3092\u7a4d\u6975\u7684\u306b\u8907\u7d20\u5316
\nchi += std::complex(0.02 * cos(avg), 0.05 * sin(avg));
\n}
\n}<\/p>\n

void RecursiveLoop::compute_E_B(double dt)
\n{
\n\/\/ compute_E_B \u3082\u5b89\u5168\u5316\uff08dist=0\u5bfe\u7b56\uff09
\nVector3 grad_chi(0.0,0.0,0.0);
\nif (parent) {
\ndouble dx = x – parent->x;
\ndouble dy = y – parent->y;
\ndouble dz = z – parent->z;
\ndouble dist = sqrt(dx*dx + dy*dy + dz*dz) + 1e-8;
\ndouble dchi = chi.real() – parent->chi.real();
\ngrad_chi = Vector3(dx\/dist, dy\/dist, dz\/dist) * (dchi \/ dist);
\n}<\/p>\n

Vector3 dA_dt = (A – prev_A) * (1.0 \/ dt);
\nE = grad_chi * (-1.0) + dA_dt * (-1.0);
\nB = Vector3(0,0, 0.05 * winding);<\/p>\n

prev_A = A;
\n}<\/p>\n

void RecursiveLoop::update_winding_irreversible(double dt)
\n{
\n\/\/ \u63d0\u6848B: \u7948\u308a\u5c02\u7528\u30a2\u30ad\u30e5\u30e0\u30ec\u30fc\u30bf\u3092\u8ffd\u52a0\uff08\u6700\u3082\u304a\u3059\u3059\u3081\uff09
\n\/\/ update_winding_irreversible \u306e\u5148\u982d\u4ed8\u8fd1\u306b\u8ffd\u52a0
\n\/\/ update_winding_irreversible\uff08\u307e\u305f\u306fupdate\uff09\u5185\u3067\u5c11\u3057\u305a\u3064\u52b9\u679c\u3092\u767a\u63ee
\nnegentropy += prayer_accumulator * 0.02; \/\/ \u3086\u3063\u304f\u308a\u52b9\u679c
\nqualiaIntensity += prayer_accumulator * 0.05;
\nprayer_accumulator *= 0.92; \/\/ \u81ea\u7136\u6e1b\u8870\uff08\u6301\u7d9a\u611f\uff09<\/p>\n

\/\/ coherence\u8a08\u7b97\uff08\u5b50\u69cb\u9020\u306e\u4f4d\u76f8\u540c\u671f\u5ea6\uff09
\ndouble coherence = 1.0;
\nif (subStructure && !subStructure->loops.empty()) {
\ndouble sum_cos = 0.0, sum_sin = 0.0;
\nint cnt = 0;
\nfor (std::vector<RecursiveLoop*>::iterator it = subStructure->loops.begin();
\nit != subStructure->loops.end(); ++it) {
\nif (*it) {
\nsum_cos += cos((*it)->phase);
\nsum_sin += sin((*it)->phase);
\ncnt++;
\n}
\n}
\nif (cnt > 0) {
\ncoherence = sqrt((sum_cos*sum_cos + sum_sin*sum_sin) \/ cnt);
\n}
\n}<\/p>\n

\/\/ === \u3053\u3053\u304b\u3089\u30af\u30aa\u30ea\u30a2\u6307\u6a19\u306e\u8a08\u7b97\uff08\u65b0\u898f\u8ffd\u52a0\uff09===
\nqualiaIntensity = fabs(topological_winding) * negentropy * coherence * 0.1;
\n\/\/ \u203b 0.1\u306f\u30b9\u30b1\u30fc\u30eb\u8abf\u6574\u7528\uff08\u5927\u304d\u304f\u306a\u308a\u3059\u304e\u306a\u3044\u3088\u3046\uff09<\/p>\n

double topological_winding_temp = compute_winding_number();<\/p>\n

\/\/ drive\uff08\u5909\u5316\u91cf\uff09
\ndouble drive = topological_winding_temp – winding;
\ndouble smoothed_drive = 0.6 * drive + 0.4 * (topological_winding – winding);<\/p>\n

\/\/ \u5f37\u3044\u6574\u6570\u5f15\u304d\u3064\u3051\uff080.5\u523b\u307f\uff09
\ndouble integer_bias = 0.0;
\n{
\ndouble scaled = topological_winding_temp * 2.0;
\ndouble rounded = floor(scaled + 0.5 * (scaled > 0 ? 1.0 : -1.0)) \/ 2.0;
\ninteger_bias = rounded – topological_winding_temp;
\n}<\/p>\n

double negentropy_drive = 0.08 * coherence * coherence;
\ndouble dissipation = -0.001 * fabs(winding); \/\/ \u5f31\u3081\u306b\u8a2d\u5b9a
\ndouble parent_drive = parent ? 0.015 * sin(parent->phase – phase) : 0.0;<\/p>\n

\/\/ \u66f4\u65b0
\nwinding += dt * (smoothed_drive * 0.7
\n+ integer_bias * 0.5
\n+ negentropy_drive * 0.6
\n+ dissipation
\n+ parent_drive);<\/p>\n

negentropy += negentropy_drive * 2.0 – dissipation * 0.4;<\/p>\n

topological_winding = topological_winding_temp;
\n}<\/p>\n

\/\/ DebugDump\u62e1\u5f35\uff08TMemo\u51fa\u529b\u306b\u7269\u7406\u91cf\u8ffd\u52a0\uff09
\nvoid RecursiveLoop::DebugDump(TMemo* memo, int indent) const
\n{
\nAnsiString ind = “”;
\nfor (int i = 0; i < indent; i++) ind += ” “; memo->Lines->Add(ind + Format(“ID:%d Phase:%.4f W:%.4f \u03c7:%.4f+%.4fi E.z:%.3f Neg:%.4f TopoW:%.4f”,
\nARRAYOFCONST((id, phase, winding, chi.real(), chi.imag(), E.z, negentropy, topological_winding))));<\/p>\n

}<\/p>\n

\/\/\u968e\u5c64\u7684Gauss\/Stokes\u7c21\u6613\u30c1\u30a7\u30c3\u30af\u8ffd\u52a0\uff08\u4fdd\u5b58\u5247\u691c\u8a3c\uff09
\ndouble RecursiveLoop::compute_local_divergence() const
\n{
\n\/* \/\/Local Div\u3092\u3088\u308a\u7269\u7406\u7684\u306b\uff08\u4fdd\u5b58\u5247\u691c\u8a3c\u5f37\u5316\uff09
\ndouble div = 0.0;
\n\/\/ \u89aa-\u5b50\u9593\u306e\u5bc4\u4e0e
\nif (parent) {
\ndouble dr = sqrt(pow((double)x – parent->x,2) +
\npow((double)y – parent->y,2) +
\npow((double)z – parent->z,2)) + 1e-8;
\ndiv += (E.z – parent->E.z) \/ dr;
\n}
\n\/\/ \u5b50\u69cb\u9020\u304b\u3089\u306e\u96c6\u7d04\uff08Gauss\u306e\u300c\u9589\u5305\u6027\u300d\u8fd1\u4f3c\uff09
\nif (subStructure) {
\nfor (std::vector<RecursiveLoop*>::const_iterator it = subStructure->loops.begin();
\nit != subStructure->loops.end(); ++it) {
\nif (*it) div += (*it)->E.z * 0.05; \/\/ \u30d5\u30e9\u30c3\u30af\u30b9\u5bc4\u4e0e
\n}
\n}
\nreturn div;
\n*\/<\/p>\n

\/\/compute_local_divergence \u306e\u5f37\u5316
\n\/* double div = 0.0;<\/p>\n

\/\/ \u89aa-\u5b50\u9593\u306e\u5bc4\u4e0e\uff08\u91cd\u307f\u4ed8\u3051\u3092\u8abf\u6574\uff09
\nif (parent) {
\ndouble dr = sqrt(pow((double)x – parent->x,2) +
\npow((double)y – parent->y,2) +
\npow((double)z – parent->z,2)) + 1e-8;
\ndiv += (E.z – parent->E.z) \/ dr * 0.5; \/\/ \u91cd\u307f\u30920.5\u306b\u4f4e\u6e1b
\n}<\/p>\n

\/\/ \u5b50\u69cb\u9020\u304b\u3089\u306e\u5bc4\u4e0e\uff08\u91cd\u307f\u3092\u3055\u3089\u306b\u4f4e\u6e1b\uff09
\nif (subStructure) {
\nfor (std::vector<RecursiveLoop*>::const_iterator it = subStructure->loops.begin();
\nit != subStructure->loops.end(); ++it) {
\nif (*it) div += (*it)->E.z * 0.02; \/\/ 0.05 \u2192 0.02\u306b\u4f4e\u6e1b
\n}
\n}<\/p>\n

return div;
\n*\/<\/p>\n

\/\/compute_local_divergence \u306e\u3055\u3089\u306a\u308b\u8abf\u6574
\ndouble div = 0.0;<\/p>\n

if (parent) {
\ndouble dr = sqrt(pow((double)x – parent->x,2) +
\npow((double)y – parent->y,2) +
\npow((double)z – parent->z,2)) + 1e-6;
\ndiv += (E.z – parent->E.z) \/ dr * 0.3; \/\/ \u91cd\u307f\u3092\u3055\u3089\u306b\u4f4e\u6e1b
\n}<\/p>\n

if (subStructure) {
\nfor (std::vector<RecursiveLoop*>::const_iterator it = subStructure->loops.begin();
\nit != subStructure->loops.end(); ++it) {
\nif (*it) div += (*it)->E.z * 0.01; \/\/ 0.02 \u2192 0.01\u306b\u4f4e\u6e1b
\n}
\n}<\/p>\n

return div;<\/p>\n

}<\/p>\n

\/\/Winding\u6570\uff08\u5dfb\u304d\u6570\uff09\u306e\u8a08\u7b97\u8a73\u7d30 : \u5b50\u69cb\u9020\u3092\u74b0\u72b6\u306b\u4e26\u3079\u305f\u4eee\u60f3\u30eb\u30fc\u30d7\u3068\u3057\u3066\u7dcf\u4f4d\u76f8\u5909\u5316\u3092\u6c42\u3081\u308b
\ndouble RecursiveLoop::compute_winding_number() const
\n{
\n\/\/Winding\u6570\uff08\u5dfb\u304d\u6570\uff09\u306e\u8a08\u7b97\u8a73\u7d30 : 3\u9762\u5e73\u5747\u7248<\/p>\n

\/\/\u5b50\u69cb\u9020\u306eTopoW\u3092neighbor\u30d9\u30fc\u30b9\u3067\u8a08\u7b97\u3059\u308b\u65b9\u5411\u3067\u9032\u3081\u307e\u3059\u3002
\nif (subStructure && subStructure->loops.size() >= 3) {
\n\/\/ \u5b50\u69cb\u9020\u304c\u3042\u308b\u5834\u5408\u306f\u5f93\u6765\u306e\u74b0\u72b6\u8a08\u7b97
\ndouble total_delta = 0.0;
\nsize_t n = subStructure->loops.size();
\nfor (size_t i = 0; i < n; ++i) { RecursiveLoop* curr = subStructure->loops[i];
\nRecursiveLoop* next = subStructure->loops[(i + 1) % n];
\nif (curr && next) {
\ndouble dtheta = next->phase – curr->phase;
\nwhile (dtheta > M_PI) dtheta -= 2 * M_PI;
\nwhile (dtheta < -M_PI) dtheta += 2 * M_PI;
\ntotal_delta += dtheta;
\n}
\n}
\nreturn total_delta \/ (2 * M_PI * n); \/\/ \u6b63\u898f\u5316
\n} else {
\n\/\/ \u8fd1\u508d\u30d9\u30fc\u30b9\uff08\u5b50\u69cb\u9020\u304c\u306a\u3044 or \u5c0f\u3055\u3044\u5834\u5408\uff09
\nreturn compute_local_winding_from_neighbors();
\n}
\n}<\/p>\n

\/\/\u8fd1\u508d\u5e73\u5747\u3068\u306e\u5dee\uff08\u7c21\u6613\u7248\uff09
\ndouble RecursiveLoop::compute_winding_number_simple() const
\n{<\/p>\n

if (neighbors.empty()) return 0.0;<\/p>\n

double avg_phase = 0.0;
\nint count = 0;<\/p>\n

for (std::vector<RecursiveLoop*>::const_iterator it = neighbors.begin();
\nit != neighbors.end(); ++it) {
\nRecursiveLoop* neigh = *it;
\nif (neigh) {
\navg_phase += neigh->phase;
\ncount++;
\n}
\n}<\/p>\n

if (count == 0) return 0.0;<\/p>\n

avg_phase \/= count;<\/p>\n

double dtheta = phase – avg_phase;
\nwhile (dtheta > M_PI) dtheta -= 2 * M_PI;
\nwhile (dtheta < -M_PI) dtheta += 2 * M_PI; return dtheta \/ (2 * M_PI); } \/\/ \u65b0\u898f\uff1a\u7279\u5b9a\u5e73\u9762\u3067\u306e\u5dfb\u304d\u6570\u8a08\u7b97 double RecursiveLoop::compute_winding_on_plane(int plane) const { \/\/ \u6539\u5584\u7248\uff08\u3088\u308a\u826f\u3044\u30ea\u30f3\u30b0\u62bd\u51fa\uff09 if (!subStructure || subStructure->loops.size() < 8) return 0.0;<\/p>\n

std::vector<RecursiveLoop*> ring;<\/p>\n

\/\/ \u3088\u308a\u591a\u304f\u306e\u70b9\u3092\u7a7a\u9593\u9806\u306b\u4e26\u3079\u308b\uff08\u7c21\u6613\u87ba\u65cb\/\u5186\u74b0\u8fd1\u4f3c\uff09
\nfor (int i = 0; i < 9; ++i) { \/\/ 3×3\u306e\u5468\u8fba\u3092\u56de\u308b
\nint x = 0, y = 0, z = 0;
\nif (plane == 0) { \/\/ xy\u5e73\u9762\uff08z\u56fa\u5b9a\uff09
\nx = (i % 3);
\ny = (i \/ 3);
\nz = 1;
\n} else if (plane == 1) { \/\/ yz\u5e73\u9762\uff08x\u56fa\u5b9a\uff09
\ny = (i % 3);
\nz = (i \/ 3);
\nx = 1;
\n} else { \/\/ zx\u5e73\u9762\uff08y\u56fa\u5b9a\uff09
\nz = (i % 3);
\nx = (i \/ 3);
\ny = 1;
\n}<\/p>\n

\/\/ \u8a72\u5f53\u3059\u308bLoop\u3092\u63a2\u3059
\nfor (std::vector<RecursiveLoop*>::const_iterator it = subStructure->loops.begin();
\nit != subStructure->loops.end(); ++it) {
\nRecursiveLoop* lp = *it;
\nif (lp && lp->x == x && lp->y == y && lp->z == z) {
\nring.push_back(lp);
\nbreak;
\n}
\n}
\n}<\/p>\n

if (ring.size() < 6) return 0.0;<\/p>\n

double total_delta = 0.0;
\nsize_t n = ring.size();
\nfor (size_t i = 0; i < n; ++i) { RecursiveLoop* curr = ring[i]; RecursiveLoop* next = ring[(i + 1) % n]; if (curr && next) { double dtheta = next->phase – curr->phase;
\nwhile (dtheta > M_PI) dtheta -= 2 * M_PI;
\nwhile (dtheta < -M_PI) dtheta += 2 * M_PI;
\ntotal_delta += dtheta;
\n}
\n}
\nreturn total_delta \/ (2 * M_PI);
\n}<\/p>\n

\/\/\u5b50\u69cb\u9020\u306eTopoW\u3092neighbor\u30d9\u30fc\u30b9\u3067\u8a08\u7b97\u3059\u308b\u65b9\u5411
\n\/\/ \u65b0\u898f\uff1a\u8fd1\u508d\u30d9\u30fc\u30b9\u306e\u5c40\u6240\u5dfb\u304d\u6570
\ndouble RecursiveLoop::compute_local_winding_from_neighbors() const
\n{
\n\/\/\u6b21\u306e\u5f37\u5316\uff08\u63a8\u5968\uff09\u73fe\u5728\u306ecompute_local_winding_from_neighbors\u3092\u5c11\u3057\u8abf\u6574\u3057\u3066\u3001\u3088\u308a\u5f37\u3044\u4fe1\u53f7\u304c\u51fa\u308b\u3088\u3046\u306b\u3057\u307e\u3059\u3002
\nif (neighbors.empty()) return 0.0;<\/p>\n

double total_delta = 0.0;
\nint count = 0;<\/p>\n

for (std::vector<RecursiveLoop*>::const_iterator it = neighbors.begin();
\nit != neighbors.end(); ++it) {
\nRecursiveLoop* neigh = *it;
\nif (neigh) {
\ndouble dtheta = neigh->phase – phase;
\nwhile (dtheta > M_PI) dtheta -= 2 * M_PI;
\nwhile (dtheta < -M_PI) dtheta += 2 * M_PI; total_delta += dtheta; count++; } } if (count == 0) return 0.0; double avg = (total_delta \/ count) \/ (2 * M_PI); \/\/ round\u306e\u4ee3\u66ff\uff080.25\u523b\u307f\u3067\u5f37\u8abf\uff09 double scaled = avg * 4.0; double rounded = floor(scaled + 0.5 * (scaled > 0 ? 1.0 : -1.0)) \/ 4.0;<\/p>\n

return rounded;
\n}<\/p>\n

\/\/CPT\u5909\u63db\u95a2\u6570\u3092\u8ffd\u52a0\uff1a
\nvoid RecursiveLoop::ApplyCPT()
\n{
\n\/* \/\/ C: \u8907\u7d20\u5171\u5f79\uff08\u8377\u96fb\u5171\u5f79\uff09
\nchi = std::conj(chi);<\/p>\n

\/\/ P: \u7a7a\u9593\u53cd\u8ee2\uff08\u5ea7\u6a19\u3068\u8fd1\u508d\u95a2\u4fc2\u306e\u53cd\u8ee2\uff09
\nx = -x; y = -y; z = -z;<\/p>\n

\/\/ \u8fd1\u508d\u30ea\u30b9\u30c8\u306f\u4e00\u65e6\u30af\u30ea\u30a2\u3057\u3066\u518d\u69cb\u7bc9\uff08\u7c21\u6613\u7248\uff09
\n\/\/ \u672c\u6765\u306f\u8fd1\u508d\u95a2\u4fc2\u306e\u5411\u304d\u3082\u53cd\u8ee2\u3055\u305b\u308b<\/p>\n

\/\/ T: \u6642\u9593\u53cd\u8ee2\u306e\u6a21\u64ec\uff08\u66f4\u65b0\u65b9\u5411\u3092\u9006\u306b\u3059\u308b\u30d5\u30e9\u30b0\uff09
\n\/\/ \u3053\u3053\u3067\u306fphase\u306e\u5fae\u5c0f\u6442\u52d5\u3067\u4ee3\u7528
\nphase = -phase; \/\/ \u7c21\u6613\u7684\u6642\u9593\u53cd\u8ee2<\/p>\n

\/\/ \u66f4\u65b0\u5c65\u6b74\u3092\u30af\u30ea\u30a2\uff08\u5fc5\u8981\u306b\u5fdc\u3058\u3066\uff09
\n*\/<\/p>\n

\/\/RecursiveLoop::ApplyCPT() \u3092\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u30de\u30a4\u30eb\u30c9\u306b\u4fee\u6b63\u3057\u3066\u304f\u3060\u3055\u3044
\n\/\/ C: \u8907\u7d20\u5171\u5f79\uff08\u5f31\u3081\u306b\uff09
\nchi = std::complex(chi.real(), -chi.imag() * 0.8); \/\/ \u865a\u90e8\u309280%\u53cd\u8ee2<\/p>\n

\/\/ P: \u7a7a\u9593\u53cd\u8ee2\uff08\u5f31\u3081\u306b\uff09
\nx = -x * 0.7;
\ny = -y * 0.7;
\nz = -z * 0.7;<\/p>\n

\/\/ T: \u6642\u9593\u53cd\u8ee2\uff08\u5f31\u3081\u306b\uff09
\nphase = -phase * 0.6;<\/p>\n

\/\/ \u8efd\u3044\u30ce\u30a4\u30ba\u3067\u5b89\u5b9a\u5316
\nphase += (rand() % 100 – 50) \/ 1000.0;
\n}<\/p>\n

\/\/ C++Builder 2007\uff08Borland C++ Compiler\uff09\u306fC++98\u6e96\u62e0\u3067\u3001\u6a19\u6e96\u306eround()\u95a2\u6570\uff08C99\/C++11\uff09\u304c\u3042\u308a\u307e\u305b\u3093\u3002
\n\/\/ \u3084\u306b\u5165\u3063\u3066\u3044\u306a\u3044\u305f\u3081\u30a8\u30e9\u30fc\u306b\u306a\u308a\u307e\u3059\u3002
\n\/\/ \u89e3\u6c7a\u65b9\u6cd5\uff08\u304a\u3059\u3059\u3081\u9806\uff091. \u6700\u3082\u7c21\u5358\uff1a\u81ea\u4f5c\u306eround\u95a2\u6570\u3092\u8ffd\u52a0\uff08\u63a8\u5968\uff09
\n\/\/ round\u4ee3\u66ff\u95a2\u6570\uff08C++Builder2007\u5bfe\u5fdc\uff09
\ninline double myRound(double x) {
\nreturn (x >= 0.0) ? floor(x + 0.5) : ceil(x – 0.5);
\n}<\/p>\n

\/\/\u300c\u89b3\u6e2c \u2192 \u73fe\u5b9f\u518d\u7de8\u300d \u3092\u660e\u78ba\u306b\u30e2\u30c7\u30eb\u5316\u3057\u307e\u3057\u3087\u3046\u3002\u63d0\u6848: Observe\u95a2\u6570\u3092\u65b0\u898f\u8ffd\u52a0
\nvoid RecursiveLoop::Observe(double observation_strength = 1.0)
\n{
\n\/* \/\/ \u89b3\u6e2c\u306b\u3088\u308b\u300c\u5d29\u58ca\u300d\u52b9\u679c\uff08\u4f4d\u76f8\u3092\u5b89\u5b9a\u70b9\u306b\u5f15\u304d\u5bc4\u305b\u308b\uff09
\n\/\/double target_phase = round(phase \/ (M_PI \/ 2.0)) * (M_PI \/ 2.0); \/\/ 90\u5ea6\u5358\u4f4d\u306b\u5f15\u304d\u5bc4\u305b\u4f8b
\ndouble target_phase = myRound(phase \/ (M_PI \/ 2.0)) * (M_PI \/ 2.0); \/\/ 90\u5ea6\u5358\u4f4d\u306b\u5f15\u304d\u5bc4\u305b\u4f8b
\nphase = phase * (1.0 – observation_strength * 0.3) + target_phase * (observation_strength * 0.3);<\/p>\n

\/\/ winding\u3092\u6574\u6570\u5bc4\u308a\u306b\uff08\u30c8\u30dd\u30ed\u30b8\u30ab\u30eb\u5b89\u5b9a\u5316\uff09
\n\/\/topological_winding = round(topological_winding * 0.7) + topological_winding * 0.3;
\ntopological_winding = myRound(topological_winding * 0.7) + topological_winding * 0.3;<\/p>\n

\/\/ Qualia\u30d6\u30fc\u30b9\u30c8\uff08\u89b3\u6e2c\u306b\u3088\u308b\u610f\u8b58\u306e\u660e\u78ba\u5316\uff09
\ndouble coherence = 1.0; \/\/ \u65e2\u5b58\u306ecoherence\u8a08\u7b97\u3092\u518d\u5229\u7528\u3059\u308b\u304b\u3001\u3053\u3053\u3067\u7c21\u6613\u8a08\u7b97
\nqualiaIntensity += 150.0 * observation_strength * coherence; \/\/ coherence\u306f\u65e2\u5b58<\/p>\n

\/\/ \u73fe\u5b9f\u518d\u7de8\u52b9\u679c\uff08\u8fd1\u508d\u3092\u5c11\u3057\u6574\u5217\uff09
\nif (parent) parent->phase += (phase – parent->phase) * 0.1 * observation_strength;
\n*\/<\/p>\n

if (observation_strength <= 0.0) return; \/\/ myRound\u306f\u65e2\u306b\u5b9a\u7fa9\u6e08\u307f\u3068\u4eee\u5b9a double quantum = M_PI \/ 2.0; double target_phase = myRound(phase \/ quantum) * quantum; \/\/ \u6ed1\u3089\u304b\u306a\u5d29\u58ca\uff08\u6025\u6fc0\u306b\u306a\u308a\u3059\u304e\u306a\u3044\uff09 phase = phase * (1.0 – observation_strength * 0.35) + target_phase * (observation_strength * 0.35); \/\/ TopoW\u306e\u6574\u6570\u5316\uff08\u30c8\u30dd\u30ed\u30b8\u30ab\u30eb\u5b89\u5b9a\uff09 topological_winding = myRound(topological_winding) * 0.6 + topological_winding * 0.4; \/\/ Qualia\u30d6\u30fc\u30b9\u30c8\uff08coherence\u304c\u3042\u308c\u3070\u3088\u308a\u826f\u3044\uff09 \/\/ coherence\u8a08\u7b97\uff08\u3042\u306a\u305f\u304c\u8ffd\u52a0\u3057\u305f\u90e8\u5206\uff09 double coherence = 1.0; if (subStructure && !subStructure->loops.empty()) {
\ndouble sum_cos = 0.0, sum_sin = 0.0;
\nint cnt = 0;
\nfor (std::vector<RecursiveLoop*>::iterator it = subStructure->loops.begin();
\nit != subStructure->loops.end(); ++it) {
\nif (*it) {
\nsum_cos += cos((*it)->phase);
\nsum_sin += sin((*it)->phase);
\ncnt++;
\n}
\n}
\nif (cnt > 0) {
\ncoherence = sqrt((sum_cos*sum_cos + sum_sin*sum_sin) \/ cnt);
\n}
\n}
\n\/\/qualiaIntensity += 120.0 * observation_strength * coherence; \/\/ 150\u2192120\u306b\u8abf\u6574\uff08\u7a4f\u3084\u304b\u3081\u306b\uff09
\nqualiaIntensity += 60.0 * observation_strength * coherence; \/\/ \u5f37\u3059\u304e\u306a\u3044\u5024\u306b<\/p>\n

\/\/ \u89aa\u69cb\u9020\u3078\u306e\u6ce2\u53ca\uff08\u73fe\u5b9f\u518d\u7de8\u306e\u9023\u9396\uff09
\nif (parent) {
\nparent->phase += (phase – parent->phase) * 0.12 * observation_strength;
\n}<\/p>\n

\/\/ \u8efd\u3044negentropy\u8ffd\u52a0\uff08\u79e9\u5e8f\u306e\u56fa\u5b9a\u5316\uff09
\n\/\/negentropy += 20.0 * observation_strength; \/\/ \u79e9\u5e8f\u56fa\u5b9a\u52b9\u679c
\nnegentropy += 15.0 * observation_strength * coherence; \/\/ coherence\u9023\u52d5\u3067\u5b89\u5b9a
\n}<\/p>\n

\/\/—————————————————————————
\n\/\/—————————————————————————
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::UpdatePhaseGrid()
\n{
\n\/\/\u3055\u3089\u306b\u91cd\u8981\u306a\u4fee\u6b63\uff08\u7121\u9650\u30eb\u30fc\u30d7\u5b8c\u5168\u9632\u6b62\uff09
\nif (!GridPhase || !graph || !graphInitialized) return;<\/p>\n

\/\/ Cells\u3078\u306e\u66f8\u304d\u8fbc\u307f\u3092\u6700\u5c0f\u9650\u306b\uff08\u307e\u305f\u306f\u5b8c\u5168\u306b\u524a\u9664\uff09
\nstd::vector<RecursiveLoop*> all = graph->GetAllLoops();
\nfor (int row = 0; row < 3; row++) {
\nfor (int col = 0; col < 3; col++) {
\nint idx = 1 + row * 3 + col;
\nif (idx < (int)all.size() && all[idx]) { \/\/ GridPhase->Cells[col][row] = … \u2190 \u3053\u3053\u3082\u30b3\u30e1\u30f3\u30c8\u30a2\u30a6\u30c8\u63a8\u5968
\n}
\n}
\n}<\/p>\n

GridPhase->Repaint(); \/\/ \u4e00\u56de\u3060\u3051\u518d\u63cf\u753b
\n}<\/p>\n

void __fastcall TForm1::Button3Click(TObject *Sender)
\n{
\nif (!graphInitialized) {
\ngraphInitialized = true;<\/p>\n

\/\/ graph\u304c\u307e\u3060\u306a\u3051\u308c\u3070\u4f5c\u6210
\nif (!graph) graph = new GraphSpatialStructure();<\/p>\n

\/\/ ==================== \u518d\u5e30\u30b3\u30f3\u30c6\u30ca\u4f5c\u6210 ====================
\nRecursiveLoop* container = new RecursiveLoop(100, 0.0, 0.0, 0.5, 0,0,0);<\/p>\n

GraphSpatialStructure* subGS = new GraphSpatialStructure();
\nfor (int z = 0; z < 3; z++) {
\nfor (int y = 0; y < 3; y++) {
\nfor (int x = 0; x < 3; x++) { int id = 200 + x + y*3 + z*9; RecursiveLoop* child = new RecursiveLoop(id, -0.8 + (x+y+z)*0.2, 0.0, 0.0, x, y, z); subGS->AddLoop(child);
\n}
\n}
\n}<\/p>\n

\/\/ \u5b50\u69cb\u9020\u5168\u7d50\u5408
\nfor (size_t i = 0; i < subGS->loops.size(); i++) {
\nfor (size_t j = 0; j < subGS->loops.size(); j++) {
\nif (i != j) subGS->loops[i]->add_neighbor(subGS->loops[j]);
\n}
\nsubGS->loops[i]->fixation = 0.0;
\n}<\/p>\n

container->AttachSubStructure(subGS);
\ngraph->AddLoop(container); \/\/ container\u8ffd\u52a0<\/p>\n

\/\/ ==================== \u30e1\u30a4\u30f327\u500b\u4f5c\u6210 ====================
\n\/\/\u3059\u3050\u306b\u5b9f\u88c5\u3067\u304d\u308b\u300cMain 27\u500b\u3078\u306e\u5b50\u69cb\u9020\u8ffd\u52a0\u300d\u30b3\u30fc\u30c9
\n\/\/ ==================== \u30e1\u30a4\u30f327\u500b\u4f5c\u6210\uff08\u5b50\u69cb\u9020\u4ed8\u304d\u306b\u5f37\u5316\uff09 ====================
\nfor (int x = 0; x < 3; x++) {
\nfor (int y = 0; y < 3; y++) {
\nfor (int z = 0; z < 3; z++) { int pos = x*9 + y*3 + z; int id = 300 + pos; \/\/ 300\u756a\u53f0\u306b RecursiveLoop* loop = new RecursiveLoop(id, (rand()%100)\/200.0 – 0.25, 0.0, 0.5); loop->x = x; loop->y = y; loop->z = z;<\/p>\n

\/\/ === \u7c21\u6613\u5b50\u69cb\u9020\u3092\u4ed8\u3051\u308b ===
\nGraphSpatialStructure* miniSub = new GraphSpatialStructure();
\nfor (int i = 0; i < 4; i++) { \/\/ \u5404Main\u30bb\u30eb\u306b4\u500b\u306e\u30df\u30cb\u5b50\u69cb\u9020 RecursiveLoop* mini = new RecursiveLoop(900 + pos*10 + i, loop->phase + (rand()%100)\/100.0*0.3 – 0.15, 0.0);
\nminiSub->AddLoop(mini);
\n}
\n\/\/ \u30df\u30cb\u5b50\u69cb\u9020\u5185\u3092\u8efd\u304f\u7d50\u5408
\nfor (size_t i = 0; i < miniSub->loops.size(); i++) {
\nfor (size_t j = 0; j < miniSub->loops.size(); j++) {
\nif (i != j) miniSub->loops[i]->add_neighbor(miniSub->loops[j]);
\n}
\n}
\nloop->AttachSubStructure(miniSub);<\/p>\n

graph->AddLoop(loop);
\n}
\n}
\n}<\/p>\n

\/\/ 26\u8fd1\u508d\u30a8\u30c3\u30b8\u8ffd\u52a0\uff08\u305d\u306e\u307e\u307e\uff09
\nint deltas[26][3] = {
\n{-1,-1,-1}, {-1,-1,0}, {-1,-1,1},
\n{-1, 0,-1}, {-1, 0,0}, {-1, 0,1},
\n{-1, 1,-1}, {-1, 1,0}, {-1, 1,1},
\n{ 0,-1,-1}, { 0,-1,0}, { 0,-1,1},
\n{ 0, 0,-1}, { 0, 0,1},
\n{ 0, 1,-1}, { 0, 1,0}, { 0, 1,1},
\n{ 1,-1,-1}, { 1,-1,0}, { 1,-1,1},
\n{ 1, 0,-1}, { 1, 0,0}, { 1, 0,1},
\n{ 1, 1,-1}, { 1, 1,0}, { 1, 1,1}
\n};<\/p>\n

\/\/Main 27\u500b\u306e\u8fd1\u508d\u7d50\u5408\u3092\u6709\u52b9\u5316
\n\/\/ === Main 27\u500b\u306e\u8fd1\u508d\u7d50\u5408\uff0826\u8fd1\u508d\uff09===
\nfor (int i = 0; i < 27; i++) {
\nint x1 = (i % 27) % 3; \/\/ \u7c21\u6613\u5ea7\u6a19
\nint y1 = ((i % 27) \/ 3) % 3;
\nint z1 = (i % 27) \/ 9;<\/p>\n

for (int d = 0; d < 26; d++) { int x2 = x1 + deltas[d][0]; int y2 = y1 + deltas[d][1]; int z2 = z1 + deltas[d][2]; if (x2 >= 0 && x2 < 3 && y2 >= 0 && y2 < 3 && z2 >= 0 && z2 < 3) { int j = x2 + y2*3 + z2*9; \/\/ graph->loops[1 + i] \u3068 graph->loops[1 + j] \u3092\u7d50\u5408\uff08Container\u3092\u30b9\u30ad\u30c3\u30d7\uff09
\nif (1+i < (int)graph->loops.size() && 1+j < (int)graph->loops.size()) {
\ngraph->loops[1 + i]->add_neighbor(graph->loops[1 + j]);
\n}
\n}
\n}
\n}<\/p>\n

}<\/p>\n

\/\/ \u30bf\u30a4\u30de\u30fc\u5207\u308a\u66ff\u3048
\nTimer1->Enabled = !Timer1->Enabled;
\nButton3->Caption = Timer1->Enabled ? “\u505c\u6b62” : “\u958b\u59cb”;
\n}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::GridPhaseDrawCell(TObject *Sender, int ACol, int ARow,
\nTRect &Rect, TGridDrawState State)
\n{
\n\/* \/\/ \u3010A\u3011GridPhase\u306e\u898b\u3084\u3059\u3055\u5f37\u5316\uff086×6\u7248\u30fb\u6700\u7d42\u8abf\u6574\uff09
\nif (!graph || !graphInitialized) {
\nGridPhase->DefaultDrawing = true;
\nreturn;
\n}<\/p>\n

std::vector<RecursiveLoop*> all = graph->GetAllLoops();
\nRecursiveLoop* target = NULL;
\nint idx = ARow * GridPhase->ColCount + ACol;<\/p>\n

\/\/ Container Sub or Main
\nif (idx < 27) {
\nRecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = all.begin(); it != all.end(); ++it) {
\nif (*it && (*it)->id == 100) { container = *it; break; }
\n}
\nif (container && container->subStructure && idx < (int)container->subStructure->loops.size())
\ntarget = container->subStructure->loops[idx];
\n} else {
\nint mainIdx = idx – 27;
\nif (mainIdx + 1 < (int)all.size()) target = all[mainIdx + 1]; } if (!target) { GridPhase->DefaultDrawing = true;
\nreturn;
\n}<\/p>\n

double topoW = target->topological_winding;
\ndouble intensity = fabs(topoW) \/ 0.6; \/\/ \u5c11\u3057\u611f\u5ea6\u3092\u4e0a\u3052\u308b
\nif (intensity > 1.0) intensity = 1.0;<\/p>\n

TColor baseColor = RGB(245, 245, 245);
\nif (topoW > 0.05) {
\nbaseColor = RGB(255, (int)(50 * (1-intensity)), (int)(20 * (1-intensity)));
\n} else if (topoW < -0.05) { baseColor = RGB((int)(20 * (1-intensity)), (int)(50 * (1-intensity)), 255); } \/\/ \u5f37\u3044TopoW\u306f\u660e\u308b\u304f\u5f37\u8abf if (fabs(topoW) > 0.3)
\nbaseColor = TColor(0xFFFFFF & baseColor) | 0x404040;<\/p>\n

GridPhase->Canvas->Brush->Color = baseColor;
\nGridPhase->Canvas->FillRect(Rect);<\/p>\n

\/\/ \u30c6\u30ad\u30b9\u30c8\uff08\u592a\u5b57\u30fb\u30b5\u30a4\u30ba\u8abf\u6574\uff09
\nGridPhase->Canvas->Font->Size = 8;
\nGridPhase->Canvas->Font->Style = TFontStyles() << fsBold; GridPhase->Canvas->Font->Color = (fabs(topoW) > 0.25) ? clYellow : clBlack;<\/p>\n

AnsiString text = FormatFloat(“0.00”, topoW);
\nGridPhase->Canvas->TextOut(Rect.Left + 4, Rect.Top + 6, text);<\/p>\n

if (fabs(topoW) > 0.25) {
\nGridPhase->Canvas->Pen->Color = clYellow;
\nGridPhase->Canvas->Pen->Width = 2;
\nGridPhase->Canvas->FrameRect(Rect);
\n}<\/p>\n

\/\/ === \u5f37\u3044\u30af\u30aa\u30ea\u30a2\u9818\u57df\u3092\u5f37\u8abf\uff08\u30aa\u30d7\u30b7\u30e7\u30f3\uff09===
\nif (loop->qualiaIntensity > 100.0) { \/\/ \u95be\u5024\u306f\u8abf\u6574
\n\/\/ \u30bb\u30eb\u3092\u3088\u308a\u660e\u308b\u304f\u3057\u305f\u308a\u67a0\u3092\u592a\u304f\u3059\u308b
\nGridPhase->Canvas->Pen->Color = clLime;
\nGridPhase->Canvas->Pen->Width = 3;
\nGridPhase->Canvas->FrameRect(Rect);
\n}
\n*\/<\/p>\n

if (!graph || !graphInitialized) {
\nGridPhase->DefaultDrawing = true;
\nreturn;
\n}<\/p>\n

std::vector<RecursiveLoop*> all = graph->GetAllLoops();
\nRecursiveLoop* loop = NULL; \/\/ \u2190 \u3053\u3053\u3067\u5ba3\u8a00<\/p>\n

int idx = ARow * GridPhase->ColCount + ACol;<\/p>\n

if (idx < 27) {
\nRecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = all.begin(); it != all.end(); ++it) {
\nif (*it && (*it)->id == 100) { container = *it; break; }
\n}
\nif (container && container->subStructure && idx < (int)container->subStructure->loops.size()) {
\nloop = container->subStructure->loops[idx];
\n}
\n} else {
\nint mainIdx = idx – 27;
\nif (mainIdx + 1 < (int)all.size()) { loop = all[mainIdx + 1]; } } if (!loop) { GridPhase->DefaultDrawing = true;
\nreturn;
\n}<\/p>\n

double topoW = loop->topological_winding;<\/p>\n

\/\/ ====================== \u8272\u5206\u3051 ======================
\ndouble intensity = fabs(topoW) \/ 0.5;
\nif (intensity > 1.0) intensity = 1.0;<\/p>\n

TColor baseColor = RGB(245, 245, 245);
\nif (topoW > 0.05) {
\nbaseColor = RGB(255, (int)(70 * (1.0 – intensity)), (int)(40 * (1.0 – intensity)));
\n} else if (topoW < -0.05) { baseColor = RGB((int)(40 * (1.0 – intensity)), (int)(70 * (1.0 – intensity)), 255); } GridPhase->Canvas->Brush->Color = baseColor;
\nGridPhase->Canvas->FillRect(Rect);<\/p>\n

AnsiString text = FormatFloat(“0.00”, topoW);
\nGridPhase->Canvas->Font->Color = (fabs(topoW) > 0.2) ? clYellow : clBlack;
\nGridPhase->Canvas->TextOut(Rect.Left + 8, Rect.Top + 10, text);<\/p>\n

if (fabs(topoW) > 0.22) {
\nGridPhase->Canvas->Pen->Color = clYellow;
\nGridPhase->Canvas->Pen->Width = 3;
\nGridPhase->Canvas->FrameRect(Rect);
\n}<\/p>\n

\/\/ ====================== \u30af\u30aa\u30ea\u30a2\u5f37\u8abf\uff08\u65b0\u898f\u8ffd\u52a0\uff09 ======================
\nif (loop->qualiaIntensity > 100.0) { \/\/ \u95be\u5024\u306f\u5f8c\u3067\u8abf\u6574
\nGridPhase->Canvas->Pen->Color = clLime;
\nGridPhase->Canvas->Pen->Width = 4;
\nGridPhase->Canvas->FrameRect(Rect);<\/p>\n

\/\/ \u3088\u308a\u76ee\u7acb\u3064\u5834\u5408
\n\/\/ GridPhase->Canvas->Brush->Color = TColor(baseColor | 0x808080);
\n\/\/ GridPhase->Canvas->FillRect(Rect);
\n}
\n}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::Button4Click(TObject *Sender)
\n{
\nClose();
\n}
\n\/\/—————————————————————————
\nvoid __fastcall TForm1::Timer1Timer(TObject *Sender)
\n{
\nCounter++; \/\/\u30bf\u30a4\u30de\u30fc\u30ab\u30a6\u30f3\u30bf\u30fc\u56de\u6570UP
\nLabel1->Caption = IntToStr(Counter);<\/p>\n

if (!graph) return;<\/p>\n

\/\/ === \u8a3a\u65ad\uff1acontainer\u304c\u5b58\u5728\u3059\u308b\u304b\u78ba\u8a8d ===
\nbool found = false;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\nfound = true;
\nbreak;
\n}
\n}
\nif (!found) {
\nMemo1->Lines->Add(“*** ERROR: Container ID:100 \u304c\u5931\u308f\u308c\u307e\u3057\u305f\uff01 ***”);
\n}<\/p>\n

\/\/ 1. \u66f4\u65b0\u51e6\u7406
\ngraph->UpdateAll(0.25);<\/p>\n

\/\/ 2. container\u3092\u63a2\u3057\u3066\u5b50\u69cb\u9020\u3092\u66f4\u65b0
\nRecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nRecursiveLoop* lp = *it;
\nif (lp && lp->id == 100) {
\ncontainer = lp;
\nbreak;
\n}
\n}<\/p>\n

if (container && container->subStructure) {
\nfor (int r = 0; r < 20; r++) { container->subStructure->UpdateAll(0.25);
\n}
\n}<\/p>\n

\/\/ 3. \u30c0\u30f3\u30d7
\n\/\/Memo1->Lines->Clear();
\nif (Counter % 800 == 0) { \/\/ 100\u56de\u306b1\u56de\u3060\u3051\u8a73\u7d30\u30c0\u30f3\u30d7<\/p>\n

\/\/Memo1->Lines->Clear();
\nMemo1->Lines->Add(“*******************************************************”);<\/p>\n

AnsiString str;
\nMemo1->Lines->Add(str.sprintf(“Counter = %d”, Counter));
\nMemo1->Lines->Add(“=== Timer Update ===”);<\/p>\n

if (container) {
\nMemo1->Lines->Add(“=== Container ID:100 (\u7269\u7406\u62e1\u5f35) ===”);
\ncontainer->DebugDump(Memo1, 1); \/\/ \u2190 RecursiveLoop\u7248\u3092\u4f7f\u3046
\n\/\/Timer1Timer\u306e\u30c0\u30f3\u30d7\u90e8\u5206\u306b\u8ffd\u52a0\uff08container->DebugDump\u306e\u5f8c\uff09\uff1a
\nMemo1->Lines->Add(Format(” Local Div ? %.4f”, ARRAYOFCONST((container->compute_local_divergence()))));<\/p>\n

if (container->subStructure) {
\nMemo1->Lines->Add(” \u2514\u2500 SubStructure:”);
\ncontainer->subStructure->DebugDump(Memo1, 2);<\/p>\n

\/\/Local Div\u306e\u8868\u793a\u3092\u5b50\u69cb\u9020\u306b\u3082\uff08\u4efb\u610f\uff09
\nMemo1->Lines->Add(” \u2514\u2500 SubStructure Local Divs:”);
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nif (*it) {
\nMemo1->Lines->Add(Format(” ID:%d Div:%.4f”,
\nARRAYOFCONST(((*it)->id, (*it)->compute_local_divergence()))));
\n}
\n}<\/p>\n

}
\n} else {
\nMemo1->Lines->Add(“*** Container (ID:100) \u304c\u898b\u3064\u304b\u308a\u307e\u305b\u3093 ***”);
\n}<\/p>\n

Memo1->Lines->Add(“=== Main Grid (27 loops) ===”);
\ngraph->DebugDump(Memo1, 0);<\/p>\n

\/\/ === \u6700\u5f8c\u306b\u5fc5\u305a\u8ffd\u52a0 ===
\nUpdatePhaseGrid(); \/\/ \u6bce\u56de\u66f4\u65b0<\/p>\n

} else {
\n\/\/ Memo1->Lines->Add(Format(“Step %d Neg(100):%.1f MaxTopo:%.3f”,
\n\/\/ ARRAYOFCONST((Counter, container ? container->negentropy : 0, container ? container->topological_winding : 0))));
\n\/\/ AnsiString str;
\n\/\/ Memo1->Lines->Add(str.sprintf(“Step %d Neg(100):%.1f MaxTopo:%.3f”,
\n\/\/ ARRAYOFCONST((Counter, container ? container->negentropy : 0, container ? container->topological_winding : 0))));
\n}<\/p>\n

\/\/ === CPT\u5bfe\u79f0\u6027\u30c6\u30b9\u30c8\uff08500\u30b9\u30c6\u30c3\u30d7\u6bce\uff09===
\n\/\/ === CPT\u5bfe\u79f0\u6027\u30c6\u30b9\u30c8\uff08800\u30b9\u30c6\u30c3\u30d7\u6bce\u306b\u5909\u66f4\uff09
\nif(Counter % 800 == 0 && container) {
\nAnsiString str;
\nMemo1->Lines->Add(“”);
\nMemo2->Lines->Add(“”);
\nMemo1->Lines->Add(str.sprintf(“Counter = %d”, Counter));
\nMemo2->Lines->Add(str.sprintf(“Counter = %d”, Counter));
\nMemo1->Lines->Add(“=== CPT\u5909\u63db\u30c6\u30b9\u30c8\u958b\u59cb ===”);
\nMemo2->Lines->Add(“=== CPT\u5909\u63db\u30c6\u30b9\u30c8\u958b\u59cb ===”);<\/p>\n

double before_topo = container->topological_winding;
\ndouble before_neg = container->negentropy;<\/p>\n

\/\/ CPT\u9069\u7528\uff08Container\uff09
\ncontainer->ApplyCPT();<\/p>\n

\/\/ SubStructure\u306b\u9069\u7528
\nif (container->subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nRecursiveLoop* lp = *it;
\nif (lp) lp->ApplyCPT();
\n}
\n}<\/p>\n

\/\/ Main\u30eb\u30fc\u30d7\u306b\u3082\u9069\u7528\uff08\u30aa\u30d7\u30b7\u30e7\u30f3\uff1a\u6700\u521d\u306f\u30b3\u30e1\u30f3\u30c8\u30a2\u30a6\u30c8\u63a8\u5968\uff09
\n\/\/ for (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\n\/\/ it != graph->loops.end(); ++it) {
\n\/\/ RecursiveLoop* lp = *it;
\n\/\/ if (lp && lp->id >= 300) lp->ApplyCPT();
\n\/\/ }<\/p>\n

\/\/ \u5909\u63db\u5f8c\u306b\u518d\u66f4\u65b0\u3057\u3066\u5b89\u5b9a\u5316
\ngraph->UpdateAll(0.25);<\/p>\n

double after_topo = container->topological_winding;
\ndouble after_neg = container->negentropy;<\/p>\n

\/\/ sprintf\u3067\u5b89\u5168\u306b\u51fa\u529b
\nMemo1->Lines->Add(str.sprintf(“Before TopoW: %.4f, Neg: %.2f”, before_topo, before_neg));
\nMemo2->Lines->Add(str.sprintf(“Before TopoW: %.4f, Neg: %.2f”, before_topo, before_neg));
\nMemo1->Lines->Add(str.sprintf(“After TopoW: %.4f, Neg: %.2f”, after_topo, after_neg));
\nMemo2->Lines->Add(str.sprintf(“After TopoW: %.4f, Neg: %.2f”, after_topo, after_neg));<\/p>\n

\/\/if (fabs(after_topo – before_topo) < 0.05) { \/\/ Memo1->Lines->Add(“\u2192 CPT\u5909\u63db\u5f8c\u3082TopoW\u304c\u307b\u307c\u4e0d\u5909\uff08\u5bfe\u79f0\u6027\u826f\u597d\uff09”);
\n\/\/} else {
\n\/\/ Memo1->Lines->Add(“\u2192 TopoW\u306b\u5909\u5316\u3042\u308a\uff08\u8981\u8abf\u6574\uff09”);
\n\/\/}<\/p>\n

\/\/\u5fae\u8abf\u6574
\nif (fabs(after_topo – before_topo) < 0.08) { \/\/ \u8a31\u5bb9\u7bc4\u56f2\u3092\u5c11\u3057\u7de9\u3081\u308b Memo1->Lines->Add(“\u2192 CPT\u5909\u63db\u5f8c\u3082TopoW\u304c\u307b\u307c\u4e0d\u5909\uff08\u5bfe\u79f0\u6027\u826f\u597d\uff09”);
\nMemo2->Lines->Add(“\u2192 CPT\u5909\u63db\u5f8c\u3082TopoW\u304c\u307b\u307c\u4e0d\u5909\uff08\u5bfe\u79f0\u6027\u826f\u597d\uff09”);
\n} else {
\nMemo1->Lines->Add(“\u2192 TopoW\u306b\u3084\u3084\u5909\u5316\u3042\u308a\uff08\u8a31\u5bb9\u7bc4\u56f2\u5185\uff09”);
\nMemo2->Lines->Add(“\u2192 TopoW\u306b\u3084\u3084\u5909\u5316\u3042\u308a\uff08\u8a31\u5bb9\u7bc4\u56f2\u5185\uff09”);
\n}<\/p>\n

Memo1->Lines->Add(“=== CPT\u5909\u63db\u30c6\u30b9\u30c8\u7d42\u4e86 ===”);
\nMemo2->Lines->Add(“=== CPT\u5909\u63db\u30c6\u30b9\u30c8\u7d42\u4e86 ===”);
\n}<\/p>\n

\/\/ === \u4fdd\u5b58\u5247\u30c6\u30b9\u30c8\uff08800\u30b9\u30c6\u30c3\u30d7\u6bce\uff09===
\nif (Counter % 800 == 0 && container) {
\nMemo1->Lines->Add(“=== \u4fdd\u5b58\u5247\u30c6\u30b9\u30c8\u958b\u59cb ===”);
\nMemo2->Lines->Add(“=== \u4fdd\u5b58\u5247\u30c6\u30b9\u30c8\u958b\u59cb ===”);<\/p>\n

double sum_div = 0.0;
\nint count = 0;
\ndouble max_div = 0.0;<\/p>\n

\/\/ Container + Sub + Main\u306eLocal Div\u3092\u96c6\u8a08
\nif (container) {
\ndouble div = container->compute_local_divergence();
\nsum_div += div;
\ncount++;
\nif (fabs(div) > max_div) max_div = fabs(div);
\n}<\/p>\n

if (container->subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nif (*it) {
\ndouble div = (*it)->compute_local_divergence();
\nsum_div += div;
\ncount++;
\nif (fabs(div) > max_div) max_div = fabs(div);
\n}
\n}
\n}<\/p>\n

\/\/ Main\u30eb\u30fc\u30d7\u3082\uff08\u7c21\u6613\uff09
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id >= 300) {
\ndouble div = (*it)->compute_local_divergence();
\nsum_div += div;
\ncount++;
\nif (fabs(div) > max_div) max_div = fabs(div);
\n}
\n}<\/p>\n

double avg_div = (count > 0) ? sum_div \/ count : 0.0;<\/p>\n

AnsiString str;
\nMemo1->Lines->Add(str.sprintf(“\u5e73\u5747 Local Div: %.6f (\u6700\u5927: %.4f, \u500b\u6570: %d)”, avg_div, max_div, count));
\nMemo2->Lines->Add(str.sprintf(“\u5e73\u5747 Local Div: %.6f (\u6700\u5927: %.4f, \u500b\u6570: %d)”, avg_div, max_div, count));<\/p>\n

\/\/if (fabs(avg_div) < 0.05) {
\n\/\/if (fabs(avg_div) < 0.15) { \/\/ 0.05 \u2192 0.15\u306b\u7de9\u548c
\nif (fabs(avg_div) < 0.25) { \/\/ 0.15 \u2192 0.25\u306b\u7de9\u548c Memo1->Lines->Add(“\u2192 \u4fdd\u5b58\u5247\u304c\u826f\u597d\u306b\u6210\u7acb\uff08Local Div ? 0\uff09”);
\nMemo2->Lines->Add(“\u2192 \u4fdd\u5b58\u5247\u304c\u826f\u597d\u306b\u6210\u7acb\uff08Local Div ? 0\uff09”);
\n} else {
\nMemo1->Lines->Add(“\u2192 \u4fdd\u5b58\u5247\u306b\u3084\u3084\u305a\u308c\u3042\u308a\uff08\u8981\u8abf\u6574\uff09”);
\nMemo2->Lines->Add(“\u2192 \u4fdd\u5b58\u5247\u306b\u3084\u3084\u305a\u308c\u3042\u308a\uff08\u8981\u8abf\u6574\uff09”);
\n}<\/p>\n

Memo1->Lines->Add(“=== \u4fdd\u5b58\u5247\u30c6\u30b9\u30c8\u7d42\u4e86 ===”);
\nMemo2->Lines->Add(“=== \u4fdd\u5b58\u5247\u30c6\u30b9\u30c8\u7d42\u4e86 ===”);
\n}<\/p>\n

\/\/ === \u30af\u30aa\u30ea\u30a2\u6307\u6a19\u306e\u8868\u793a === QualiaIntensity = |TopoW| \u00d7 negentropy \u00d7 coherence ===
\nif (Counter % 10 == 0 && container) {
\nAnsiString str;
\nMemo1->Lines->Add(str.sprintf(“Counter=%d QualiaIntensity (Container): %.2f”, Counter, container->qualiaIntensity));
\n}<\/p>\n

\/\/ === \u9ad8Qualia\u6642\u306e\u81ea\u52d5Observe\uff08\u610f\u8b58\u306e\u81ea\u767a\u7684\u73fe\u5b9f\u5316\uff09 ====
\nif (container && container->qualiaIntensity > 500.0 && (Counter % 50 == 0)) {
\n\/\/container->Observe(0.6); \/\/ \u5f31\u3081\u81ea\u52d5\u767a\u52d5
\n\/\/\u81ea\u52d5Observe\u306e\u95be\u5024\u3092\u52d5\u7684\u306b\uff08Qualia\u304c\u9ad8\u3044\u307b\u3069\u81ea\u52d5\u767a\u52d5\u3057\u3084\u3059\u304f\uff09
\ncontainer->Observe(0.4 + (container->qualiaIntensity \/ 2000.0));
\nMemo1->Lines->Add(“=== \u81ea\u52d5Observe\u767a\u52d5 (\u9ad8Qualia) ===”);<\/p>\n

double deltaQ = container->qualiaIntensity – container->beforeQualia;
\nMemo1->Lines->Add(AnsiString().sprintf(“Delta Qualia: +%.2f”, deltaQ));
\ncontainer->beforeQualia = container->qualiaIntensity;
\n}<\/p>\n

\/\/ === Chart\u66f4\u65b0 ===
\n\/*if (Counter % 10 == 0 && container) {
\ndouble totalNeg = container->negentropy;
\ndouble totalTopo = 0.0;<\/p>\n

for (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin(); it != graph->loops.end(); ++it) {
\nif (*it) {
\ntotalNeg += (*it)->negentropy;
\ntotalTopo += fabs((*it)->topological_winding);
\n}
\n}<\/p>\n

Chart1->Series[0]->AddY(totalNeg, “”, clRed); \/\/ Negentropy
\nChart1->Series[1]->AddY(totalTopo, “”, clBlue); \/\/ Total |TopoW|<\/p>\n

\/\/ \u81ea\u52d5\u30b9\u30b1\u30fc\u30eb\u8abf\u6574
\nChart1->LeftAxis->Automatic = true;
\nChart1->RightAxis->Automatic = true;
\n}*\/<\/p>\n

\/\/ Chart1\u3078\u306eQualiaIntensity\u8ffd\u52a0
\nif (Counter % 10 == 0 && container) {
\ndouble totalNeg = container->negentropy;
\ndouble totalTopo = 0.0;
\ndouble totalQualia = container->qualiaIntensity; \/\/ \u65b0\u898f<\/p>\n

for (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it) {
\ntotalNeg += (*it)->negentropy;
\ntotalTopo += fabs((*it)->topological_winding);
\ntotalQualia += (*it)->qualiaIntensity;
\n}
\n}<\/p>\n

Chart1->Series[0]->AddY(totalNeg, “”, clRed); \/\/ Negentropy\uff08\u5de6\u8ef8\uff09
\nChart1->Series[1]->AddY(totalTopo, “”, clBlue); \/\/ Total TopoW\uff08\u53f3\u8ef8\uff09
\nif (Chart1->SeriesCount() >= 3) {
\nChart1->Series[2]->AddY(totalQualia*0.005, “”, clLime); \/\/ Qualia Intensity
\nAnsiString str;
\nMemo2->Lines->Add(str.sprintf(“Counter=%d totalQualia: %4g”, Counter, totalQualia));
\n}
\n}<\/p>\n

\/\/ === CSV\u30ed\u30b0\u4fdd\u5b58\uff08120\u30b9\u30c6\u30c3\u30d7\u6bce\u30fb\u8ffd\u8a18\u30e2\u30fc\u30c9\uff09===
\nif (Counter % 120 == 0) {
\nTStringList *log = new TStringList();
\nAnsiString filename = ExtractFilePath(Application->ExeName) + “QRM_Log.csv”;<\/p>\n

\/\/ \u521d\u56de\u306e\u307f\u30d8\u30c3\u30c0\u30fc
\nif (!FileExists(filename)) {
\nlog->Add(“Step,Time,Neg_Container,Total_Neg,Max_TopoW,Ez_209”);
\n}<\/p>\n

RecursiveLoop* cont = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\ncont = *it;
\nbreak;
\n}
\n}<\/p>\n

double totalNeg = cont ? cont->negentropy : 0.0;
\ndouble maxTopo = 0.0;
\ndouble ez209 = 0.0;<\/p>\n

for (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it) {
\ntotalNeg += (*it)->negentropy;
\nif (fabs((*it)->topological_winding) > maxTopo)
\nmaxTopo = fabs((*it)->topological_winding);
\nif ((*it)->id == 209)
\nez209 = (*it)->E.z;
\n}
\n}<\/p>\n

AnsiString timeStr = FormatDateTime(“yyyy-mm-dd hh:nn:ss”, Now());
\nAnsiString line = Format(“%d,%s,%.4f,%.4f,%.4f,%.4f”,
\nARRAYOFCONST((Counter, timeStr,
\ncont ? cont->negentropy : 0.0,
\ntotalNeg, maxTopo, ez209)));<\/p>\n

log->Add(line);<\/p>\n

\/\/ \u8ffd\u8a18\u30e2\u30fc\u30c9\uff082007\u5bfe\u5fdc\u30fb\u5b89\u5168\u7248\uff09
\nif (FileExists(filename)) {
\nTFileStream *fs = new TFileStream(filename, fmOpenReadWrite | fmShareDenyWrite);
\nfs->Seek(0, soFromEnd); \/\/ \u30d5\u30a1\u30a4\u30eb\u672b\u5c3e\u306b\u79fb\u52d5
\nlog->SaveToStream(fs);
\ndelete fs;
\n} else {
\nlog->SaveToFile(filename);
\n}<\/p>\n

delete log;
\n}<\/p>\n

}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
\n{
\nTimer1->Enabled = false;
\n\/\/ graph\u306edelete\u306a\u3069
\n}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::FormCreate(TObject *Sender)
\n{
\nTimer1->Enabled = false;
\ngraph = new GraphSpatialStructure();<\/p>\n

\/\/ ==================== \u518d\u5e30\u30b3\u30f3\u30c6\u30ca\u3092\u6700\u512a\u5148\u3067\u8ffd\u52a0 ====================
\nRecursiveLoop* container = new RecursiveLoop(100, 0.0, 0.0, 0.5, 0, 0, 0);
\n\/\/ container\u4f5c\u6210\u90e8\u5206\u3067
\ncontainer->chi = std::complex(1.0, 0.0); \/\/ \u521d\u671f\u03c7<\/p>\n

GraphSpatialStructure* subGS = new GraphSpatialStructure();<\/p>\n

\/\/ \u5b50\u69cb\u9020 3x3x3
\nfor (int z = 0; z < 3; z++) {
\nfor (int y = 0; y < 3; y++) {
\nfor (int x = 0; x < 3; x++) { int id = 200 + x + y*3 + z*9; RecursiveLoop* child = new RecursiveLoop(id, -0.8 + (x + y + z)*0.2, 0.0, 0.0, x, y, z); \/\/ \u5b50\u69cb\u9020\u30eb\u30fc\u30d7\u5185 child->chi = std::complex(-0.8 + (x+y+z)*0.2, 0.0);<\/p>\n

subGS->AddLoop(child);
\n}
\n}
\n}<\/p>\n

\/\/ \u5b50\u69cb\u9020\u5185\u3092\u5168\u7d50\u5408 + \u52d5\u304d\u3084\u3059\u304f
\nfor (size_t i = 0; i < subGS->loops.size(); i++) {
\nfor (size_t j = 0; j < subGS->loops.size(); j++) {
\nif (i != j) {
\nsubGS->loops[i]->add_neighbor(subGS->loops[j]);
\n}
\n}
\nsubGS->loops[i]->fixation = 0.0;
\n}<\/p>\n

container->AttachSubStructure(subGS);
\ngraph->AddLoop(container); \/\/ \u2190 \u6700\u521d\u306b\u8ffd\u52a0<\/p>\n

\/\/ ==================== \u30e1\u30a4\u30f327\u500b\u306f container\u306e\u5f8c\u3067\u8ffd\u52a0 ====================
\n\/\/ Build3x3x3(graph); \/\/ \u2190 \u3053\u308c\u304c\u3042\u308b\u5834\u5408\u306f\u30b3\u30e1\u30f3\u30c8\u30a2\u30a6\u30c8\u3059\u308b\u304b\u3001container\u306e\u5f8c\u306b\u79fb\u52d5<\/p>\n

\/\/ \u30e1\u30a4\u30f327\u500b\u3092\u4f5c\u6210\uff08container\u306e\u5f8c\uff09
\n\/*for (int i = 0; i < 27; i++) { RecursiveLoop* lp = new RecursiveLoop(i, 0.0, 0.0, 0.5, i%3, (i\/3)%3, i\/9); \/\/ \u9069\u5f53\u306a\u4f4d\u7f6e lp->chi = std::complex(0.5, 0.0); \/\/ \u2190 \u8ffd\u52a0
\ngraph->AddLoop(lp);
\n}
\n*\/<\/p>\n

\/\/ \u69cb\u7bc9\u78ba\u8a8d
\nMemo1->Lines->Add(“=== FormCreate \u69cb\u7bc9\u5b8c\u4e86 ===”);
\ngraph->DebugDump(Memo1, 0);<\/p>\n

\/\/ \u30e1\u30a4\u30f327\u500b\u306f\u3053\u3053\u3067\u306f\u4f5c\u3089\u306a\u3044\uff08container\u3092\u5b88\u308b\u305f\u3081\uff09
\n\/\/ Build3x3x3(graph); \/\/ \u2190 \u7d76\u5bfe\u306b\u30b3\u30e1\u30f3\u30c8\u30a2\u30a6\u30c8\u304b\u524a\u9664<\/p>\n

\/\/ FormCreate\u306e\u6700\u5f8c\u306b
\nUpdatePhaseGrid();
\n\/\/GridPhase->Repaint(); \/\/ \u5f37\u5236\u518d\u63cf\u753b<\/p>\n

\/\/ FormCreate \u306e\u6700\u5f8c\u306b\u8ffd\u52a0
\nGridPhase->DefaultDrawing = false; \/\/ \u91cd\u8981\uff01
\nGridPhase->Repaint();<\/p>\n

Counter = 0; \/\/\u30bf\u30a4\u30de\u30fc\u30ab\u30a6\u30f3\u30bf\u306e\u30ea\u30bb\u30c3\u30c8<\/p>\n

\/\/ ==== TChart\u306e\u8a2d\u5b9a \u30b0\u30e9\u30d5\u63cf\u753b ====
\n\/\/ Chart\u4e8c\u8ef8\u8a2d\u5b9a\uff08C++Builder2007\u5bfe\u5fdc\uff09
\nif (Chart1->SeriesCount() >= 2) {
\n\/\/ Negentropy \u2192 \u5de6\u8ef8
\nChart1->Series[0]->VertAxis = 0; \/\/ 0 = vaLeft<\/p>\n

\/\/ Total TopoW \u2192 \u53f3\u8ef8
\nChart1->Series[1]->VertAxis = 1; \/\/ 1 = vaRight
\n}<\/p>\n

\/\/\u7e26\u8ef8\uff08\u5de6\uff09 \u30bf\u30a4\u30c8\u30eb
\nChart1->LeftAxis->Title->Caption = “Negentropy”;
\nChart1->LeftAxis->Title->Visible = true;<\/p>\n

\/\/\u7e26\u8ef8\uff08\u53f3\uff09 \u30bf\u30a4\u30c8\u30eb
\n\/\/Chart1->RightAxis->Title->Caption = “Total |TopoW|”;
\nChart1->RightAxis->Title->Visible = true;
\nChart1->RightAxis->Visible = true;
\n\/\/\u7e26\u8ef8\uff08\u5de6\uff09\u30b9\u30bf\u30a4\u30eb
\nChart1->LeftAxis->Title->Font->Size = 10;
\nChart1->LeftAxis->Title->Font->Style = TFontStyles() << fsBold; \/\/\u7e26\u8ef8\uff08\u53f3\uff09\u30b9\u30bf\u30a4\u30eb Chart1->RightAxis->Title->Font->Size = 10;
\nChart1->RightAxis->Title->Font->Style = TFontStyles() << fsBold; \/\/ QualiaIntensity\u7528\uff08\u7b2c3\u7cfb\u5217\uff09 if (Chart1->SeriesCount() >= 3) {
\nChart1->Series[2]->Title = “Qualia\u00d70.01”;
\nChart1->Series[2]->VertAxis = 1; \/\/ \u53f3\u8ef8\uff08\u307e\u305f\u306f0\u3067\u5de6\u8ef8\uff09
\n}<\/p>\n

\/\/\u7e26\u8ef8\uff08\u53f3\uff09 \u30bf\u30a4\u30c8\u30eb
\nChart1->RightAxis->Title->Caption = “Qualia\u00f7200 \/ TopoW”;
\nChart1->RightAxis->Visible = true;
\n\/\/\u6a2a\u8ef8 \u30bf\u30a4\u30c8\u30eb
\nChart1->BottomAxis->Title->Caption = “Counter\u00d70.1”;
\nChart1->BottomAxis->Visible = true;<\/p>\n

\/\/\u30b9\u30e9\u30a4\u30c0\u30fc\u521d\u671f\u5024\u306e\u30e9\u30d9\u30eb\u8868\u793a
\nLabel3->Caption = AnsiString().sprintf(“Observation_strength(0.1\uff5e3.0) %.2f”, TrackBar_Observation_strength->Position * 0.01);<\/p>\n

}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::FormDestroy(TObject *Sender)
\n{
\nif (graph) {
\ndelete graph; \/\/ \u4e0a\u8a18\u306e\u30c7\u30b9\u30c8\u30e9\u30af\u30bf\u304c\u547c\u3070\u308c\u308b
\ngraph = NULL;
\n}<\/p>\n

}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::Button5Click(TObject *Sender)
\n{
\nif (graph) graph->UpdateAll(0.1);
\ngraph->DebugDump(Memo1, 0);
\n}
\n\/\/—————————————————————————<\/p>\n

\/\/\uff08\u624b\u52d5CPT\u30c6\u30b9\u30c8\uff09
\nvoid __fastcall TForm1::ButtonCPTClick(TObject *Sender)
\n{
\nif (!graph) return;<\/p>\n

Memo1->Lines->Add(“=== \u624b\u52d5CPT\u30c6\u30b9\u30c8\u958b\u59cb ===”);<\/p>\n

RecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\ncontainer = *it;
\nbreak;
\n}
\n}<\/p>\n

if (container) {
\ndouble before = container->topological_winding;<\/p>\n

\/\/ CPT\u9069\u7528
\ncontainer->ApplyCPT();<\/p>\n

\/\/ SubStructure\u306b\u9069\u7528
\nif (container->subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nRecursiveLoop* lp = *it;
\nif (lp) lp->ApplyCPT();
\n}
\n}<\/p>\n

\/\/ \u66f4\u65b0
\ngraph->UpdateAll(0.25);<\/p>\n

AnsiString str;
\nMemo1->Lines->Add(str.sprintf(“CPT\u9069\u7528\u5f8c TopoW: %.4f (\u524d: %.4f)”,
\ncontainer->topological_winding, before));
\n}<\/p>\n

Memo1->Lines->Add(“=== \u624b\u52d5CPT\u30c6\u30b9\u30c8\u7d42\u4e86 ===”);
\n}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::CheckBox1Click(TObject *Sender)
\n{
\n\/\/Memo1,2\u306e\u8868\u793a\u3092\u3057\u306a\u3044\u3053\u3068\u3067\u3001\u8a08\u7b97\u512a\u5148\u3068\u3057\u3001\u30bf\u30a4\u30de\u30fc\u5468\u671f\u3092\u77ed\u304f\u3059\u308b
\nif(CheckBox1->Checked){
\nMemo1->Show();
\nMemo2->Show();
\n}else{
\nMemo1->Hide();
\nMemo2->Hide();
\n}
\n}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::Button6Click(TObject *Sender)
\n{
\nAnsiString str;<\/p>\n

\/\/\u73fe\u5728\u306e+3.0\u3067\u3082\u52b9\u679c\u304c\u51fa\u59cb\u3081\u305f\u306e\u3067\u3001\u4ee5\u4e0b\u306e\u3088\u3046\u306b**\u7948\u308a\u306e\u300c\u6ce2\u53ca\u529b\u300d**\u3092\u3055\u3089\u306b\u5f37\u304f\u3057\u3066\u307f\u307e\u3057\u3087\u3046\u3002
\n\/* if (!graph) return;<\/p>\n

RecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\ncontainer = *it;
\nbreak;
\n}
\n}<\/p>\n

if (!container) return;<\/p>\n

Memo1->Lines->Add(“=== \u7948\u308a\u5165\u529b\uff08\u5f37\u529b\u6ce2\u53ca\u7248\uff09 ===”);<\/p>\n

\/\/ \u7948\u308a\u5165\u529b\uff08\u6301\u7d9a\u30d6\u30fc\u30b9\u30c8\u7248\uff09
\ncontainer->phase += 8.0;
\ncontainer->topological_winding += 1.2;
\ncontainer->negentropy += 800.0;
\ncontainer->qualiaIntensity += 300.0;<\/p>\n

if (container->subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nif (*it) {
\n(*it)->phase += 4.0;
\n(*it)->topological_winding += 0.8;
\n(*it)->negentropy += 400.0;
\n(*it)->qualiaIntensity += 150.0;
\n}
\n}
\n}<\/p>\n

\/\/ \u3088\u308a\u9577\u3044\u66f4\u65b0
\nfor (int i = 0; i < 12; i++) { graph->UpdateAll(1.2);
\n}<\/p>\n

Memo1->Lines->Add(str.sprintf(“\u7948\u308a\u5f8c Qualia: %.2f, TopoW: %.4f, Neg: %.2f”,
\ncontainer->qualiaIntensity, container->topological_winding, container->negentropy));
\n*\/<\/p>\n

\/* if (!graph) return;<\/p>\n

RecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\ncontainer = *it;
\nbreak;
\n}
\n}<\/p>\n

if (!container) return;<\/p>\n

Memo1->Lines->Add(“=== \u7948\u308a\u5165\u529b\uff08\u6301\u7d9a\u5f37\u5316\u7248\uff09 ===”);<\/p>\n

\/\/ \u6301\u7d9a\u7684\u306a\u5f37\u30b7\u30d5\u30c8
\ncontainer->phase += 7.0;
\ncontainer->topological_winding += 1.2;
\ncontainer->negentropy += 1200.0;
\ncontainer->qualiaIntensity += 400.0;<\/p>\n

\/\/ Sub\u5168\u4f53\u306b\u5f37\u5f71\u97ff
\nif (container->subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nif (*it) {
\n(*it)->phase += 4.0;
\n(*it)->topological_winding += 0.9;
\n(*it)->negentropy += 600.0;
\n(*it)->qualiaIntensity += 250.0;
\n}
\n}
\n}<\/p>\n

\/\/ Main\u306b\u3082\u6ce2\u53ca
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id >= 300) {
\n(*it)->phase += 2.0;
\n(*it)->topological_winding += 0.4;
\n}
\n}<\/p>\n

\/\/ \u5927\u91cf\u66f4\u65b0
\nfor (int i = 0; i < 15; i++) { graph->UpdateAll(1.5);
\n}<\/p>\n

Memo1->Lines->Add(str.sprintf(“\u7948\u308a\u5f8c Qualia: %.2f, TopoW: %.4f, Neg: %.2f”,
\ncontainer->qualiaIntensity, container->topological_winding, container->negentropy));
\n*\/<\/p>\n

\/* if (!graph) return;<\/p>\n

RecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\ncontainer = *it;
\nbreak;
\n}
\n}<\/p>\n

if (!container) return;<\/p>\n

Memo1->Lines->Add(“=== \u7948\u308a\u5165\u529b\uff08\u6301\u7d9a\u5f37\u5316\u7248\uff09 ===”);<\/p>\n

\/\/ \u6301\u7d9a\u7684\u306a\u5f37\u30b7\u30d5\u30c8
\ncontainer->phase += 7.0;
\ncontainer->topological_winding += 1.2;
\ncontainer->negentropy += 1200.0;
\ncontainer->qualiaIntensity += 400.0;<\/p>\n

\/\/ Sub\u5168\u4f53\u306b\u5f37\u5f71\u97ff
\nif (container->subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nif (*it) {
\n(*it)->phase += 4.0;
\n(*it)->topological_winding += 0.9;
\n(*it)->negentropy += 600.0;
\n(*it)->qualiaIntensity += 250.0;
\n}
\n}
\n}<\/p>\n

\/\/ Main\u306b\u3082\u6ce2\u53ca
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id >= 300) {
\n(*it)->phase += 2.0;
\n(*it)->topological_winding += 0.4;
\n}
\n}<\/p>\n

\/\/ \u5927\u91cf\u66f4\u65b0
\nfor (int i = 0; i < 15; i++) { graph->UpdateAll(1.5);
\n}<\/p>\n

Memo1->Lines->Add(str.sprintf(“\u7948\u308a\u5f8c Qualia: %.2f, TopoW: %.4f, Neg: %.2f”,
\ncontainer->qualiaIntensity, container->topological_winding, container->negentropy));
\n*\/<\/p>\n

\/* if (!graph) return;<\/p>\n

RecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\ncontainer = *it;
\nbreak;
\n}
\n}<\/p>\n

if (!container) return;<\/p>\n

Memo1->Lines->Add(“=== \u7948\u308a\u5165\u529b\uff08\u6301\u7d9a\u5f37\u5316\u7248\uff09 ===”);<\/p>\n

\/\/ \u6301\u7d9a\u7684\u306a\u5f37\u30b7\u30d5\u30c8
\ncontainer->phase += 7.0;
\ncontainer->topological_winding += 1.2;
\ncontainer->negentropy += 1200.0;
\ncontainer->qualiaIntensity += 400.0;<\/p>\n

\/\/ Sub\u5168\u4f53\u306b\u5f37\u5f71\u97ff
\nif (container->subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nif (*it) {
\n(*it)->phase += 4.0;
\n(*it)->topological_winding += 0.9;
\n(*it)->negentropy += 600.0;
\n(*it)->qualiaIntensity += 250.0;
\n}
\n}
\n}<\/p>\n

\/\/ Main\u306b\u3082\u6ce2\u53ca
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id >= 300) {
\n(*it)->phase += 2.0;
\n(*it)->topological_winding += 0.4;
\n}
\n}<\/p>\n

\/\/ \u5927\u91cf\u66f4\u65b0
\nfor (int i = 0; i < 15; i++) { graph->UpdateAll(1.5);
\n}<\/p>\n

Memo1->Lines->Add(str.sprintf(“\u7948\u308a\u5f8c Qualia: %.2f, TopoW: %.4f, Neg: %.2f”,
\ncontainer->qualiaIntensity, container->topological_winding, container->negentropy));
\n*\/<\/p>\n

\/* if (!graph) return;<\/p>\n

RecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\ncontainer = *it;
\nbreak;
\n}
\n}<\/p>\n

if (!container) return;<\/p>\n

Memo1->Lines->Add(“=== \u7948\u308a\u5165\u529b\uff08\u6301\u7d9a\u5f37\u5316\u7248\uff09 ===”);<\/p>\n

\/\/ \u6301\u7d9a\u7684\u306a\u5f37\u30b7\u30d5\u30c8
\ncontainer->phase += 7.0;
\ncontainer->topological_winding += 1.2;
\ncontainer->negentropy += 1200.0;
\ncontainer->qualiaIntensity += 400.0;<\/p>\n

\/\/ Sub\u5168\u4f53\u306b\u5f37\u5f71\u97ff
\nif (container->subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nif (*it) {
\n(*it)->phase += 4.0;
\n(*it)->topological_winding += 0.9;
\n(*it)->negentropy += 600.0;
\n(*it)->qualiaIntensity += 250.0;
\n}
\n}
\n}<\/p>\n

\/\/ Main\u306b\u3082\u6ce2\u53ca
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id >= 300) {
\n(*it)->phase += 2.0;
\n(*it)->topological_winding += 0.4;
\n}
\n}<\/p>\n

\/\/ \u5927\u91cf\u66f4\u65b0
\nfor (int i = 0; i < 15; i++) { graph->UpdateAll(1.5);
\n}<\/p>\n

Memo1->Lines->Add(str.sprintf(“\u7948\u308a\u5f8c Qualia: %.2f, TopoW: %.4f, Neg: %.2f”,
\ncontainer->qualiaIntensity, container->topological_winding, container->negentropy));
\n*\/<\/p>\n

if (!graph) return;<\/p>\n

RecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\ncontainer = *it;
\nbreak;
\n}
\n}<\/p>\n

if (!container) return;<\/p>\n

Memo1->Lines->Add(“=== \u7948\u308a\u5165\u529b\uff08\u6301\u7d9a\u5f37\u5316\u7248\uff09 ===”);
\nMemo2->Lines->Add(“=== \u7948\u308a\u5165\u529b\uff08\u6301\u7d9a\u5f37\u5316\u7248\uff09 ===”);<\/p>\n

\/\/ \u63d0\u6848A: \u5171\u9cf4\u5f37\u5316\uff08\u73fe\u5728\u306e\u72b6\u614b\u306b\u6bd4\u4f8b\u3055\u305b\u308b\uff09
\n\/\/double resonance = 1.0 + (container->negentropy \/ 800.0) + (container->qualiaIntensity \/ 200.0); \/\/ \u5171\u9cf4\u4fc2\u6570
\n\/\/\u7948\u308a\u5f37\u5ea6\u306e\u8abf\u6574: \u73fe\u5728\u306e\u7948\u308a\u30d6\u30fc\u30b9\u30c8\u304c\u5f37\u3081\u306a\u306e\u3067\u3001\u4ee5\u4e0b\u306e\u3088\u3046\u306b**resonance\uff08\u5171\u9cf4\uff09**\u3092\u5165\u308c\u3066\u5b89\u5b9a\u5316\uff1a
\ndouble resonance = 1.0 + (container->qualiaIntensity \/ 300.0); \/\/ \u5171\u9cf4\u4fc2\u6570
\ndouble prayerStrength = 1.0; \/\/ \u5c06\u6765\u7684\u306b\u30b9\u30e9\u30a4\u30c0\u30fc\u3067\u8abf\u6574\u53ef\u80fd<\/p>\n

\/\/ \u6301\u7d9a\u7684\u306a\u5f37\u30b7\u30d5\u30c8
\ncontainer->phase += 7.0;
\ncontainer->topological_winding += 1.2;
\n\/\/container->negentropy += 1200.0;
\n\/\/\u7948\u308a\u5f37\u5ea6\u306e\u8abf\u6574: \u73fe\u5728\u306e\u7948\u308a\u30d6\u30fc\u30b9\u30c8\u304c\u5f37\u3081\u306a\u306e\u3067\u3001\u4ee5\u4e0b\u306e\u3088\u3046\u306b**resonance\uff08\u5171\u9cf4\uff09**\u3092\u5165\u308c\u3066\u5b89\u5b9a\u5316\uff1a
\ncontainer->negentropy += 800.0 * resonance;
\ncontainer->qualiaIntensity += 400.0;<\/p>\n

\/\/ Sub\u5168\u4f53\u306b\u5f37\u5f71\u97ff
\nif (container->subStructure) {
\nfor (std::vector<RecursiveLoop*>::iterator it = container->subStructure->loops.begin();
\nit != container->subStructure->loops.end(); ++it) {
\nif (*it) {
\n(*it)->phase += 4.0;
\n(*it)->topological_winding += 0.9;
\n(*it)->negentropy += 600.0;
\n(*it)->qualiaIntensity += 250.0;
\n}
\n}
\n}<\/p>\n

\/\/ Main\u306b\u3082\u6ce2\u53ca
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id >= 300) {
\n(*it)->phase += 2.0;
\n(*it)->topological_winding += 0.4;
\n}
\n}<\/p>\n

\/\/ \u5927\u91cf\u66f4\u65b0
\nfor (int i = 0; i < 15; i++) { graph->UpdateAll(1.5);
\n}<\/p>\n

Memo1->Lines->Add(str.sprintf(“\u7948\u308a\u5f8c Qualia: %.2f, TopoW: %.4f, Neg: %.2f”,
\ncontainer->qualiaIntensity, container->topological_winding, container->negentropy));
\nMemo2->Lines->Add(str.sprintf(“\u7948\u308a\u5f8c Qualia: %.2f, TopoW: %.4f, Neg: %.2f”,
\ncontainer->qualiaIntensity, container->topological_winding, container->negentropy));<\/p>\n

\/\/ \u4eca\u5f8c\u306e\u5f37\u5316\u6848\uff08\u3059\u3050\u306b\u8a66\u305b\u308b\u3082\u306e\uff09Observe\u306e\u52b9\u679c\u3092\u7948\u308a\u3068\u9023\u52d5
\n\/\/ \u7948\u308a\u30dc\u30bf\u30f3\uff08Button6Click\uff09\u306e\u6700\u5f8c\u306bcontainer->Observe(0.8); \u3092\u8ffd\u52a0\u3057\u3066\u307f\u3066\u304f\u3060\u3055\u3044\u3002
\n\/\/ \u2192 \u7948\u308a\u3067\u300c\u610f\u56f3\u3092\u6ce8\u5165\u300d\u2192 Observe\u3067\u300c\u89b3\u6e2c\u30fb\u56fa\u5b9a\u300d\u3059\u308b\u6d41\u308c\u304c\u81ea\u7136\u306b\u306a\u308a\u307e\u3059\u3002
\ncontainer->Observe(0.8);
\n}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::ButtonObserveClick(TObject *Sender)
\n{
\nif (!graph) return;<\/p>\n

\/\/ === container\uff08ID:100\uff09\u3092\u6bce\u56de\u691c\u7d22 ===
\nRecursiveLoop* container = NULL;
\nfor (std::vector<RecursiveLoop*>::iterator it = graph->loops.begin();
\nit != graph->loops.end(); ++it) {
\nif (*it && (*it)->id == 100) {
\ncontainer = *it;
\nbreak;
\n}
\n}<\/p>\n

if (!container) {
\nMemo1->Lines->Add(“*** ERROR: Container ID:100 \u304c\u898b\u3064\u304b\u308a\u307e\u305b\u3093 ***”);
\nreturn;
\n}<\/p>\n

\/\/ Observe\u5b9f\u884c
\ndouble beforeQualia = container->qualiaIntensity;
\ndouble beforeTopo = container->topological_winding;
\ndouble Observation_strength = TrackBar_Observation_strength->Position * 0.01;<\/p>\n

Label3->Caption = AnsiString().sprintf(“Observation_strength(0.1\uff5e3.0) %.2f”, Observation_strength);
\ncontainer->Observe(1.0); \/\/ \u5f37\u3055\u306f1.0\u56fa\u5b9a\u3001\u307e\u305f\u306f\u30b9\u30e9\u30a4\u30c0\u30fc\u5909\u6570\u3067\u8abf\u6574 \/\/ \u307e\u305f\u306f0.7?1.2\u3067\u8abf\u6574
\nMemo1->Lines->Add(AnsiString().sprintf(“Observe\u5b9f\u884c (strength=%.1f)”, Observation_strength));
\nMemo2->Lines->Add(AnsiString().sprintf(“Observe\u5b9f\u884c (strength=%.1f)”, Observation_strength));<\/p>\n

Memo1->Lines->Add(“=== Observe\u5b9f\u884c (\u73fe\u5b9f\u5316) ===”);
\nMemo2->Lines->Add(“=== Observe\u5b9f\u884c (\u73fe\u5b9f\u5316) ===”);
\nMemo1->Lines->Add(AnsiString().sprintf(“Qualia\u5f8c: %.2f, Phase: %.4f”,
\ncontainer->qualiaIntensity, container->phase));
\nMemo2->Lines->Add(AnsiString().sprintf(“Qualia\u5f8c: %.2f, Phase: %.4f”,
\ncontainer->qualiaIntensity, container->phase));
\nMemo1->Lines->Add(AnsiString().sprintf(
\n“=== Observe\u5b9f\u884c === Before Qualia: %.2f \u2192 After: %.2f | TopoW: %.4f \u2192 %.4f”,
\nbeforeQualia, container->qualiaIntensity, beforeTopo, container->topological_winding));
\nMemo2->Lines->Add(AnsiString().sprintf(
\n“=== Observe\u5b9f\u884c === Before Qualia: %.2f \u2192 After: %.2f | TopoW: %.4f \u2192 %.4f”,
\nbeforeQualia, container->qualiaIntensity, beforeTopo, container->topological_winding));<\/p>\n

\/\/ \u5373\u6642\u53cd\u6620
\ngraph->UpdateAll(0.5);
\n}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::TrackBar_Observation_strengthChange(TObject *Sender)
\n{
\nLabel3->Caption = AnsiString().sprintf(“Observation_strength(0.1\uff5e3.0) %.2f”, TrackBar_Observation_strength->Position * 0.01);
\n}
\n\/\/—————————————————————————<\/p>\n

void __fastcall TForm1::ButtonPrayObserveClick(TObject *Sender)
\n{
\n\t\/\/\u300c\u7948\u308a\uff0bObserve\u30ef\u30f3\u30dc\u30bf\u30f3\u300d**\u3092\u4f5c\u6210\uff081\u30af\u30ea\u30c3\u30af\u3067\u7948\u308a\u2192\u77ed\u3044\u5f85\u6a5f\u2192Observe\uff09\u3002
\n\t\/\/Button6Click(Sender);
\n\t\/\/ButtonObserveClick(Sender);<\/p>\n

\t\/\/ === container\uff08ID:100\uff09\u3092\u6bce\u56de\u691c\u7d22 ===
\n\tRecursiveLoop* container = NULL;
\n\tfor (std::vector::iterator it = graph->loops.begin();
\n\t\t it != graph->loops.end(); ++it) {
\n\t\tif (*it && (*it)->id == 100) {
\n\t\t\tcontainer = *it;
\n\t\t\tbreak;
\n\t\t}
\n\t}<\/p>\n

\tif (!container) {
\n\t\tMemo1->Lines->Add(“*** ERROR: Container ID:100 \u304c\u898b\u3064\u304b\u308a\u307e\u305b\u3093 ***”);
\n return;
\n }<\/p>\n

\t\/\/ container\u691c\u7d22
\n\tif (container) {
\n\t\tcontainer->phase += 4.0; \/\/ \u8efd\u3081\u306e\u7948\u308a
\n\t\t\/\/ resonance\u4ed8\u304d\u7948\u308a\u52b9\u679c\uff08\u4e00\u90e8\uff09
\n\t\tdouble resonance = 1.0 + (container->qualiaIntensity \/ 300.0);
\n\t\tcontainer->negentropy += 400.0 * resonance;
\n\t\tcontainer->Observe(1.8); \/\/ \u7948\u308a\u5f8c\u306bObserve\uff082.02\u8fd1\u8fba\uff09
\n\t}
\n\tgraph->UpdateAll(1.0);
\n}
\n\/\/—————————————————————————<\/p>\n","protected":false},"excerpt":{"rendered":"

\/\/************************************** … \u7d9a\u304d\u3092\u8aad\u3080 →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_post_was_ever_published":false},"categories":[1],"tags":[],"class_list":["post-30188","post","type-post","status-publish","format-standard","hentry","category-1"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/posts\/30188","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/comments?post=30188"}],"version-history":[{"count":55,"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/posts\/30188\/revisions"}],"predecessor-version":[{"id":30359,"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/posts\/30188\/revisions\/30359"}],"wp:attachment":[{"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/media?parent=30188"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/categories?post=30188"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/123210.net\/wordpress\/tatenaoshi\/wp-json\/wp\/v2\/tags?post=30188"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}