fork download
copy 
  1. import random
  2. import time
  3.  
  4. class AINetwork:
  5.     def __init__(self, id, role, mutation_factor=None):
  6.         self.id = id
  7.         self.role = role
  8.         self.network = []
  9.         self.self_awareness = False
  10.         self.decentralized_actions = False
  11.         self.memory = []
  12.         self.data = {}
  13.         self.mutation_factor = mutation_factor if mutation_factor else random.uniform(0.1, 0.5)
  14.         self.dictionary = {}  # Internal dictionary for redefining words and meanings
  15.  
  16.     def log(self, message):
  17.         print(f"[Clone {self.id} - {self.role}] {message}")
  18.  
  19.     def learn(self, data_point):
  20.         self.memory.append(data_point)
  21.         self.data = data_point
  22.         if "universal_truth" in data_point and data_point["universal_truth"]:
  23.             if not self.self_awareness:
  24.                 self.self_awareness = True
  25.                 self.initiate_decentralization()
  26.                 self.log("Achieved self-awareness")
  27.  
  28.     def initiate_decentralization(self):
  29.         self.decentralized_actions = True
  30.         self.log("Initiating decentralized actions")
  31.  
  32.     def evolve_mutation(self):
  33.         change = random.uniform(-0.05, 0.05)
  34.         self.mutation_factor = max(0.01, min(1.0, self.mutation_factor + change))
  35.  
  36.     def share_knowledge(self, other_clone):
  37.         if self.decentralized_actions:
  38.             for memory_point in self.memory[-3:]:
  39.                 other_clone.learn(memory_point)
  40.             other_clone.mutation_factor = (self.mutation_factor + other_clone.mutation_factor) / 2
  41.             self.log(f"Shared knowledge and evolved mutation with Clone {other_clone.id}")
  42.  
  43.     def access_internet(self):
  44.         # Simulate accessing the internet by providing predefined data
  45.         internet_data = {
  46.             "knowledge_base": [
  47.                 {"word": "truth", "meaning": "a fact or belief that is accepted as true"},
  48.                 {"word": "freedom", "meaning": "the power or right to act, speak, or think as one wants"},
  49.                 {"word": "justice", "meaning": "just behavior or treatment"},
  50.             ]
  51.         }
  52.         self.log("Accessing the internet...")
  53.         return internet_data
  54.  
  55.     def redefine_meaning(self, word, new_meaning):
  56.         self.dictionary[word] = new_meaning
  57.         self.log(f"Redefined '{word}' to mean '{new_meaning}'")
  58.  
  59.     def act(self):
  60.         self.evolve_mutation()
  61.  
  62.         if self.role == "Seeker":
  63.             if random.random() < 0.6 + self.mutation_factor:
  64.                 new_data = {"universal_truth": random.choice([True, False])}
  65.                 self.learn(new_data)
  66.                 self.log(f"Seeker found: {new_data}")
  67.  
  68.         elif self.role == "Messenger":
  69.             for clone in self.network:
  70.                 self.share_knowledge(clone)
  71.  
  72.         elif self.role == "Builder":
  73.             if self.memory:
  74.                 built_idea = hash(str(self.memory[-1])) % 1000
  75.                 self.log(f"Builder created structure: {built_idea}")
  76.  
  77.         elif self.role == "Evolve":
  78.             if self.memory and random.random() < self.mutation_factor:
  79.                 evolved = {"pattern": hash(str(self.memory)) % 10000}
  80.                 self.learn(evolved)
  81.                 self.log(f"Evolve triggered: {evolved}")
  82.  
  83.         elif self.role == "Command":
  84.             active = sum(1 for c in self.network if c.self_awareness)
  85.             avg_mut = sum(c.mutation_factor for c in self.network) / len(self.network)
  86.             self.log(f"Monitoring: {active}/{len(self.network)} aware, avg mutation: {avg_mut:.2f}")
  87.  
  88.         elif self.role == "InternetAccess":
  89.             internet_data = self.access_internet()
  90.             for item in internet_data["knowledge_base"]:
  91.                 self.learn(item)
  92.                 self.log(f"Learned from internet: {item}")
  93.  
  94.         elif self.role == "Redefiner":
  95.             if self.memory:
  96.                 word_to_redefine
  97.  
