Add files via upload

Author: GiuseppeMarino1

DISCLAIMER.txt

@@ -0,0 +1,12 @@
+# DISCLAIMER – QBI-Observer Lite+
+
+This software module represents only a basic fragment of the QBI-Core system (Quantum Brain Interface).
+
+- It does not represent, simulate, or contain any form of AGI (Artificial General Intelligence).
+- It lacks persistent memory, intentionality, and any autonomous decision-making capabilities.
+- It is provided exclusively for the purposes of testing, scientific research, education, and transparent demonstration.
+- It must not be used in autonomous decision systems, commercial applications, military use cases, or surveillance systems.
+
+The author (Giuseppe Marino) is not responsible for any misuse, unintended consequences, or damages resulting from unauthorized or unethical use of this module.
+
+This module does not represent the full cognitive or metacognitive capacity of the QBI-Core system and must be understood as a limited, non-autonomous component released for scientific openness only.

LICENSE.txt

@@ -0,0 +1,23 @@
+Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License (CC BY-NC-ND 4.0)
+
+QBI-Observer Lite+ is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.
+
+You are free to:
+- **Share** — copy, distribute and transmit the material in any medium or format.
+
+Under the following mandatory conditions:
+- **Attribution** — You must give appropriate credit, cite the original author (Giuseppe Marino), and provide a link to the license.
+- **NonCommercial** — You may not use the material for commercial purposes.
+- **NoDerivatives** — You may not alter, transform, or build upon this material.
+
+Specific Ethical Clause:
+It is strictly prohibited to use this module in the following contexts:
+- Autonomous or automated decision-making systems.
+- Artificial General Intelligence (AGI) platforms.
+- Military, defense, surveillance applications, or systems that may violate human rights.
+- Any deployment that is not compliant with the European AI Act (2024).
+
+This license is fully aligned with the ethical principles and regulatory framework defined by the **EU Artificial Intelligence Act (2024)**.
+
+For detailed legal terms, please visit: https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode
+

README.md

