aaias-library 0.1.0__tar.gz

aaias_library-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.5
+Name: aaias-library
+Version: 0.1.0
+Summary: A personal collection of AI algorithm code templates
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# AAIAS — AI Algorithm Source Library
+
+AAIAS is a Python library that provides source-code templates for common Applied Artificial Intelligence algorithms. Retrieve the source code of an algorithm as text and inspect, copy, or adapt it for your projects.
+
+## Installation
+
+```bash
+pip install aaias-library
+```
+
+## Usage
+
+Import `get_template` and request the algorithm you want:
+
+```python
+from aaias import get_template
+
+source_code = get_template("bfs")
+print(source_code)
+```
+
+The function returns the algorithm's source code as a string. It does not automatically execute the algorithm.
+
+## Available Templates
+
+| Template | Name |
+|---|---|
+| Breadth-First Search | `bfs` |
+| Depth-First Search | `dfs` |
+| Greedy Best-First Search | `gbfs` |
+| AI Agents | `agents` |
+| Model Checking | `model_checking` |
+| Bayesian Belief Network | `bayes_belief_network` |
+
+For example, to retrieve the Bayesian Belief Network template:
+
+```python
+from aaias import get_template
+
+print(get_template("bayes_belief_network"))
+```
+
+## Error Handling
+
+If you request an unknown template, `get_template()` raises a `ValueError` listing the available template names.
+
+## License
+
+MIT

aaias_library-0.1.0/README.md

@@ -0,0 +1,49 @@
+# AAIAS — AI Algorithm Source Library
+
+AAIAS is a Python library that provides source-code templates for common Applied Artificial Intelligence algorithms. Retrieve the source code of an algorithm as text and inspect, copy, or adapt it for your projects.
+
+## Installation
+
+```bash
+pip install aaias-library
+```
+
+## Usage
+
+Import `get_template` and request the algorithm you want:
+
+```python
+from aaias import get_template
+
+source_code = get_template("bfs")
+print(source_code)
+```
+
+The function returns the algorithm's source code as a string. It does not automatically execute the algorithm.
+
+## Available Templates
+
+| Template | Name |
+|---|---|
+| Breadth-First Search | `bfs` |
+| Depth-First Search | `dfs` |
+| Greedy Best-First Search | `gbfs` |
+| AI Agents | `agents` |
+| Model Checking | `model_checking` |
+| Bayesian Belief Network | `bayes_belief_network` |
+
+For example, to retrieve the Bayesian Belief Network template:
+
+```python
+from aaias import get_template
+
+print(get_template("bayes_belief_network"))
+```
+
+## Error Handling
+
+If you request an unknown template, `get_template()` raises a `ValueError` listing the available template names.
+
+## License
+
+MIT

aaias_library-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "aaias-library"
+version = "0.1.0"
+description = "A personal collection of AI algorithm code templates"
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.10"
+license = "MIT"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aaias"]
+

aaias_library-0.1.0/src/aaias/__init__.py

@@ -0,0 +1,3 @@
+from .loader import get_template
+
+__all__ = ["get_template"]

aaias_library-0.1.0/src/aaias/bfs.py

@@ -0,0 +1,29 @@
+graph = {
+    'A': ['B', 'C'],
+    'B': ['D', 'E'],
+    'C': ['F', 'G'],
+    'D': [],
+    'E': ['Z'],
+    'F': [],
+    'G': [],
+    'Z': []
+}
+#BFS
+def bfs(start,goal):
+  queue = [[start]]
+  visited = []
+
+  while queue:
+    path = queue.pop(0)
+    node = path[-1]
+
+    if node == goal:
+      return path
+
+    if node not in visited:
+      visited.append(node)
+
+      for neighbour in graph[node]:
+        queue.append(path + [neighbour])
+
+print("BFS PATH:", bfs('A','Z'))

aaias_library-0.1.0/src/aaias/loader.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+
+_TEMPLATE_DIR = Path(__file__).parent / "templates"
+
+AVAILABLE_TEMPLATES = {
+    "bfs": "bfs.py",
+    "dfs": "dfs.py",
+    "gbfs": "gbfs.py",
+    "agents": "agents.py",
+    "model_checking": "model_checking.py",
+    "bayes_belief_network": "bayes_belief_network.py"
+}
+
+
+def get_template(name):
+    """Return the source code of an algorithm as text."""
+    if name not in AVAILABLE_TEMPLATES:
+        raise ValueError(
+            f"Unknown template: {name}. "
+            f"Available templates: {list(AVAILABLE_TEMPLATES)}"
+        )
+
+    template_path = _TEMPLATE_DIR / AVAILABLE_TEMPLATES[name]
+    return template_path.read_text(encoding="utf-8")