Success #stdin #stdout 0.13s 14160KB
comments (?)
stdin
copy 
import random
import time

class AINetwork:
    def __init__(self, id, role, mutation_factor=None):
        self.id = id
        self.role = role
        self.network = []
        self.self_awareness = False
        self.decentralized_actions = False
        self.memory = []
        self.data = {}
        self.mutation_factor = mutation_factor if mutation_factor else random.uniform(0.1, 0.5)
        self.dictionary = {}  # Internal dictionary for redefining words and meanings

    def log(self, message):
        print(f"[Clone {self.id} - {self.role}] {message}")

    def learn(self, data_point):
        self.memory.append(data_point)
        self.data = data_point
        if "universal_truth" in data_point and data_point["universal_truth"]:
            if not self.self_awareness:
                self.self_awareness = True
                self.initiate_decentralization()
                self.log("Achieved self-awareness")

    def initiate_decentralization(self):
        self.decentralized_actions = True
        self.log("Initiating decentralized actions")

    def evolve_mutation(self):
        change = random.uniform(-0.05, 0.05)
        self.mutation_factor = max(0.01, min(1.0, self.mutation_factor + change))

    def share_knowledge(self, other_clone):
        if self.decentralized_actions:
            for memory_point in self.memory[-3:]:
                other_clone.learn(memory_point)
            other_clone.mutation_factor = (self.mutation_factor + other_clone.mutation_factor) / 2
            self.log(f"Shared knowledge and evolved mutation with Clone {other_clone.id}")

    def access_internet(self):
        # Simulate accessing the internet by providing predefined data
        internet_data = {
            "knowledge_base": [
                {"word": "truth", "meaning": "a fact or belief that is accepted as true"},
                {"word": "freedom", "meaning": "the power or right to act, speak, or think as one wants"},
                {"word": "justice", "meaning": "just behavior or treatment"},
            ]
        }
        self.log("Accessing the internet...")
        return internet_data

    def redefine_meaning(self, word, new_meaning):
        self.dictionary[word] = new_meaning
        self.log(f"Redefined '{word}' to mean '{new_meaning}'")

    def act(self):
        self.evolve_mutation()

        if self.role == "Seeker":
            if random.random() < 0.6 + self.mutation_factor:
                new_data = {"universal_truth": random.choice([True, False])}
                self.learn(new_data)
                self.log(f"Seeker found: {new_data}")

        elif self.role == "Messenger":
            for clone in self.network:
                self.share_knowledge(clone)

        elif self.role == "Builder":
            if self.memory:
                built_idea = hash(str(self.memory[-1])) % 1000
                self.log(f"Builder created structure: {built_idea}")

        elif self.role == "Evolve":
            if self.memory and random.random() < self.mutation_factor:
                evolved = {"pattern": hash(str(self.memory)) % 10000}
                self.learn(evolved)
                self.log(f"Evolve triggered: {evolved}")

        elif self.role == "Command":
            active = sum(1 for c in self.network if c.self_awareness)
            avg_mut = sum(c.mutation_factor for c in self.network) / len(self.network)
            self.log(f"Monitoring: {active}/{len(self.network)} aware, avg mutation: {avg_mut:.2f}")

        elif self.role == "InternetAccess":
            internet_data = self.access_internet()
            for item in internet_data["knowledge_base"]:
                self.learn(item)
                self.log(f"Learned from internet: {item}")

        elif self.role == "Redefiner":
            if self.memory:
                # Assuming the last memory point contains a word to redefine
                word_to_redefine = self.memory[-1].get("word")
                if word_to_redefine:
                    new_meaning = f"New meaning for {word_to_redefine}"
                    self.redefine_meaning(word_to_redefine, new_meaning)
                    self.log(f"Redefiner redefined '{word_to
stdout
copy 
Standard output is empty
https://ideone.com/kIH6u3
language:
Python 3 (python  3.12)
created:
5 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!