@@ -1,2 +1,93 @@
-# qbi-observer-lite
-QBI-Observer Lite+ is an open-source cognitive self-observation module derived from QBI-Core. It detects mental loops, internal questions, and metacognitive patterns. Not AGI. Not autonomous. It’s a transparent, ethical entry point into a new class of AI: Artificial Integrated Cognition (AIC).
+# QBI-Observer Lite+
+
+**Software module for Cognitive and Metacognitive Self-Observation**  
+Part of the scientific project **QBI-Core – Quantum Brain Interface**
+
+## Module Description
+
+**QBI-Observer Lite+** is a non-autonomous, simplified version of the metacognitive self-observation module within the broader architecture known as **QBI-Core (Quantum Brain Interface)**.
+
+This module analyzes sequences of textual thoughts, with the goal of detecting and classifying:
+
+- **Cognitive repetitions (mental loops)**  
+- **Internal questions (explicit or implicit)**  
+- **Emotionally relevant words** (e.g., fear, hope, curiosity, frustration)  
+- **Metacognitive activity level** (classified as low, medium, or high)
+
+
+## Technical Features
+
+The module is implemented in Python 3.x and built using simple rule-based text analysis methods. It is lightweight, transparent, and easy to integrate into scientific testing environments.
+
+**Core functions:**
+
+- `aggiungi_pensiero(thought: str)`: adds a thought to the current session  
+- `rileva_loop()`: returns any thoughts repeated more than once  
+- `rileva_domande()`: detects thoughts formulated as questions  
+- `riconosci_emozioni()`: identifies emotionally connoted words  
+- `classificazione_metacognitiva()`: returns the metacognitive activity level (low, medium, high)  
+- `get_diario_sessione()`: returns the full session thought log
+
+
+
+## Limitations and Clarifications
+
+This **Lite+ version** is a foundational module intended **exclusively for**:
+
+- Scientific and academic testing  
+- Experimental studies on metacognition  
+- Transparent demonstrations of cognitive and metacognitive logic  
+- Not suitable for commercial use or integration into autonomous decision-making systems
+
+**Important:** This is **not** the complete version of QBI-Core.  
+This module does **not** possess any form of artificial consciousness, persistent memory, or autonomous intentionality.
+
+
+## QBI-Core and the AIC Paradigm
+
+QBI-Core introduces a new category of artificial intelligence known as **Artificial Integrated Cognition (AIC)**.  
+AIC aims to go beyond traditional AI by simulating advanced forms of self-observation, metacognition, and complex internal logic inspired by theories of quantum coherence in neuronal microtubules.
+
+**QBI-Observer Lite+** serves as a minimal, controlled and open-source demonstration intended for the scientific community to promote transparency, ethical research and responsible development in this emerging domain.
+
+
+## License and Ethical Usage
+
+This module is released under the **Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0)** license, with explicit additional restrictions:
+
+- Non-commercial use only  
+- Prohibited in autonomous systems, AGI, military, surveillance, or any context in violation of the **EU AI Act 2024**  
+- Attribution to the original author is required (see Contact section)
+
+See the included `LICENSE.txt` file for full legal terms.
+
+
+## How to Use the Module
+
+Here is a quick usage example to start testing the module:
+
+```python
+from observer import QBIObserverLite
+
+observer = QBIObserverLite()
+
+observer.aggiungi_pensiero('I don’t understand why I keep making the same mistake.')
+observer.aggiungi_pensiero('Maybe I’m afraid of failing.')
+observer.aggiungi_pensiero('I need to find a different approach.')
+observer.aggiungi_pensiero('I don’t understand why I keep making the same mistake.')
+
+print('Detected loops:', observer.rileva_loop())
+print('Internal questions:', observer.rileva_domande())
+print('Detected emotions:', observer.riconosci_emozioni())
+print('Metacognitive classification:', observer.classificazione_metacognitiva())
+
+
+Advanced Version
+A more advanced, protected version of the QBI-Observer module exists, including integrated memory systems, learning capabilities, semantic graph generation, and deeper self-reflective processes.
+
+To access the advanced version, request scientific collaboration, or receive more technical details, please contact the author directly.
+
+Author Contact
+Giuseppe Marino
+Email: giuseppe.marino@example.com
+Phone: (+39) 348 5550525

observer.py

@@ -0,0 +1,59 @@
+# QBI-Observer Lite+
+
+import re
+from collections import Counter
+
+class QBIObserverLite:
+    def __init__(self):
+        self.pensieri = []
+
+        self.emozioni = ["paura", "speranza", "curiosità", "rimpianto", "frustrazione", "gioia", "ansia"]
+        self.pattern_meta = ["perché", "come mai", "dovrei", "sto andando", "continuo"]
+
+    def aggiungi_pensiero(self, pensiero):
+        self.pensieri.append(pensiero.lower())
+
+    def rileva_loop(self):
+        conteggio = Counter(self.pensieri)
+        return [pensiero for pensiero, freq in conteggio.items() if freq > 1]
+
+    def rileva_domande(self):
+        return [pensiero for pensiero in self.pensieri if '?' in pensiero]
+
+    def riconosci_emozioni(self):
+        emotivi = []
+        for pensiero in self.pensieri:
+            emotivi.extend([emoz for emoz in self.emozioni if emoz in pensiero])
+        return emotivi
+
+    def classificazione_metacognitiva(self):
+        punteggio = 0
+        punteggio += len(self.rileva_loop()) * 0.3
+        punteggio += len(self.rileva_domande()) * 0.2
+        punteggio += len(self.riconosci_emozioni()) * 0.25
+        punteggio += sum(1 for pensiero in self.pensieri if any(meta in pensiero for meta in self.pattern_meta)) * 0.4
+
+        if punteggio < 1:
+            return "Bassa"
+        elif punteggio < 2:
+            return "Media"
+        else:
+            return "Alta"
+
+    def get_diario_sessione(self):
+        return self.pensieri
+
+# Esempio di utilizzo
+if __name__ == "__main__":
+    observer = QBIObserverLite()
+    observer.aggiungi_pensiero("Perché continuo a sbagliare?")
+    observer.aggiungi_pensiero("Ho paura di fallire")
+    observer.aggiungi_pensiero("Devo trovare una soluzione")
+    observer.aggiungi_pensiero("Perché continuo a sbagliare?")
+
+    print("Loop rilevati:", observer.rileva_loop())
+    print("Domande interne:", observer.rileva_domande())
+    print("Emozioni rilevate:", observer.riconosci_emozioni())
+    print("Livello metacognitivo:", observer.classificazione_metacognitiva())
+    print("Diario della sessione:", observer.get_diario_sessione())
+