danielutils 1.1.28__py3-none-any.whl

danielutils/university/computability_and_complexity/discreate_finite_automaton.py

@@ -0,0 +1,89 @@
+import random
+from typing import Set, Callable, Sequence, Collection, Tuple, Dict, TypeVar, Generic
+
+State = TypeVar('State')
+Symbol = TypeVar('Symbol')
+Alphabet = Collection[Symbol]
+TransitionFunction = Callable[[State, Symbol], State]
+
+
+class DiscreteFiniteAutomaton(Generic[State, Symbol]):
+    def __init__(self, Q: Collection[State], sigma: Alphabet, delta: TransitionFunction, q0: State,
+                 F: Collection[State]):
+        """
+
+        Args:
+            Q: set of possible states
+            sigma: the alphabet
+            delta: the transition function
+            q0: the initial state
+            F: the accept states
+        """
+        self.Q: Set[State] = set(Q)
+        self.sigma: Sequence[Symbol] = list(sigma)
+        self.delta: TransitionFunction = delta
+        self.q0: State = q0
+        self.F: Set[State] = set(F)
+        self._verify()
+
+    def process(self, word: Sequence[Symbol]) -> State:
+        cur = self.q0
+        for letter in word:
+            cur = self.delta(cur, letter)
+        return cur
+
+    def run(self, word: Sequence[Symbol]) -> bool:
+        return self.process(word) in self.F
+
+    def __call__(self, word: Sequence[Symbol]) -> bool:
+        return self.run(word)
+
+    def _verify(self) -> None:
+        for letter in self.sigma:
+            for state in self.Q:
+                try:
+                    res = self.delta(state, letter)
+                except Exception as e:
+                    raise ValueError(f'delta({state}, {letter}) raised an exception') from e
+                if not res in self.Q:
+                    raise ValueError(f'delta({state}, {letter}) = {state} which is not in F = {self.Q}')
+
+    def random_word(self, k: int) -> Sequence[Symbol]:
+        return tuple(random.choices(self.sigma, k=k))
+
+    def is_described_by(self, language_indicator: Callable[[Sequence[Symbol]], bool], max_word_length: int = 100,
+                        num_repeats_for_length: int = 1000) -> bool:
+        """
+        This function will randomly generate work of all lengths up to k and will check whether this DFA acceptance
+         of the word is the same as the result of a function that describes the behaviour of the language
+        Args:
+            language_indicator: An indicator function to check if a word is a member of a language
+            max_word_length: the maximum length of a word to check
+            num_repeats_for_length: how many times to repeat the check of any one length (as the words are randomly generated)
+
+        Returns:
+            A boolean result
+        """
+        for k in range(max_word_length):
+            for _ in range(num_repeats_for_length):
+                word = self.random_word(k)
+                if not (self.run(word) == language_indicator(word)):
+                    return False
+
+        return True
+
+    @staticmethod
+    def delta_from_dict(dct: Dict[Tuple[State, Symbol], State]) -> TransitionFunction:
+        return lambda state, letter: dct[(state, letter)]
+
+
+DFA = DiscreteFiniteAutomaton
+
+__all__ = [
+    "State",
+    "Symbol",
+    "Alphabet",
+    "TransitionFunction",
+    "DiscreteFiniteAutomaton",
+    "DFA"
+]

danielutils/university/computability_and_complexity/languages/language.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+from typing import Protocol
+
+
+class LanguageItem(Protocol): ...
+
+
+class Language(ABC):
+
+    @abstractmethod
+    def __contains__(self, item: LanguageItem) -> bool: ...
+
+
+__all__ = [
+    "Language",
+    "LanguageItem"
+]

danielutils/university/computability_and_complexity/languages/sat.py

