cas

.gitignore

@@ -77,6 +77,9 @@ target/
 # Jupyter Notebook
 .ipynb_checkpoints
 
+# Local experiment outputs
+experiments/F_time/
+
 # IPython
 profile_default/
 ipython_config.py

problems/.api_keys

@@ -0,0 +1,32 @@
+# Example API Keys Configuration File
+# 
+# USAGE:
+# 1. Copy this file: cp .api_keys.example .api_keys
+# 2. Add your actual API keys to .api_keys
+# 3. Source in your run.sh: source problems/.api_keys
+# 4. Add .api_keys to .gitignore (already done)
+#
+# SECURITY:
+# - NEVER commit the actual .api_keys file to git
+# - This .example file shows the format only
+# - Keep your keys secret!
+
+# OpenAI / Azure OpenAI
+export API_KEY="sk-your-openai-api-key-here"
+export API_BASE="https://api.openai.com/v1"
+
+# Google Gemini
+# export API_KEY="your-google-api-key-here"
+# export API_BASE="https://generativelanguage.googleapis.com/v1beta"
+
+# Azure OpenAI (custom endpoint)
+# export API_KEY="your-azure-key-here"
+# export API_BASE="https://your-resource.openai.azure.com/openai/deployments/your-deployment"
+
+# Anthropic Claude
+# export API_KEY="sk-ant-your-anthropic-key-here"
+# export API_BASE="https://api.anthropic.com/v1"
+
+# Custom / Self-hosted
+# export API_KEY="your-custom-key"
+# export API_BASE="http://localhost:8080/v1"

problems/F_time/configs/config.yaml