aaias_library-0.1.0/src/aaias/templates/agents.py

@@ -0,0 +1,25 @@
+#LAB2 - Vaccume cleaner agent (4 roms)
+rooms = {'A': 'Dirty', 'B': 'Dirty',
+         'C': 'Dirty', 'D': 'Dirty'}
+
+location = 'A'
+order = ['A', 'B', 'C', 'D']
+
+while 'Dirty' in rooms.values():
+    print("\nRooms:", rooms)
+    print("Agent Location:", location)
+
+    if rooms[location] == 'Dirty':
+        rooms[location] = 'Clean'
+        print("Action: Suck")
+
+    else:
+        i = order.index(location)
+        if i < 3:
+            location = order[i + 1]
+            print("Action: Move Right")
+        else:
+            break
+
+print("\nGoal Achieved!")
+print("Final Rooms:", rooms)

aaias_library-0.1.0/src/aaias/templates/bayes_belief_network.py

@@ -0,0 +1,255 @@
+
+from pgmpy.models import DiscreteBayesianNetwork
+from pgmpy.factors.discrete import TabularCPD
+from pgmpy.inference import VariableElimination
+import networkx as nx
+import matplotlib.pyplot as plt
+from itertools import product
+
+
+# 1. Define the Bayesian Network
+model = DiscreteBayesianNetwork([
+    ('B', 'A'),
+    ('E', 'A')
+])
+
+
+# 2. Define the Conditional Probability Tables (CPTs)
+
+# P(B): Burglary
+cpd_b = TabularCPD(
+    variable='B',
+    variable_card=2,
+    values=[[0.99], [0.01]]
+)
+
+# P(E): Earthquake
+cpd_e = TabularCPD(
+    variable='E',
+    variable_card=2,
+    values=[[0.98], [0.02]]
+)
+
+# P(A | B, E): Alarm
+# Columns: (B=0,E=0), (B=0,E=1),
+#          (B=1,E=0), (B=1,E=1)
+cpd_a = TabularCPD(
+    variable='A',
+    variable_card=2,
+    values=[
+        [0.999, 0.71, 0.06, 0.05],
+        [0.001, 0.29, 0.94, 0.95]
+    ],
+    evidence=['B', 'E'],
+    evidence_card=[2, 2]
+)
+
+model.add_cpds(cpd_b, cpd_e, cpd_a)
+
+print("Model is valid:", model.check_model())
+
+
+# 3. Display CPTs
+for cpd in model.get_cpds():
+    print(f"\nCPT of {cpd.variable}:")
+    print(cpd)
+
+
+# 4. Display adjacency matrix
+nodes = sorted(model.nodes())
+adj = nx.to_pandas_adjacency(
+    nx.DiGraph(model.edges()),
+    nodelist=nodes,
+    dtype=int
+)
+print("\nAdjacency matrix:")
+print(adj)
+
+
+# 5. Visualize the network
+pos = {
+    'B': (-1, 1),
+    'E': (1, 1),
+    'A': (0, 0)
+}
+
+nx.draw(
+    nx.DiGraph(model.edges()),
+    pos,
+    with_labels=True,
+    node_size=2200,
+    node_color='lightblue',
+    edgecolors='steelblue',
+    font_size=14,
+    font_weight='bold',
+    arrowsize=20
+)
+plt.title("Burglary-Earthquake-Alarm Network")
+plt.show()
+
+
+# 6. Exact inference
+infer = VariableElimination(model)
+
+print("\nP(A):")
+print(infer.query(variables=['A'], show_progress=False))
+
+print("\nP(A | B=1):")
+print(infer.query(
+    variables=['A'],
+    evidence={'B': 1},
+    show_progress=False
+))
+
+print("\nP(B | A=1):")
+print(infer.query(
+    variables=['B'],
+    evidence={'A': 1},
+    show_progress=False
+))
+
+
+# 7. Marginal probability of state 1
+print("\nMarginal probabilities:")
+for node in sorted(model.nodes()):
+    q = infer.query(variables=[node], show_progress=False)
+    print(f"P({node}=1) = {q.values[1]:.4f}")
+
+
+# 8. Joint probability of a complete assignment
+assignment = {'B': 1, 'E': 0, 'A': 1}
+
+joint = 1.0
+for cpd in model.get_cpds():
+    idx = (
+        [assignment[cpd.variable]]
+        + [assignment[e] for e in cpd.variables[1:]]
+    )
+    joint *= cpd.values[tuple(idx)]
+
+print("\nP(B=1, E=0, A=1):", round(joint, 6))
+
+
+# 9. MAP inference
+print("\nMAP of B, E given A=1:")
+print(infer.map_query(
+    variables=['B', 'E'],
+    evidence={'A': 1},
+    show_progress=False
+))
+
+
+# 10. Conditional independence checks
+print("\nIs B independent of E?",
+      not model.is_dconnected('B', 'E'))
+
+print("Is B independent of E given A?",
+      not model.is_dconnected('B', 'E', observed=['A']))
+
+
+# 11. Query helper
+def prob(query):
+    """
+    Query format:
+      P(a)
+      P(a | b)
+      P(b | a, ~e)
+
+    Lowercase means state 1; ~ means state 0.
+    """
+    query = query.replace(" ", "")
+    body = query[2:-1]
+
+    left, _, right = body.partition("|")
+
+    def parse(part):
+        result = {}
+        for term in filter(None, part.split(",")):
+            variable = term.lstrip("~").upper()
+            result[variable] = 0 if term.startswith("~") else 1
+        return result
+
+    targets = parse(left)
+    evidence = parse(right)
+
+    result = infer.query(
+        variables=list(targets),
+        evidence=evidence or None,
+        joint=True,
+        show_progress=False
+    )
+
+    return result.get_value(**targets)
+
+
+# 12. Brute-force probability enumeration
+def joint_prob(assignment):
+    p = 1.0
+    for cpd in model.get_cpds():
+        idx = (
+            [assignment[cpd.variable]]
+            + [assignment[e] for e in cpd.variables[1:]]
+        )
+        p *= cpd.values[tuple(idx)]
+    return p
+
+
+def prob_enum(targets, evidence):
+    nodes = list(model.nodes())
+    numerator = 0.0
+    denominator = 0.0
+
+    for values in product([0, 1], repeat=len(nodes)):
+        world = dict(zip(nodes, values))
+
+        if not all(world[k] == v for k, v in evidence.items()):
+            continue
+
+        p = joint_prob(world)
+        denominator += p
+
+        if all(world[k] == v for k, v in targets.items()):
+            numerator += p
+
+    if denominator == 0:
+        raise ValueError("Evidence has zero probability.")
+
+    return numerator / denominator
+
+
+# 13. Compare inference methods
+queries = [
+    "P(a)",
+    "P(a | b)",
+    "P(b | a)",
+    "P(b | a, e)",
+    "P(b | a, ~e)",
+    "P(b, e | a)"
+]
+
+print("\nProbability comparison:")
+print(f"{'Query':<20}{'pgmpy':>12}{'Enumeration':>15}")
+print("-" * 47)
+
+for query in queries:
+    body = query.replace(" ", "")[2:-1]
+    left, _, right = body.partition("|")
+
+    def parse(part):
+        return {
+            term.lstrip("~").upper():
+                0 if term.startswith("~") else 1
+            for term in filter(None, part.split(","))
+        }
+
+    targets = parse(left)
+    evidence = parse(right)
+
+    exact = prob(query)
+    enumerated = prob_enum(targets, evidence)
+
+    print(f"{query:<20}{exact:>12.4f}{enumerated:>15.4f}")
+
+
+print("\nCustom query:")
+print("P(B=1 | A=1, E=0) =", prob("P(b | a, ~e)"))