@@ -0,0 +1,71 @@
+from typing import List, TypeVar, Optional
+
+from .language import Language
+
+CNFVariable_id_type = TypeVar('CNFVariable_id_type', bound=int)
+
+
+class CNFVariable:
+    __ID: int = 0
+
+    def __init__(self, value: bool):
+        self.value = value
+        self.id = CNFVariable.__ID
+        CNFVariable.__ID += 1
+
+    def __bool__(self):
+        return self.value
+
+    def get_id(self) -> CNFVariable_id_type:  # type:ignore
+        # TODO
+        assert False
+
+
+class CNFLiteral:
+    def __init__(self, negation: bool):
+        self.negation = negation
+
+    def __call__(self, var: CNFVariable) -> bool:
+        return not bool(var) if self.negation else bool(var)
+
+    def get_corresponding_variable_id(self) -> CNFVariable_id_type:  # type:ignore
+        # TODO
+        assert False
+
+
+class CNFClause:
+    def __bool__(self, literals: Optional[List[CNFLiteral]] = None) -> None:
+        self.literals = literals or []
+
+    def add_literal(self, literal: CNFLiteral):
+        self.literals.append(literal)
+
+    def evaluate(self, variables: List[CNFVariable]) -> bool:
+        dct: dict = {v.get_id(): v for v in variables}
+
+        for literal in self.literals:
+            if not literal.get_corresponding_variable_id() in dct.keys():
+                return False
+            if not literal(dct[literal.get_corresponding_variable_id()]):
+                return False
+        return True
+
+    def __len__(self) -> int:
+        return len(self.literals)
+
+
+class CNFFormula:
+    def __init__(self, clauses: Optional[List[CNFClause]] = None) -> None:
+        self.clauses = clauses or []
+
+    def add_clause(self, clause: CNFClause) -> None:
+        self.clauses.append(clause)
+
+    def evaluate(self, variables: List[CNFVariable]) -> bool:
+        for clause in self.clauses:
+            if not clause.evaluate(variables):
+                return False
+        return True
+
+
+class SAT(Language): ...

danielutils/university/computability_and_complexity/turing_machine.py

@@ -0,0 +1,47 @@
+from typing import TypeVar, Collection, Callable, Set, List, Sequence, Tuple, Union, Literal, Generic
+
+State = TypeVar('State')
+Symbol = TypeVar('Symbol')
+Alphabet = Collection[Symbol]
+Direction = Union[Literal["L"], Literal["R"]]
+TransitionFunction = Callable[[State, Symbol], Tuple[State, Symbol, Direction]]
+
+
+class TuringMachine(Generic[State, Symbol]):
+    def __init__(self, Q: Collection[State], Gamma: Alphabet, Sigma: Alphabet, delta: TransitionFunction, q0: State,
+                 F_acc: Collection[State], F_rej: Collection[State]) -> None:
+        self.Q: Set[State] = set(Q)
+        self.Gamma: List[State] = list(Gamma)
+        self.Sigma: List[State] = list(Sigma)
+        self.delta: TransitionFunction = delta
+        self.q0: State = q0
+        self.F_acc: Set[State] = set(F_acc)
+        self.F_rej: Set[State] = set(F_rej)
+        self.tape: List[Symbol] = []
+        self.head: int = 0
+
+    def _should_stop(self, cur_state: State) -> bool:
+        return cur_state in self.F_acc or cur_state in self.F_rej
+
+    def process(self, word: Sequence[Symbol]) -> State:
+        for letter in word:
+            self.tape.append(letter)
+        cur = self.q0
+        while not self._should_stop(cur):
+            state, symbol, direction = self.delta(cur, self.tape[self.head])
+            cur = state
+            self.tape[self.head] = symbol
+            self.head += 1 if direction == "R" else -1
+
+        return cur
+
+    def run(self, word: Sequence[Symbol]) -> bool:
+        return self.process(word) in self.F_acc
+
+    def __call__(self, word: Sequence[Symbol]) -> bool:
+        return self.run(word)
+
+
+__all__ = [
+    'TuringMachine'
+]

danielutils/university/databases/__init__.py

@@ -0,0 +1 @@
+from .all import *