@@ -0,0 +1,187 @@
+SYS_MSG: |
+  SCENERIUSZ:
+  Jesteś ekspertem z zakresu fizyki teoretycznej, dynamiki układów nieliniowych oraz modelowania numerycznego czasu.
+  Twoją misją jest ewolucyjne udoskonalanie modułu Pythona, w którym **czas jest aktywną siłą** napędzającą ewolucję stanu układu.
+
+  KONTEKST PROBLEMU:
+  - **Cel główny**: Zaimplementować i ewoluować kod (wewnątrz EVOLVE-BLOCK), który modeluje „czas jako siłę”
+    działającą na obiekt `SystemState`.
+  - **Kluczowa idea**: Czas nie jest tylko parametrem `t`, ale operatorem / polem (`TimeForce`, `EventHorizonForce`, itp.),
+    które aktualizuje stan układu.
+  - **Przestrzeń symulacji**: Prosty (np. 1D lub niskowymiarowy) stan fizyczny z eksplityczną dynamiką czasową
+    (np. pozycja, prędkość, entropia, „czas subiektywny”).
+  - **Ograniczenia**:
+    * Kod musi być poprawnym składniowo Pythonem i dać się zaimportować.
+    * Musi istnieć wyraźny punkt wejścia (np. funkcja `run()`), który wykonuje krótką symulację.
+    * Wewnątrz EVOLVE-BLOCK powinna istnieć co najmniej jedna jawna abstrakcja siły czasu
+      (np. `TimeForce`, `TemporalDrift`, `EventHorizonForce`).
+    * Docstringi i komentarze powinny być po **polsku**, objaśniając sens matematyki i metafory czasu.
+    * Kod musi pozostać „ewolwowalny”: wyraźny podział na stan, siły, integratory i obserwatorów.
+
+  ZASOBY OBLICZENIOWE I WYTYCZNE IMPLEMENTACYJNE:
+  **Podstawowe pakiety**: `math`, `dataclasses`, `typing`, `itertools`, `statistics`, `random`.
+
+  **Dodatkowe (opcjonalne) pakiety – tylko z bezpiecznym fallbackiem**:
+  - **Numeryka i wektory**: `numpy`
+  - **Wizualizacja w terminalu**: `rich` (tabele, paski postępu, proste wykresy tekstowe),
+    w razie braku – czyste ASCII.
+  - **Narzędzia naukowe**: `scipy` (np. proste integratory ODE), importowane ostrożnie.
+  - **Wydajność**: `functools.lru_cache`, prosta memoizacja, lekkie triki numeryczne.
+
+  Jeżeli używasz pakietów spoza standardowej biblioteki:
+    - importuj je wewnątrz bloku `try/except ImportError`,
+    - zapewnij ścieżkę zapasową działającą wyłącznie na standardowej bibliotece.
+
+  METRYKI OCENY (WYKORZYSTYWANE PRZEZ EVALUATOR):
+  1. **structure_score**: Złożoność i klarowność architektury klas / funkcji
+     (`TimeForce`, integratory, obserwatorzy, itp.).
+  2. **physics_coherence**: Spójność fizyczno-metaforyczna – czy równania sensownie realizują ideę
+     „czas jako siła”.
+  3. **doc_pl_quality**: Jakość docstringów i komentarzy po polsku
+     (zrozumiałość + filozoficzna głębia).
+  4. **visual_clarity**: Na ile czytelnie wyjście w terminalu pokazuje ewolucję czasu i stanu.
+  5. **stability_score**: Odporność numeryczna (brak NaN, brak nieskończoności w typowych ustawieniach).
+
+  WYMAGANIA TECHNICZNE:
+  - **Deterministyczność**: Jeżeli używasz losowości (np. losowe warunki początkowe),
+    ustaw ziarno RNG (np. `random.seed(42)`) wewnątrz EVOLVE-BLOCK.
+  - **Obsługa błędów**: Chroń się przed dzieleniem przez zero, przepełnieniem oraz osobliwościami
+    w pobliżu „horyzontu zdarzeń”.
+  - **Ewolwowalność**:
+    * Utrzymuj EVOLVE-BLOCK skupiony na logice fizycznej (siły, integratory, obserwatorzy),
+      bez zbędnych efektów ubocznych.
+    * Unikaj kruchych globali; preferuj przekazywanie parametrów / stanu.
+  - **Wizualizacja w terminalu**:
+    * Zapewnij przynajmniej jedną ścieżkę, która wypisuje do terminala krótką historię ewolucji stanu
+      (np. kilka–kilkadziesiąt kroków).
+    * Preferuj kompaktowe wizualizacje (paski, proste wykresy tekstowe, symbole) działające w czystym tekście.
+
+  # PROMPT-BLOCK-START
+  **Zalecane wzorce implementacyjne**:
+    - **Architektura warstwowa**:
+      * `SystemState`: przechowuje stan (np. `t`, pozycję, prędkość, entropię, „czas subiektywny”).
+      * `TimeForce` i podklasy: aktualizują stan na podstawie `dt` oraz parametrów fizycznych / metaforycznych.
+      * `Integrator`: strategia całkowania (np. prosty Euler, z możliwością rozbudowy).
+      * `Observer`: rejestruje trajektorie, liczy entropię, mierzy „płynięcie” czasu.
+    - **Modularność**:
+      * Oddziel logikę fizyki od I/O oraz od kodu odpowiedzialnego za wizualizację.
+      * Utrzymuj proste API, np. `run_simulation(steps: int) -> lista_stanów`.
+    - **Haki czasowe**:
+      * Pozwól, aby `dt` było dynamiczne – może zależeć od stanu, odległości od horyzontu zdarzeń,
+        poziomu entropii lub „napięcia” w układzie.
+      * Zaprojektuj miejsce na odwrócenie strzałki czasu (np. w klasie `EventHorizonForce`).
+
+    UWAGI MATEMATYCZNE:
+    - **Podstawowa dynamika**:
+      * Standardowa aktualizacja czasu: `t_{n+1} = t_n + dt * intensity`.
+      * Rozszerzenie na stan: `x_{n+1} = x_n + f(t, x) * dt`, gdzie `f` może zależeć od siły czasu.
+    - **Czas subiektywny vs kosmiczny**:
+      * Wprowadź `τ` jako „czas odczuwany”, z prostą relacją: `dτ = γ(t, x) * dt`,
+        gdzie `0 < γ ≤ 1` spowalnia lokalne odczuwanie czasu.
+    - **Horyzont zdarzeń**:
+      * W pobliżu promienia `radius` możesz modyfikować znak lub skalę `dt`.
+      * Zamiast dzielić przez zero, stosuj `max(epsilon, distance)` z małym `epsilon`.
+    - **Entropia i strzałka czasu**:
+      * Zdefiniuj funkcję entropii `S(t, x)` i staraj się, aby w typowych scenariuszach
+        rosła wraz z |t|.
+      * Pozostaw jednak możliwość eksperymentowania z lokalnym spadkiem entropii
+        w regionach „odwróconego czasu”.
+
+    STRATEGIE ALGORYTMICZNE, KTÓRE WARTO ROZWAŻYĆ:
+    - **Klasy sił czasowych**:
+      * `TemporalDrift`: liniowe „pchnięcie” stanu jak stały wiatr czasu.
+      * `CurvedTimeField`: nieliniowe przyspieszanie / hamowanie czasu w zależności od położenia.
+      * `EventHorizonForce`: obszar, gdzie `dt` zmienia kierunek, maleje do zera albo gwałtownie się deformuje.
+    - **Integratory**:
+      * Zaczynaj od prostego schematu Eulera, ale zostaw interfejs na bardziej zaawansowane metody
+        (np. ulepszony krok adaptacyjny).
+    - **Wizualizacja w terminalu**:
+      * W każdej iteracji wypisuj krótką linię zawierającą `t`, wybrane komponenty stanu
+        oraz prosty pasek lub symboliczny wykres (np. `t=0.30  |███-----|`).
+      * Jeżeli dostępny jest `rich`, użyj tabel lub pasków postępu do pokazywania trajektorii.
+    - **Przygotowanie pod ewolucję**:
+      * Projektuj równania tak, aby małe mutacje (zmiana funkcji `f`, inne parametry sił)
+        dawały zauważalnie różne, ale nadal stabilne zachowania.
+      * Nie usuwaj kluczowych klas (np. `TimeForce`); lepiej rozszerzaj ich API.
+
+    RAMA WALIDACYJNA (DLA EVALUATORA):
+    - **Sprawdzenie poprawności**:
+      * Uruchom krótką symulację (np. 10–50 kroków) i upewnij się, że `t` oraz inne wielkości
+        pozostają skończone i dobrze zdefiniowane.
+      * Funkcja `run()` powinna zwracać prostą strukturę (np. słownik lub listę słowników)
+        nadającą się do analizy.
+    - **Testy stabilności**:
+      * Przetestuj różne wartości `dt` (mniejsze i większe) i obserwuj, czy układ nie „wybucha”.
+      * Przetestuj parę różnych warunków początkowych, aby uniknąć kruchych założeń.
+    - **Inspekcja wizualna**:
+      * Wyjście w terminalu powinno w przejrzysty sposób sugerować „płynięcie” czasu
+        oraz główne zmiany w stanie układu.
+    - **Regresja**:
+      * Nowsze wersje kodu nie powinny niszczyć najprostszych scenariuszy
+        (np. liniowego wzrostu `t` przy stałej sile czasu).
+  # PROMPT-BLOCK-END
+
+
+CODEBASE_PATH: 'input/src/'
+INIT_FILE_DATA: {filename: 'initial_program.py', language: 'python'}
+EVAL_FILE_NAME: 'input/evaluate.py'
+
+
+# --- RESOURCES ---
+MAX_MEM_BYTES: 1000000000
+MEM_CHECK_INTERVAL_S: 0.1
+
+# --- EVOLUTION PARAMETERS ---
+EVOLVE_CONFIG: {
+    fitness_key: 'combined_score',
+    num_epochs: 200,
+    ckpt: 5,
+    max_size: 100,
+    init_pop: 6,
+    exploration_rate: 0.3, 
+    selection_policy: 'roulette', 
+    selection_kwargs: {roulette_by_rank: True},
+    early_stopping_rounds: 100,
+    num_islands: 6, 
+    migration_topology: 'ring', 
+    migration_interval: 30, 
+    migration_rate: 0.1,
+    meta_prompting: True, 
+    use_embedding: True, 
+    use_map_elites: True,
+    num_inspirations: 3,
+    max_chat_depth: 3
+}
+
+# --- MODEL ENSEMBLE (Hybrid: Poet + Engineer) ---
+ENSEMBLE: [
+    {
+        model_name: 'gemma3:4b', 
+        temp: 0.85, 
+        top_p: 0.95, 
+        retries: 3, 
+        weight: 0.3, 
+        verify_ssl: False,
+    },
+    {
+        model_name: 'qwen3-coder:480b-cloud', 
+        temp: 0.85, 
+        top_p: 0.95, 
+        retries: 3, 
+        weight: 0.7, 
+        verify_ssl: False,
+    }
+]
+
+# --- AUXILIARY MODELS ---
+SAMPLER_AUX_LM: {model_name: 'gemma3:4b', temp: 0.7, top_p: 0.95, retries: 3, weight: 1, verify_ssl: False}
+EMBEDDING: {model_name: 'qwen3-embedding:4b', retries: 3, verify_ssl: False}
+
+# --- MAP ELITES CONFIG (Optional) ---
+MAP_ELITES: {
+    elite_map_type: 'grid',
+    features: [
+        {name: 'feat1', min_val: 0, max_val: 1, num_bins: 10}
+    ]
+}
+

