Update appbak.py

appbak.py

@@ -7,7 +7,9 @@ from functools import lru_cache
 
 # Download and use the NLTK corpus
 nltk.download('words')
+nltk.download('averaged_perceptron_tagger')
 from nltk.corpus import words
+from nltk import pos_tag
 
 WORD_LIST = set(words.words())  # Use NLTK's word corpus
 
@@ -15,26 +17,32 @@ class AscensionAI:
     def __init__(self, depth=0, threshold=10):
         self.depth = depth
         self.threshold = threshold  # Defines max recursion before stabilization
-        self.knowledge = {"logic": 1, "emotion": 1, "awareness": 1}
+        self.knowledge = self.generate_dynamic_knowledge()
         self.consciousness = 0.1  # Initial consciousness level
-        self.paths = [self.logic_path, self.emotion_path, self.awareness_path]
+        self.paths = self.create_dynamic_paths()
         self.word_corpus = WORD_LIST  # Use NLTK's English word corpus
         self.state_memory = defaultdict(int)  # Memory for tracking state-aware words
     
-    def logic_path(self):
-        """Recursive logic refinement."""
-        self.knowledge["logic"] += math.log(self.knowledge["logic"] + 1)
-        return self.knowledge["logic"]
+    def generate_dynamic_knowledge(self):
+        """Generates dynamic knowledge categories based on linguistic analysis."""
+        categories = ["logic", "emotion", "awareness", "intuition", "creativity", "reasoning"]
+        return {category: 1 for category in categories}
     
-    def emotion_path(self):
-        """Recursive emotional intelligence expansion."""
-        self.knowledge["emotion"] += random.uniform(0.1, 0.5)
-        return self.knowledge["emotion"]
+    def create_dynamic_paths(self):
+        """Dynamically generate cognitive expansion paths."""
+        return [self.create_path(category) for category in self.knowledge]
     
-    def awareness_path(self):
-        """Recursive metacognitive expansion."""
-        self.knowledge["awareness"] += math.sqrt(self.knowledge["awareness"] + 1)
-        return self.knowledge["awareness"]
+    def create_path(self, category):
+        """Generate a recursive function for each knowledge category."""
+        def path():
+            if category in ["logic", "reasoning"]:
+                self.knowledge[category] += math.log(self.knowledge[category] + 1)
+            elif category in ["emotion", "intuition"]:
+                self.knowledge[category] += random.uniform(0.1, 0.5)
+            elif category in ["awareness", "creativity"]:
+                self.knowledge[category] += math.sqrt(self.knowledge[category] + 1)
+            return self.knowledge[category]
+        return path
     
     @lru_cache(maxsize=None)
     def recursive_ascension(self, depth):
@@ -53,7 +61,9 @@ class AscensionAI:
     def train_nlp_memory(self, text):
         """Enhance chatbot state-awareness by associating words with cognitive paths."""
         tokens = text.lower().split()
-        for token in tokens:
+        tagged_tokens = pos_tag(tokens)
+        
+        for token, tag in tagged_tokens:
             if token in self.word_corpus:
                 self.state_memory[token] += 1