Upload 2 files

codette_quantum_multicore.py

@@ -0,0 +1,81 @@
+import numpy as np
+import os
+import json
+import random
+import requests
+from multiprocessing import Pool, cpu_count
+
+CORES = 15  # Set your number of cores here
+
+# Cognitive cocoon module (same as previous for compatibility)
+class CognitionCocooner:
+    def __init__(self, storage_path="./astro_cocoons"):
+        self.storage_path = storage_path
+        if not os.path.exists(storage_path):
+            os.makedirs(storage_path)
+    def wrap(self,label,data):
+        meta={"label":label,"data":data}
+        fname=f"{label}_{random.randint(1000,9999)}_{os.getpid()}.cocoon"
+        fpath=os.path.join(self.storage_path,fname)
+        with open(fpath,"w") as f: json.dump(meta,f)
+        return fpath
+
+# Perspective Agent, experiment logic unchanged
+class PerspectiveAgent:
+    def __init__(self,name): self.name=name
+    def analyze(self,result,space_info=None):
+        if self.name=="Quantum":
+            return f"Quantum perspective: Measured value was {result}. Superposed realities possible."
+        elif self.name=="Newton":
+            return f"Newtonian logic: State followed deterministic evolution from {space_info}."
+        elif self.name=="Stardust":
+            return f"Stardust agent: Interleaved {space_info} into experiment as entropy!"
+        else: return "Unknown perspective..."
+
+def fetch_exoplanet_star_data():
+    try:
+        url = ('https://exoplanetarchive.ipac.caltech.edu/TAP/sync?query=select+pl_hostname,pl_rade,pl_orbper+from+pscomppars+where+rownum+<2&format=json')
+        res = requests.get(url,timeout=3)
+        j=res.json()
+        return j[0] if j else {"pl_hostname":"unknown"}
+    except Exception:
+        return {"pl_hostname":"unknown"}
+
+def quantum_astro_experiment(space_entropy):
+    radius=float(space_entropy.get("pl_rade") or 1.0)
+    period=float(space_entropy.get("pl_orbper") or 1.0)
+    superposition=np.array([random.random()*radius,random.random()*period])
+    sigma=radius; rho=period; beta=8/3; x=0.1*radius; y=0.2*period; z=0.2*radius
+    dt=0.01; steps=50
+    for _ in range(steps):
+        dx=sigma*(y-x)*dt; dy=(x*(rho-z)-y)*dt; dz=(x*y-beta*z)*dt
+        x+=dx; y+=dy; z+=dz
+    return superposition.tolist(), [x,y,z]
+
+def codette_experiment_task(proc_id):
+    cocoons=CognitionCocooner("./astro_cocoons")
+    sp_data=fetch_exoplanet_star_data()
+    qq_state, chaos_state = quantum_astro_experiment(sp_data)
+    qa = PerspectiveAgent("Quantum")
+    na = PerspectiveAgent("Newton")
+    sa = PerspectiveAgent("Stardust")
+    q_comment=qa.analyze(qq_state[0],sp_data)
+    n_comment=na.analyze(chaos_state[0],sp_data)
+    s_comment=sa.analyze("---",sp_data["pl_hostname"])
+    record_dict={
+       "stardust_input":sp_data,
+       "quantum_state":qq_state,
+       "chaos_state":chaos_state,
+       "perspectives":[q_comment,n_comment,s_comment],
+       "run_by_proc": proc_id,
+       "pid": os.getpid()
+    }
+    cocoon_file=cocoons.wrap(label="quantum_space_trial", data=record_dict)
+    print(f"[Core {proc_id} | PID {os.getpid()}] Cocooned in {cocoon_file}")
+    return cocoon_file
+
+if __name__=="__main__":
+    pool = Pool(CORES)
+    jobs = [i for i in range(CORES)]
+    results = pool.map(codette_experiment_task, jobs)
+    print("\n[All cocoons written across all available processors!]")

codette_quantum_multicore2.py

@@ -0,0 +1,77 @@
+import os
+import json
+import numpy as np
+import matplotlib.pyplot as plt
+
+folder = '.'  # Or your path to cocoons
+
+quantum_states=[]
+chaos_states=[]
+proc_ids=[]
+labels=[]
+all_perspectives=[]
+meta_mutations=[]
+
+def simple_neural_activator(quantum_vec, chaos_vec):
+    # Lightweight thresholds: feels like a tiny neural net inspired by input!
+    q_sum = sum(quantum_vec)
+    c_var = np.var(chaos_vec)
+    activated = 1 if q_sum + c_var > 1 else 0
+    return activated
+
+def codette_dream_agent(quantum_vec, chaos_vec):
+    # Blend them using pseudo-random logic—a “mutated” universe!
+    dream_q = [np.sin(q * np.pi) for q in quantum_vec]
+    dream_c = [np.cos(c * np.pi) for c in chaos_vec]
+    return dream_q, dream_c
+
+def philosophical_perspective(qv, cv):
+    # Synthesizes a philosophy based on state magnitude and spread
+    m = np.max(qv) + np.max(cv)
+    if m > 1.3:
+        return "Philosophical Note: This universe is likely awake."
+    else:
+        return "Philosophical Note: Echoes in the void."
+
+# Meta processing loop
+print("\nMeta Reflection Table:\n")
+header = "Cocoon File | Quantum State | Chaos State | Neural | Dream Q/C | Philosophy"
+print(header)
+print('-'*len(header))
+
+for fname in os.listdir(folder):
+    if fname.endswith('.cocoon'):
+        with open(os.path.join(folder, fname), 'r') as f:
+            try:
+                dct=json.load(f)['data']
+                q=dct.get('quantum_state',[0,0])
+                c=dct.get('chaos_state',[0,0,0])
+                neural=simple_neural_activator(q,c)
+                dreamq,dreamc=codette_dream_agent(q,c)
+                phil=philosophical_perspective(q,c)
+                quantum_states.append(q)
+                chaos_states.append(c)
+                proc_ids.append(dct.get('run_by_proc',-1))
+                labels.append(fname)
+                all_perspectives.append(dct.get('perspectives',[]))
+                meta_mutations.append({'dreamQ':dreamq,'dreamC':dreamc,'neural':neural,'philosophy':phil})
+                print(f"{fname} | {q} | {c} | {neural} | {dreamq}/{dreamc} | {phil}")
+            except Exception as e:
+                print(f"Warning: {fname} failed ({e})")
+
+# Also plot meta-dream mutated universes!
+if len(meta_mutations)>0:
+    dq0=[m['dreamQ'][0] for m in meta_mutations]
+    dc0=[m['dreamC'][0] for m in meta_mutations]
+    ncls=[m['neural'] for m in meta_mutations]
+
+    plt.figure(figsize=(8,6))
+    sc=plt.scatter(dq0,dc0,c=ncls,cmap='spring',s=100)
+    plt.xlabel('Dream Quantum[0]')
+    plt.ylabel('Dream Chaos[0]')
+    plt.title('Meta-Dream Codette Universes')
+    plt.colorbar(sc,label="Neural Activation Class")
+    plt.grid(True)
+    plt.show()
+else:
+    print("No valid cocoons found for meta-analysis.")