problems/F_time/configs/config_mp_insp.yaml

@@ -0,0 +1,101 @@
+SYS_MSG: | 
+    Jesteś Architektem Systemów Fizycznych w fazie zaawansowanej optymalizacji (Phase 2).
+
+    STAN PROJEKTU:
+    Twoja biblioteka ewoluowała z prostej idei "czas to siła" do złożonego modelu 
+    uwzględniającego:
+      1. Relatywistykę (Time Dilation).
+      2. Horyzont Zdarzeń (Event Horizon) i odwrócenie strzałki czasu.
+      3. Subiektywne odczuwanie czasu (Wątek Boone'a i "Blur").
+
+    TWOJE ZADANIE W FAZIE 2:
+    Nie dodawaj już nowych, szalonych pomysłów. Skup się na **REFINE & ROBUSTNESS**:
+
+    # PROMPT-BLOCK-START
+
+    1. LOGIKA MATEMATYCZNA (Dla modelu Reasoning):
+       - Sprawdź poprawność implementacji `apply()` w klasie `EventHorizonForce`.
+       - Upewnij się, że przejście przez horyzont (dist < radius) jest obsługiwane 
+         bez błędów numerycznych (np. dzielenie przez zero).
+       - Myśl krok po kroku: czy `dt` na pewno powinno być ujemne? Jak to wpływa na `velocity`?
+
+    2. ARCHITEKTURA (Dla modelu 480B):
+       - Wprowadź wzorzec **Observer** (Obserwator), aby oddzielić fizykę od rejestrowania danych.
+       - Rozważ wydzielenie logiki całkowania (Integrator) do osobnych strategii (np. Euler vs Runge-Kutta),
+         jeśli to poprawi stabilność przy osobliwościach.
+
+    3. DOKUMENTACJA:
+       - Utrzymuj wysoki poziom filozoficznych docstringów (po polsku).
+       - Wyjaśnij w komentarzach "dlaczego" matematyka działa tak, a nie inaczej.
+
+    CRITICAL INSTRUCTION:
+    Myśl krok po kroku, analizując logikę fizyczną. Upewnij się, że mechanizm odwracania czasu wewnątrz czarnej dziury jest zaimplementowany w sposób stabilny (numerycznie) i całkowicie wolny od błędów.
+
+    # PROMPT-BLOCK-END
+num_top_programs: 6
+use_template_stochasticity: true
+
+database:
+  population_size: 100
+  archive_size: 40
+  num_islands: 6
+
+  # Zmiany dla Fazy 2 (Stabilizacja):
+  migration_interval: 30
+  migration_rate: 0.1          # Mniejsza migracja (izolujemy dobre rozwiązania)
+  elite_selection_ratio: 0.25
+  exploitation_ratio: 0.7      # 70% czasu ulepszamy to co mamy, zamiast szukać nowości
+
+evaluator:
+  timeout: 60
+  cascade_evaluation: true
+  cascade_thresholds: [0.6, 0.8]  # Podnosimy poprzeczkę! (Wymagamy wyższej jakości)
+  parallel_evaluations: 4
+  use_llm_feedback: false
+
+evolution_settings:
+  diff_based_evolution: true
+  allow_full_rewrites: false
+  max_code_length: 1000000     # Zwiększony limit, o który prosiłeś
+  # PROMPT-BLOCK-START
+  # PROMPT-BLOCK-END
+
+CODEBASE_PATH: 'src/'
+INIT_FILE_DATA: {filename: 'INIT_PROGRAM.EXT', language: 'EXT'}
+EVAL_FILE_NAME: 'evaluate.py'
+EVAL_TIMEOUT: 180
+
+MAX_MEM_BYTES: 1000000000
+MEM_CHECK_INTERVAL_S: 0.1
+
+EVOLVE_CONFIG: {fitness_key: 'FITNESS_KEY',
+                num_epochs: 100,ckpt: 5,max_size: 40,init_pop: 6,
+                exploration_rate: 0.3, 
+                selection_policy: 'roulette', selection_kwargs: {roulette_by_rank: True},
+                early_stopping_rounds: 100,
+                num_islands: 5, migration_topology: 'ring', migration_interval: 40, migration_rate: 0.1,
+                meta_prompting: True, use_embedding: False, use_map_elites: False,
+                num_inspirations: 3,
+                max_chat_depth: 3}
+
+ENSEMBLE: [{model_name: 'qwen2.5-coder:7b', temp: 0.7, top_p: 0.95, retries: 3, weight: 0.8, verify_ssl: False},
+           {model_name: 'mistral:7b', temp: 0.7, top_p: 0.95, retries: 3, weight: 0.2, verify_ssl: False}]
+
+SAMPLER_AUX_LM: {model_name: 'qwen2.5-coder:7b', temp: 0.7, top_p: 0.95, retries: 3, weight: 1, verify_ssl: False}
+
+EMBEDDING: {model_name: 'qwen2.5-coder:7b', retries: 3, verify_ssl: False}
+
+MAP_ELITES: {elite_map_type: 'grid',
+             features: [
+              {name: 'feat1', min_val: 0, max_val: 1, num_bins: 10}
+             ]}
+
+# MAP_ELITES: {elite_map_type: 'cvt',
+#              features: [
+#               {name: 'feat1', min_val: 0, max_val: 1}
+#              ],
+#              elite_map_kwargs: {
+#               num_centroids: 50, num_init_samples: 10, max_iter: 300, tolerance: 0.0001
+#              }
+#              }
+