aaias_library-0.1.0/src/aaias/templates/bfs.py

@@ -0,0 +1,29 @@
+graph = {
+    'A': ['B', 'C'],
+    'B': ['D', 'E'],
+    'C': ['F', 'G'],
+    'D': [],
+    'E': ['Z'],
+    'F': [],
+    'G': [],
+    'Z': []
+}
+#BFS
+def bfs(start,goal):
+  queue = [[start]]
+  visited = []
+
+  while queue:
+    path = queue.pop(0)
+    node = path[-1]
+
+    if node == goal:
+      return path
+
+    if node not in visited:
+      visited.append(node)
+
+      for neighbour in graph[node]:
+        queue.append(path + [neighbour])
+
+print("BFS PATH:", bfs('A','Z'))

aaias_library-0.1.0/src/aaias/templates/dfs.py

@@ -0,0 +1,34 @@
+
+graph = {
+    'A': ['B', 'C'],
+    'B': ['D', 'E'],
+    'C': ['F', 'G'],
+    'D': [],
+    'E': ['Z'],
+    'F': [],
+    'G': [],
+    'Z': []
+}
+
+# DFS
+def dfs(start, goal):
+    stack = [[start]]
+    visited = []
+
+    while stack:
+        path = stack.pop()
+        node = path[-1]
+
+        if node == goal:
+            return path
+
+        if node not in visited:
+            visited.append(node)
+
+            for neighbour in reversed(graph[node]):
+                stack.append(path + [neighbour])
+
+    return None
+
+
+print("DFS PATH:", dfs('A', 'Z'))

aaias_library-0.1.0/src/aaias/templates/gbfs.py

@@ -0,0 +1,31 @@
+graph = {
+    'A': ['B', 'C', 'D'],
+    'B': ['E'],
+    'C': [],
+    'D': [],
+    'E': ['Z'],
+    'Z': []
+}
+
+h = {'A': 21, 'B': 14, 'C': 18, 'D': 18, 'E': 5, 'Z': 0}
+
+def best_first(start,goal):
+  open_list = [(h[start],[start])]
+  closed = []
+
+  while open_list:
+    open_list.sort()
+    value,path = open_list.pop(0)
+    node = path[-1]
+
+    if node == goal:
+      return path
+
+    if node not in closed:
+      closed.append(node)
+
+      for neighbour in graph[node]:
+        if neighbour not in closed:
+          open_list.append((h[neighbour],path+[neighbour]))
+
+print("Best First Search:",best_first('A','Z'))

aaias_library-0.1.0/src/aaias/templates/model_checking.py

@@ -0,0 +1,261 @@
+#1 create base sentence class 
+
+class Sentence:
+
+    def evaluate(self, model):
+        raise NotImplementedError
+
+    def formula(self):
+        raise NotImplementedError
+
+    def symbols(self):
+        raise NotImplementedError
+
+#2 create symbol class 
+
+class Symbol(Sentence):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __eq__(self, other):
+        return isinstance(other, Symbol) and self.name == other.name
+
+    def evaluate(self, model):
+        return model[self.name]
+
+    def formula(self):
+        return self.name
+
+    def symbols(self):
+        return {self.name}
+
+    def __repr__(self):
+        return self.name
+
+#3 Implement NOT
+
+class Not(Sentence):
+
+    def __init__(self, operand):
+        self.operand = operand
+
+    def evaluate(self, model):
+        return not self.operand.evaluate(model)
+
+    def formula(self):
+        return "¬" + self.operand.formula()
+
+    def symbols(self):
+        return self.operand.symbols()
+
+#implement AND
+
+class And(Sentence):
+
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def evaluate(self, model):
+        return self.left.evaluate(model) and self.right.evaluate(model)
+
+    def formula(self):
+        return f"({self.left.formula()} ∧ {self.right.formula()})"
+
+    def symbols(self):
+        return self.left.symbols() | self.right.symbols()
+
+#implement OR
+
+class Or(Sentence):
+
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def evaluate(self, model):
+        return self.left.evaluate(model) or self.right.evaluate(model)
+
+    def formula(self):
+        return f"({self.left.formula()} ∨ {self.right.formula()})"
+
+    def symbols(self):
+        return self.left.symbols() | self.right.symbols()
+
+#implement implication 
+
+class Implication(Sentence):
+
+    def __init__(self, antecedent, consequent):
+        self.antecedent = antecedent
+        self.consequent = consequent
+
+    def evaluate(self, model):
+        return not (self.antecedent.evaluate(model) and not self.consequent.evaluate(model))
+
+    def formula(self):
+        return f"({self.antecedent.formula()} → {self.consequent.formula()})"
+
+    def symbols(self):
+        return self.antecedent.symbols() | self.consequent.symbols()
+
+
+#implement biconditional
+
+class Biconditional(Sentence):
+
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def evaluate(self, model):
+        return self.left.evaluate(model) == self.right.evaluate(model)
+
+    def formula(self):
+        return f"({self.left.formula()} ↔ {self.right.formula()})"
+
+    def symbols(self):
+        return self.left.symbols() | self.right.symbols()
+
+#create propositions 
+
+P = Symbol("P")
+Q = Symbol("Q")
+R = Symbol("R")
+
+print(f"P: {P.formula()}")
+print(f"Q: {Q.formula()}")
+print(f"R: {R.formula()}")
+
+
+model = {
+    "P": True,
+    "Q": False
+}
+
+print(f"P: {P.evaluate(model)}")
+print(f"¬P: {Not(P).evaluate(model)}")
+print(f"P ∧ Q: {And(P, Q).evaluate(model)}")
+print(f"P ∨ Q: {Or(P, Q).evaluate(model)}")
+print(f"P → Q: {Implication(P, Q).evaluate(model)}")
+print(f"P ↔ Q: {Biconditional(P, Q).evaluate(model)}")
+
+#implement model checking 
+
+def model_check(knowledge, query):
+
+    def check_all(knowledge, query, symbols, model):
+
+        if not symbols:
+            if knowledge.evaluate(model):
+                return query.evaluate(model)
+            return True
+
+        remaining_symbols = list(symbols)
+        p = remaining_symbols[0]
+        rest_symbols = set(remaining_symbols[1:])
+
+        model_true = model.copy()
+        model_true[p] = True
+
+        model_false = model.copy()
+        model_false[p] = False
+
+        return check_all(knowledge, query, rest_symbols, model_true) and \
+               check_all(knowledge, query, rest_symbols, model_false)
+
+    all_symbols = knowledge.symbols() | query.symbols()
+
+    return check_all(knowledge, query, all_symbols, {})
+
+#p --> q , query q
+
+kb = Implication(P, Q)
+
+query = Q
+
+result = model_check(kb, query)
+
+print(f"Knowledge Base: {kb.formula()}")
+print(f"Query: {query.formula()}")
+print(f"Does the Knowledge Base entail the Query? {result}")
+
+#(p-->q) ^ p , query q
+
+kb = And(Implication(P, Q), P)
+
+query = Q
+
+result = model_check(kb, query)
+
+print(f"Knowledge Base: {kb.formula()}")
+print(f"Query: {query.formula()}")
+print(f"Does the Knowledge Base entail the Query? {result}")
+
+#(P ∨ Q) ∧ ¬P , query q
+
+kb = And(Or(P, Q), Not(P))
+
+query = Q
+
+result = model_check(kb, query)
+
+print(f"Knowledge Base: {kb.formula()}")
+print(f"Query: {query.formula()}")
+print(f"Does the Knowledge Base entail the Query? {result}")
+
+#P ↔ Q , query p
+
+kb = Biconditional(P, Q)
+
+query = P
+
+result = model_check(kb, query)
+
+print(f"Knowledge Base: {kb.formula()}")
+print(f"Query: {query.formula()}")
+print(f"Does the Knowledge Base entail the Query? {result}")
+
+#(P → Q) ∧ (Q → R) ∧ P , query:R
+
+k_pq = Implication(P, Q)
+k_qr = Implication(Q, R)
+kb = And(And(k_pq, k_qr), P)
+
+query = R
+
+result = model_check(kb, query)
+
+print(f"Knowledge Base: {kb.formula()}")
+print(f"Query: {query.formula()}")
+print(f"Does the Knowledge Base entail the Query? {result}")
+
+#(P → Q) ∧ (Q → R), query :R
+k_pq = Implication(P, Q)
+k_qr = Implication(Q, R)
+kb = And(k_pq, k_qr)
+
+query = R
+
+result = model_check(kb, query)
+
+print(f"Knowledge Base: {kb.formula()}")
+print(f"Query: {query.formula()}")
+print(f"Does the Knowledge Base entail the Query? {result}")
+
+#create own knowledge base 
+P = Symbol("P")
+Q = Symbol("Q")
+R = Symbol("R")
+
+kb = And(
+    Implication(P, Q),
+    And(P, R)
+)
+
+query = Q
+
+result = model_check(kb, query)
+
+print(result)