From 6c365cfbbcacc442f17697c2c9ad4ab69c9cb796 Mon Sep 17 00:00:00 2001 From: JOLIMAITRE Matthieu Date: Fri, 28 Jun 2024 13:36:38 +0200 Subject: [PATCH] tp surete --- surete/tp_ltl/.gitignore | 2 + surete/tp_ltl/requirements.txt | 1 + surete/tp_ltl/run.sh | 12 + surete/tp_ltl/setup.sh | 10 + surete/tp_ltl/src/GBA.py | 119 ++++++++++ surete/tp_ltl/src/LTL.py | 391 ++++++++++++++++++++++++++++++++ surete/tp_ltl/src/LTLchecker.py | 34 +++ surete/tp_ltl/src/LTLtoGBA.py | 260 +++++++++++++++++++++ surete/tp_ltl/src/buchi.py | 132 +++++++++++ surete/tp_ltl/src/emptyTest.py | 45 ++++ surete/tp_ltl/src/kripke.py | 101 +++++++++ surete/tp_ltl/src/product.py | 49 ++++ surete/tp_ltl/src/py.typed | 0 surete/tp_ltl/src/utils.py | 9 + surete/tp_ltl/sujet.pdf | Bin 0 -> 185907 bytes surete/tp_ltl/test/.gitignore | 1 + surete/tp_ltl/test/test.sh | 42 ++++ 17 files changed, 1208 insertions(+) create mode 100644 surete/tp_ltl/.gitignore create mode 100644 surete/tp_ltl/requirements.txt create mode 100755 surete/tp_ltl/run.sh create mode 100755 surete/tp_ltl/setup.sh create mode 100644 surete/tp_ltl/src/GBA.py create mode 100644 surete/tp_ltl/src/LTL.py create mode 100644 surete/tp_ltl/src/LTLchecker.py create mode 100644 surete/tp_ltl/src/LTLtoGBA.py create mode 100644 surete/tp_ltl/src/buchi.py create mode 100644 surete/tp_ltl/src/emptyTest.py create mode 100755 surete/tp_ltl/src/kripke.py create mode 100644 surete/tp_ltl/src/product.py create mode 100644 surete/tp_ltl/src/py.typed create mode 100644 surete/tp_ltl/src/utils.py create mode 100644 surete/tp_ltl/sujet.pdf create mode 100644 surete/tp_ltl/test/.gitignore create mode 100755 surete/tp_ltl/test/test.sh diff --git a/surete/tp_ltl/.gitignore b/surete/tp_ltl/.gitignore new file mode 100644 index 0000000..0b81a20 --- /dev/null +++ b/surete/tp_ltl/.gitignore @@ -0,0 +1,2 @@ +/venv +__pycache__ \ No newline at end of file diff --git a/surete/tp_ltl/requirements.txt b/surete/tp_ltl/requirements.txt new file mode 100644 index 0000000..abecf5d --- /dev/null +++ b/surete/tp_ltl/requirements.txt @@ -0,0 +1 @@ +graphviz \ No newline at end of file diff --git a/surete/tp_ltl/run.sh b/surete/tp_ltl/run.sh new file mode 100755 index 0000000..139a0d5 --- /dev/null +++ b/surete/tp_ltl/run.sh @@ -0,0 +1,12 @@ +#!/bin/sh +set -e +cd "$(dirname "$(realpath "$0")")" + + +if ! [ -d venv ] +then ./setup.sh +fi +. venv/bin/activate + + +python src/product.py diff --git a/surete/tp_ltl/setup.sh b/surete/tp_ltl/setup.sh new file mode 100755 index 0000000..495b249 --- /dev/null +++ b/surete/tp_ltl/setup.sh @@ -0,0 +1,10 @@ +#!/bin/bash +set -e +cd "$(dirname "$(realpath "$0")")" + + +python -m venv venv +. venv/bin/activate + + +pip install -r requirements.txt diff --git a/surete/tp_ltl/src/GBA.py b/surete/tp_ltl/src/GBA.py new file mode 100644 index 0000000..4469cfe --- /dev/null +++ b/surete/tp_ltl/src/GBA.py @@ -0,0 +1,119 @@ +# -*-coding:UTF-8 -* +from typing import Iterable, TypeVar +from graphviz import Digraph + + +from utils import edge, state + + +def fstr(formula: frozenset[str]): + form_str = "" + for l in formula: + form_str = form_str+l+',' + return form_str[:-1] + + +def is_consistent(formula): + for l in formula: + if "~"+l in formula: + return False + return True + + +# Generalized Buchi Automata +class GBA[T]: + + def __init__(self, all_states: Iterable[state[T]], initial_states: Iterable[state[T]], propositions: Iterable[str], edges: list[edge[T]], acceptings: Iterable[Iterable[state[T]]]): + # States: a set of integers + self.all_states = set(all_states) + # Initial states: a set of integers + self.initial_states = set(initial_states).intersection(self.all_states) + # There must be an initial state; if there isn't, an initial state 0 + # is added + if not self.initial_states: + self.initial_states.add(0) + self.all_states.add(0) + self.accepting_states = list[set[state[T]]]() + for final in acceptings: + self.accepting_states.append(set(final).intersection(self.all_states)) + self.ap = set(propositions) + self.formulas = {frozenset(formula) for (_,formula,_) in edges} + self.next_states = {(state, formula): set() + for state in self.all_states + for formula in self.formulas} + for edge in edges: + if (edge[0] in self.all_states) and (edge[2] in self.all_states) and is_consistent(edge[1]): + self.next_states[(edge[0], frozenset(edge[1]))].add(edge[2]) + self.labels = {state:str(state) for state in self.all_states} + + # Adds a new state to the structure + def add_state(self): + add_state = max([s for s in self.all_states if type(s) is int]) + 1 + self.all_states.add(add_state) + for formula in self.formulas: + self.next_states[add_state,formula] = set() + self.labels[add_state]= str(add_state) + return add_state + + def add_initial(self, state: int): + self.initial_states.add(state) + return state + + # Adds a new edge from the state 'origin' to the state 'destination' + def add_edge(self, origin, formula, destination): + if origin in self.all_states: + if destination in self.all_states: + if not frozenset(formula) in self.formulas: + self.formulas.add(frozenset(formula)) + for st in self.all_states: + self.next_states[(st, frozenset(formula))] = set() + self.next_states[(origin, frozenset(formula))].add(destination) + else: + raise KeyError("The destination " + str(destination) \ + + " isn't a known state.") + else: + raise KeyError("The origin " + str(origin) \ + + " isn't a known state.") + + def change_accept(self, sets): + self.accepting_states = [] + for s in sets: + self.accepting_states.append(set(s)) + + + # Returns the set of all states reachable from the state 'origin' + # with one transition + def get_successors(self, origin, formula): + if not origin in self.all_states: + raise KeyError("The origin " + str(origin) \ + + " isn't a known state.") + return self.next_states[(origin, formula)] + + # Exports a picture of the automaton to 'file'.pdf. + def export(self, file: str): + graph = Digraph(filename = file) + graph.graph_attr['rankdir'] = 'LR' + for state in self.all_states: + node_shape = 'circle' + graph.attr('node', shape = node_shape, style = 'filled', \ + fillcolor = 'white') + graph.node(str(state), label = self.labels[state]) + if state in self.initial_states: + graph.node(str(state) + "_i", style = "invisible") + graph.edge(str(state) + "_i", str(state)) + for state in self.all_states: + for formula in self.formulas: + for next_state in self.next_states[(state, formula)]: + if not formula: + edge_label = "True" + else: + edge_label = fstr(formula) + graph.edge(str(state), str(next_state), label=edge_label, + color='black') + graph.render() + + +if __name__ == "__main__": + #exemple + exempleCours=GBA([0,1],[0,1],["a","b"],[(0,["b"],0),(0,["a","b"],1),(1,["a","b"],1)],[[1]]) + exempleCours.export("GBAexemple") diff --git a/surete/tp_ltl/src/LTL.py b/surete/tp_ltl/src/LTL.py new file mode 100644 index 0000000..46b6ea6 --- /dev/null +++ b/surete/tp_ltl/src/LTL.py @@ -0,0 +1,391 @@ +# -*-coding:UTF-8 -* +from graphviz import Digraph + + +# A pseudo-LR(1) parser for simple regular expressions, based on the following +# context-free grammar G: +# [1] E -> 's' +# where s is any sequence of characters not featuring ().+~XGFU +# [2] E -> '('E')' +# [3] E -> '~'E* +# [4] E -> 'X'E* +# [5] E -> 'G'E* +# [6] E -> 'F'E* +# [7] E -> E('U'E)* +# [8] E -> E('.'E)* +# [9] E -> E('+'E)* +# The rules being ordered by decreasing priority. + + +# A class for input tokens +class token: + + def __init__(self, type_t: str, value_t: (str | None) = None): + # The string 'type' stands for the symbol in the grammar's terminals + # matched to the token. + self.type = type_t + # The string 'value' stands for the value carried by tokens of type "s". + self.value = value_t + + +# A tree-based representation of regular expresssions +class LTL: + + def __init__(self, root: str, children: list["LTL"] = []): + # The string attribute 'root' stands for the operator labelling the + # root. + self.root = root + # The list attribute 'children' + self.children = children + + # Exports a picture of the regular expression tree to 'file'.pdf. + def export(self, file: str): + graph = Digraph(filename = file) + graph.graph_attr['rankdir'] = 'TB' + if self.children: + graph.attr('node', shape = 'circle', style = 'filled', \ + fillcolor = 'white') + graph.node("0", label = self.root) + write_graph(self, "0", graph) + else: + graph.attr('node', shape = 'box', style = 'filled', \ + fillcolor = 'white') + graph.node("0", label = self.root) + graph.render() + + + def copy(self): + cpchildren = list[LTL]() + for child in self.children: + cpchildren.append(child.copy()) + return LTL(self.root, cpchildren) + + def convertNNF(self): + if self.root == "non": + child = self.children[0] + self.root = child.root + self.children = child.children + self.negativeNNF() + else: + for child in self.children: + child.convertNNF() + + def negativeNNF(self): + if not self.children: + self.children=[LTL(self.root, self.children)] + self.root="non" + elif self.root == "non": + child = self.children[0] + self.root = child.root + self.children = child.children + self.convertNNF() + else: + if self.root == "et": + self.root = "ou" + elif self.root == "ou": + self.root = "et" + elif self.root == "U": + self.root = "R" + elif self.root == "R": + self.root = "U" + elif self.root == "G": + self.root = "F" + elif self.root == "F": + self.root = "G" + for child in self.children: + child.negativeNNF() + + def equals(self, formula): + if self.root != formula.root: + return False + for i in range(len(self.children)): + if not (self.children[i].equals(formula.children[i])): + return False + return True + +# Writes in the Graphviz graph 'graph' the tree structure of the regular +# expression 'LTL', starting from its root 'root_string'. +def write_graph(LTL, root_string: str, graph: Digraph): + if LTL.children: + index = 0 + for child in LTL.children: + child_root = root_string + str(index) + if not child.children: + graph.attr('node', shape = 'box', style = 'filled', \ + fillcolor = 'white') + lab = child.root if child.root else "<ε>" + graph.node(child_root, label = lab) + graph.edge(root_string, child_root) + else: + graph.attr('node', shape = 'circle', style = 'filled', \ + fillcolor = 'white') + graph.node(child_root, label = child.root) + graph.edge(root_string, child_root) + write_graph(child, child_root, graph) + index += 1 + + +# A class for terminal and non-terminal symbols the parser can push on the +# stack +class symbol: + + def __init__(self, type_t: str, LTL_tree: (LTL | None) =None): + # The string 'type' stands for the symbol in the grammar's vocabulary + # matched to the symbol. + self.type = type_t + # The LTL 'tree' stands for the regular expression matched to the + # symbol, based on the parsing operations applied so far. + self.tree = LTL_tree + + +# A class for the bottom-up parsing process +class LTL_Parser: + + def __init__(self, LTL_string: str): + # The input string 'stream' from which tokens are generated + self.stream = LTL_string + # The list 'stack' that stands for the parsing stack. + self.stack = list[symbol]() + + # Returns the head token of the string attribute 'stream'; if the latter is + # empty, returns the end of file token "$" instead. + def look_ahead(self): + if not self.stream: + return token("$", "$") + if self.stream[0] in ["(", ")", ".", "+", "X", "U", "~", "G", "F", "R"]: + return token(self.stream[0], self.stream[0]) + else: + index = 0 + while index < len(self.stream): + if self.stream[index] in ["(", ")", ".", "+", "X", "U","~", "G", "F", "R"]: + break + index += 1 + return token("s", self.stream[0:index]) + + # Removes and returns the head token of the string attribute 'stream'; if + # if the input stream is empty while expecting a token of type 'head_type', + # raises an error. + def pop_stream(self, head_type = ""): + if not self.stream: + if head_type: + raise IndexError("End of string reached prematurely while " \ + "looking for token '" + head_type + "'.") + else: + raise IndexError("End of string reached prematurely.") + stream_head = self.look_ahead() + assert isinstance(stream_head, token) + assert stream_head.value is not None + self.stream = self.stream[len(stream_head.value):] + return stream_head + + # Checks if rule [1] can be applied. + def check_string_rule(self): + return (len(self.stack) > 0) and (self.stack[-1].type == "s") + + # Checks if rule [2] can be applied. + def check_par_rule(self): + return (len(self.stack) > 2) and (self.stack[-1].type == ")") \ + and (self.stack[-2].type == "E") and (self.stack[-3].type == "(") \ + + # Checks if rule [3] can be applied. + def check_not_rule(self, look_ahead_t): + return (len(self.stack) > 1) and (self.stack[-2].type == "~") \ + and (self.stack[-1].type == "E") + # Checks if rule [4] can be applied. + def check_next_rule(self): + return (len(self.stack) > 1) and (self.stack[-2].type == "X") \ + and (self.stack[-1].type == "E") + + # Checks if rule [5] can be applied. + def check_G_rule(self, look_ahead_t): + return (len(self.stack) > 1) and (self.stack[-2].type == "G") \ + and (self.stack[-1].type == "E") + + # Checks if rule [6] can be applied. + def check_F_rule(self, look_ahead_t): + return (len(self.stack) > 1) and (self.stack[-2].type == "F") \ + and (self.stack[-1].type == "E") + + # Checks if rule [7] can be applied; the type of the next token + # 'look_ahead_t' is required in order to solve shift-reduce conflicts + # by applying the grammar's priority rules. + def check_until_rule(self, look_ahead_t): + return (len(self.stack) > 2) and (self.stack[-1].type == "E") \ + and (self.stack[-2].type == "U") and (self.stack[-3].type == "E") \ + and not (look_ahead_t in {"X","G","F","~"}) + + # Checks if rule [8] can be applied; the type of the next token + # 'look_ahead_t' is required in order to solve shift-reduce conflicts + # by applying the grammar's priority rules. + def check_dot_rule(self, look_ahead_t): + return (len(self.stack) > 2) and (self.stack[-1].type == "E") \ + and (self.stack[-2].type == ".") and (self.stack[-3].type == "E") \ + and not (look_ahead_t in {"X","G","F","~","U"}) + + # Checks if rule [9] can be applied; the type of the next token + # 'look_ahead_t' is required in order to solve shift-reduce conflicts + # by applying the grammar's priority rules. + def check_plus_rule(self, look_ahead_t): + return (len(self.stack) > 2) and (self.stack[-1].type == "E") \ + and (self.stack[-2].type == "+") and (self.stack[-3].type == "E") \ + and not (look_ahead_t in {"X","G","F","~","U","."}) + + # Checks if the implicit initial rule Z -> E'$' can be applied. Note that + # the end of file symbol is never pushed on the stack; it merely appears + # as an incoming token of type 'look_ahead_t' instead. Moreover, the stack + # must consist in a single non-terminal symbol E in order to avoid + # accepting with a non-empty stack. + def check_initial_rule(self, look_ahead_t): + return (len(self.stack) == 1) and (self.stack[0].type == "E") \ + and (look_ahead_t == "$") + + # Applies rule [1]. + def apply_string_rule(self): + tree = self.stack[-1].tree + self.stack = self.stack[:-1] + self.stack.append(symbol("E", tree)) + + # Applies rule [2]. + def apply_par_rule(self): + tree = self.stack[-2].tree + self.stack = self.stack[:-3] + self.stack.append(symbol("E", tree)) + + # Applies rule [3]. + def apply_not_rule(self): + tree = self.stack[-1].tree + assert tree is not None + self.stack = self.stack[:-2] + self.stack.append(symbol("E", LTL("non", [tree]))) + + # Applies rule [4]. + def apply_next_rule(self): + tree = self.stack[-1].tree + assert tree is not None + self.stack = self.stack[:-2] + self.stack.append(symbol("E", LTL("X", [tree]))) + + # Applies rule [5]. + def apply_G_rule(self): + tree = self.stack[-1].tree + assert tree is not None + self.stack = self.stack[:-2] + self.stack.append(symbol("E", LTL("G", [tree]))) + + # Applies rule [6]. + def apply_F_rule(self): + tree = self.stack[-1].tree + assert tree is not None + self.stack = self.stack[:-2] + self.stack.append(symbol("E", LTL("F", [tree]))) + + # Applies rule [7]. + def apply_until_rule(self): + right_tree = self.stack[-1].tree + left_tree = self.stack[-3].tree + assert right_tree is not None + assert left_tree is not None + self.stack = self.stack[:-3] + self.stack.append(symbol("E", LTL("U", [left_tree, right_tree]))) + + # Applies rule [8]. + def apply_dot_rule(self): + right_tree = self.stack[-1].tree + left_tree = self.stack[-3].tree + assert right_tree is not None + assert left_tree is not None + self.stack = self.stack[:-3] + self.stack.append(symbol("E", LTL("et", [left_tree, right_tree]))) + + # Applies rule [9]. + def apply_plus_rule(self): + right_tree = self.stack[-1].tree + left_tree = self.stack[-3].tree + assert right_tree is not None + assert left_tree is not None + self.stack = self.stack[:-3] + self.stack.append(symbol("E", LTL("ou", [left_tree, right_tree]))) + + # Shifts the incoming token of type 'look_ahead_t' on the stack. + def shift(self, look_ahead_t): + new_token = self.pop_stream(look_ahead_t) + # String tokens carry a simple regular expression tree reduced to + # a single node. + if new_token.type == "s": + if new_token.value == "ε": + self.stack.append(symbol("s", LTL(""))) + else: + assert new_token.value is not None + self.stack.append(symbol("s", LTL(new_token.value))) + # Other terminal symbols do not carry syntactic trees. + else: + self.stack.append(symbol(new_token.type)) + + # The parser itself. It either returns a LTL tree or raises a SyntaxError + # once it has read the entire stream yet cannot perform any reduction. + # The stack trace is shown if the Boolean 'trace' is true. + def parse(self, trace = False): + while True: + look_ahead = self.look_ahead() + # Shows the stack trace for debugging purposes. + if trace: + for symb in self.stack: + print(symb.type, end=";") + print() + # First tries to apply the reduction rules in their matching + # priority order. + if self.check_string_rule(): + self.apply_string_rule() + elif self.check_par_rule(): + self.apply_par_rule() + elif self.check_next_rule(): + self.apply_next_rule() + elif self.check_not_rule(look_ahead.type): + self.apply_not_rule() + elif self.check_G_rule(look_ahead.type): + self.apply_G_rule() + elif self.check_F_rule(look_ahead.type): + self.apply_F_rule() + elif self.check_until_rule(look_ahead.type): + self.apply_until_rule() + elif self.check_dot_rule(look_ahead.type): + self.apply_dot_rule() + elif self.check_plus_rule(look_ahead.type): + self.apply_plus_rule() + # If the initial reduction can be performed, the parsing process + # succeeds. + elif self.check_initial_rule(look_ahead.type): + return self.stack[0].tree + # It otherwise shifts a token from the input stream, assuming it is + # not empty. + elif look_ahead.type != "$": + self.shift(look_ahead.type) + # The parser can no longer shift or reduce, hence, fails. + else: + raise SyntaxError("Can no longer shift a symbol or reduce" \ + " a rule.") + + +# Returns a tree of type LTL representing the string 'LTL_string'. +def new_LTL(LTL_string: str): + parsed = LTL_Parser(LTL_string).parse() + assert parsed is not None + return parsed + + +# Tests +if __name__ == "__main__": + P1 = LTL_Parser("a") + P1_tokens = list[str]() + while P1.stream: + head = P1.look_ahead().value + assert head is not None + P1_tokens.append(head) + P1.pop_stream() + head = P1.look_ahead().value + assert head is not None + P1_tokens.append(head) + print(P1_tokens) + formule = new_LTL("~(a+X~a+Gb.F~c)") + formule.convertNNF() + formule.export("test") diff --git a/surete/tp_ltl/src/LTLchecker.py b/surete/tp_ltl/src/LTLchecker.py new file mode 100644 index 0000000..301381f --- /dev/null +++ b/surete/tp_ltl/src/LTLchecker.py @@ -0,0 +1,34 @@ +from GBA import * +from kripke import * +from LTL import * +from LTLtoGBA import * +from product import * +from emptyTest import * + +#Entrées : une formule LTL et une structure de Kripke et un ensemble de propositions atomiques +#Sortie : renvoie True si ttes les traces de la structure satisfont la formule faux sinon +def satisfait(formule: LTL, kripke: Kripke, /, *_): + neg = LTL("non", [formule]).convertNNF() + propositions = kripke.ap + gba1 = buildBuchi(neg, propositions) + gba2 = kripke.toGBA() + produit = product(gba1,gba2) + return is_GBA_empty(produit) + +if __name__ == "__main__": + #machine à laver + propositions = ["b","f","d","v"] + mlaver=Kripke([0,1,2,3,4],[0],["b","f","d","v"],[(0,1),(0,2),(1,3),(1,0),(2,3),(3,2),(3,4),(4,4)],{0:set(),1:{"f"},2:{"b"},3:{"b","f"},4:{"b","f","d","v"}}) + mlaver.export("mlaver") + #Test avec formule1, doit être faux + formule1 = new_LTL("F(d)") + satisfait(formule1, mlaver, ["b","f","d","v"]) + #Test avec formule2, doit être vrai + formule2 = new_LTL("G(~d+f)") + satisfait(formule2, mlaver, ["b","f","d","v"]) + #Test avec formule3, doit être vrai + formule3 = new_LTL("G(~d+G(d))") + satisfait(formule3, mlaver, ["b","f","d","v"]) + #Test avec formule4, doit être vrai + formule4 = new_LTL("G(~d.~v)+F(d.v))") + satisfait(formule4, mlaver, ["b","f","d","v"]) diff --git a/surete/tp_ltl/src/LTLtoGBA.py b/surete/tp_ltl/src/LTLtoGBA.py new file mode 100644 index 0000000..fb48c63 --- /dev/null +++ b/surete/tp_ltl/src/LTLtoGBA.py @@ -0,0 +1,260 @@ +# -*-coding:UTF-8 -* +from LTL import * +from GBA import * + + +def equals(formules1: list[LTL], formules2: list[LTL]): + difference = formules1.copy() + for form1 in formules2: + equals = False + for form2 in formules1: + if form1.equals(form2): + difference.remove(form2) + equals = True + if not equals: + return False + return not difference + + +def findall(val: list[tuple[list[LTL], int]], formule: list[LTL]): + result = set() + for couple in val: + if equals(formule,couple[0]): + result.add(couple[1]) + return result + + +def clean(formules: Iterable[LTL]): + new = list[LTL]() + for form1 in formules: + toAdd = True + for form2 in new: + if form1.equals(form2): + toAdd = False + if toAdd: + new.append(form1) + formules = new + return new + + +def copy(formules: Iterable[LTL]): + result = list[LTL]() + for formule in formules: + result.append(formule.copy()) + return result + + +def is_in(formule, formules): + for formule2 in formules: + if formule.equals(formule2): + return True + return False + + +def duplicate(state: int, structure: GBA, todo: dict[int, list[LTL]], val: list[tuple[list[LTL], int]], toExpand: list[int]): + statecp=structure.add_state() + if state in structure.initial_states: + structure.add_initial(statecp) + update_val(state, statecp, val) + todo[statecp]=copy(todo[state]) + todo[state]=copy(todo[state]) + toExpand.append(statecp) + return statecp + + +def update_val(state, statecp, val): + for couple in val: + if couple[1]==state: + val.append((couple[0],statecp)) + return val + + +def traitET(formule: LTL, i: int, structure: GBA, todo: dict[int, list[LTL]], state: int, val: list[tuple[list[LTL], int]], toExpand: list[int]): + """ + Applies a 'AND' node of the LTL formula to the val. + """ + child1 = formule.children[0] + child2 = formule.children[1] + formulecp = copy(todo[state]) + todo[state] = formulecp + formulecp[i] = child1 + formulecp.append(child2) + val.append((formulecp,state)) + return True + + +def traitG(formule: LTL, i: int, structure: GBA, todo: dict[int, list[LTL]], state: int, val: list[tuple[list[LTL], int]], toExpand: list[int]): + child = formule.children[0] + formulecp = todo[state].copy() + todo[state] = formulecp + formulecp.append(child) + formulecp[i] = LTL("X", [formule]) + val.append((formulecp,state)) + return True + + +def traitOU(formule: LTL, i: int, structure: GBA, todo: dict[int, list[LTL]], state: int, val: list[tuple[list[LTL], int]], toExpand: list[int]): + #on duplique l'état considéré pour avoir deux choix de transitions possibles + state2 = duplicate(state, structure, todo, val, toExpand) + #on récupère les formules à droite et à gauche du OU + child1 = formule.children[0] + child2 = formule.children[1] + #on modifie les formules courantes pour avoir dans un état child1 et dans l'autre child2 + todo[state][i] = child1.copy() + todo[state2][i] = child2.copy() + #on ajoute le fait que state et state2 satisfont le nouvel ensemble de formules + val.append((todo[state], state)) + val.append((todo[state2],state2)) + return True + + +def traitF(formule: LTL, i: int, structure: GBA, todo: dict[int, list[LTL]], state: int, val: list[tuple[list[LTL], int]], toExpand: list[int]): + #on duplique l'état considéré pour avoir deux choix de transitions possibles + state2 = duplicate(state, structure, todo, val, toExpand) + #on récupère la formule sous le F + child = formule.children[0] + #on construit la formule avec XF + nextF = LTL("X", [formule]) + #on modifie les formules courantes pour avoir dans un état child et dans l'autre XF(child) + todo[state2][i] = child + todo[state][i] = nextF + #on ajoute le fait que state et state2 satisfont le nouvel ensemble de formules + val.append((todo[state], state)) + val.append((todo[state2],state2)) + return True + + +def traitU(formule: LTL, i: int, structure: GBA, todo: dict[int, list[LTL]], state: int, val: list[tuple[list[LTL], int]], toExpand: list[int]): + #on duplique l'état considéré pour avoir deux choix de transitions possibles + state2 = duplicate(state, structure, todo, val, toExpand) + #on récupère les formules à droite et à gauche du U + child1 = formule.children[0] + child2 = formule.children[1] + #on construit la formule avec X..U.. + nextU = LTL("X", [formule]) + #on modifie les formules courantes + + #à compléter + todo[state2][i] = child2 + todo[state][i] = nextU + todo[state].append(child1.copy()) + + #on ajoute le fait que state et state2 satisfont le nouvel ensemble de formules + val.append((todo[state], state)) + val.append((todo[state2],state2)) + return True + + +def traitement(done: bool, i: int, structure: GBA, todo: dict[int, list[LTL]], state: int, val: list[tuple[list[LTL], int]], toExpand: list[int]): + """ + Applies one step of the todo collection of LTL formulas. + """ + formule = todo[state][i] + if formule.root == "et": + return traitET(formule, i, structure, todo, state, val, toExpand) + elif formule.root == "ou": + return traitOU(formule, i, structure, todo, state, val, toExpand) + elif formule.root == "F": + return traitF(formule, i, structure, todo, state, val, toExpand) + elif formule.root == "G": + return traitG(formule, i, structure, todo, state, val, toExpand) + elif formule.root == "U": + return traitU(formule, i, structure, todo, state, val, toExpand) + else: + return False + + +def buildBuchi(formule: LTL, propositions: list[str]): + """ + Builds a buchi state machine. + + From the LTL formula and the possible propositions. + """ + structure = GBA([0],[0],propositions,[],[]) + val=[([formule], 0)] + todo = {0:[formule]} + expandState(structure, todo, 0, val, [0]) + accept_conditions(structure, todo, val) + return structure + + +def expandState(structure: GBA, todo: dict[int, list[LTL]], state: int, val: list[tuple[list[LTL], int]], toExpand: list[int]): + """ + Creates all states from a collection of LTL transitions formulas (in todo). + """ + done = False + i = 0 + while not done and i < len(todo[state]): + done = traitement(done, i, structure, todo, state, val, toExpand) + i=i+1 + if not done: + toExpand = toExpand[1:] + if toExpand: + expandState(structure, todo, toExpand[0], val, toExpand) + else: + computeSucc(structure, todo, val) + return val + + +def computeSucc(structure: GBA, todo: dict[int, list[LTL]], val: list[tuple[list[LTL], int]]): + states = structure.all_states.copy() + for state in states: + succ = findall(val, next(todo[state])) + if not succ: + new = structure.add_state() + val.append((next(todo[state]),new)) + todo[new]=next(todo[state]) + expandState(structure, todo, new, val, [new]) + succ = findall(val, next(todo[state])) + label = now(todo[state]) + if is_consistent(label): + for s in succ: + structure.add_edge(state,label, s) + + +def accept_conditions(structure: GBA, todo: dict[int, list[LTL]], val: list[tuple[list[LTL], int]]): + cond = list[LTL]() + for couple in val: + for formule in couple[0]: + if formule.root in {"F","U"} and not is_in(formule,cond): + cond.append(formule) + sets = list[list[int]]() + for i in range(len(cond)): + formule = cond[i] + sets.append([]) + for state in structure.all_states: + if not is_in(LTL("X", [formule]), todo[state]): + sets[i].append(state) + structure.change_accept(sets) + return structure + + +def next(formules: Iterable[LTL]): + retour = list[LTL]() + for formule in formules: + if formule.root == "X": + retour.append(formule.children[0]) + return retour + + +def now(formules: Iterable[LTL]): + retour = list[str]() + for formule in formules: + if formule.root == "non": + retour.append("~"+formule.children[0].root) + if not formule.children: + assert type(formule.root) is str + retour.append(formule.root) + return retour + + +if __name__ == "__main__": + formule = new_LTL("G(a).Fb") + trad = buildBuchi(formule, ["a","b"]) + trad.export("trad") + print(trad.accepting_states) + + formule = new_LTL("aUb") + trad = buildBuchi(formule, ["a","b"]) + trad.export("trad_union") + print(trad.accepting_states) diff --git a/surete/tp_ltl/src/buchi.py b/surete/tp_ltl/src/buchi.py new file mode 100644 index 0000000..1544119 --- /dev/null +++ b/surete/tp_ltl/src/buchi.py @@ -0,0 +1,132 @@ +# -*-coding:UTF-8 -* +from graphviz import Digraph +from utils import edge + + +def fstr(formula): + form_str = "" + for l in formula: + form_str = form_str+l+',' + return form_str[:-1] + +def is_consistent(formula): + for l in formula: + if "~"+l in formula: + return False + return True + + +# Buchi automata +class Buchi: + + def __init__(self, all_states: list[int], initial_states: list[int], propositions: list[str], edges: list[edge], accepting: list[int]): + + # States: a set of integers + self.all_states = set(all_states) + # Initial states: a set of integers + self.initial_states = set(initial_states).intersection(self.all_states) + # There must be an initial state; if there isn't, an initial state 0 + # is added + if not self.initial_states: + self.initial_states.add(0) + self.all_states.add(0) + #Defining the set of accepting states + self.accepting_states = set(accepting) + #Defining the set of propositionnal variables + self.ap = set(propositions) + #We build the set of formulas appearing in transitions + #A formula is represented by a set of litterals ie a variable or its negation + if edges: + self.formulas = {frozenset(formula) for (_,formula,_) in edges} + else: + self.formulas = set() + self.next_states = {(state, formula): set() + for state in self.all_states + for formula in self.formulas} + for edge in edges: + if (edge[0] in self.all_states) and (edge[2] in self.all_states) and is_consistent(edge[1]): + self.next_states[(edge[0], frozenset(edge[1]))].add(edge[2]) + self.labels = {state:str(state) for state in self.all_states} + + # Adds a new state to the structure + def add_state(self): + add_state = max(self.all_states) + 1 + self.all_states.add(add_state) + for formula in self.formulas: + self.next_states[add_state,formula] = set() + self.labels[add_state]= str(add_state) + return add_state + + def add_initial(self, state): + self.initial_states.add(state) + return state + + # # Removes the state 'state' from the structure if it exists. + # def remove_state(self, state): + # if state in self.all_states: + # self.all_states.remove(state) + # if state in self.initial_states: + # self.initial_states.remove(state) + # del self.labels[state] + # del self.valuation[state] + # # Remove the successors of 'state', but also all the edges + # # leading to 'state' + # del self.next_states[state] + # for origin in self.all_states: + # if state in self.next_states[origin]: + # self.next_states[origin].remove(state) + + + # Adds a new edge from the state 'origin' to the state 'destination' + def add_edge(self, origin, formula, destination): + if origin in self.all_states: + if destination in self.all_states: + if not frozenset(formula) in self.formulas: + self.formulas.add(frozenset(formula)) + for st in self.all_states: + self.next_states[(st, frozenset(formula))] = set() + self.next_states[(origin, frozenset(formula))].add(destination) + else: + raise KeyError("The destination " + str(destination) \ + + " isn't a known state.") + else: + raise KeyError("The origin " + str(origin) \ + + " isn't a known state.") + + + # Returns the set of all states reachable from the state 'origin' + # with one transition + def get_successors(self, origin, formula): + if not origin in self.all_states: + raise KeyError("The origin " + str(origin) \ + + " isn't a known state.") + return self.next_states[(origin, formula)] + + # Exports a picture of the automaton to 'file'.pdf. + def export(self, file): + graph = Digraph(filename = file) + graph.graph_attr['rankdir'] = 'LR' + for state in self.all_states: + node_shape = 'circle' + if state in self.accepting_states: + node_shape = 'doublecircle' + graph.attr('node', shape = node_shape, style = 'filled', \ + fillcolor = 'white') + graph.node(str(state), label = self.labels[state]) + if state in self.initial_states: + graph.node(str(state) + "_i", style = "invisible") + graph.edge(str(state) + "_i", str(state)) + for state in self.all_states: + for formula in self.formulas: + for next_state in self.next_states[(state, formula)]: + if not formula: + edge_label = "True" + else: + edge_label = fstr(formula) + graph.edge(str(state), str(next_state), label=edge_label, + color='black') + graph.render() + +#exemple +exempleCours=Buchi([0,1],[0,1],["a","b"],[(0,["b"],0),(0,["a","b"],1),(1,["a","b"],1)],[1]) +exempleCours.export("BuchiExemple") diff --git a/surete/tp_ltl/src/emptyTest.py b/surete/tp_ltl/src/emptyTest.py new file mode 100644 index 0000000..5488b9b --- /dev/null +++ b/surete/tp_ltl/src/emptyTest.py @@ -0,0 +1,45 @@ +from GBA import GBA + + +def dfs(gba : GBA, s1, s2, sets, eactuel, index, past): + if index == len(sets): + return eactuel == s2 + past.add((eactuel, index)) + for ns in gba.transitions[eactuel]: + if ns in sets[index] and (ns, index + 1) not in past: + return dfs(gba, s1, s2, ns, index + 1, past) + if (ns, index) not in past: + return dfs(gba, s1, s2, ns, index, past) + return False + + +def path(gba: GBA, s1, s2, sets): + past = set() + return dfs(gba, s1,s2, s1, 0, past) + +#Entrée : une formule sous forme de liste de littéraux (ie une variable ou sa négation) +#Vérifie que cette formule est consistente cad qu'elle ne contient pas à la fois une variable et sa négation +def is_consistent(formula): + for l in formula: + if "~"+l in formula: + return False + return True + +#Entrées : 1 automate de buchi +#Sortie : renvoie True si cet automate n'admet aucune exécution et false sinon +def is_Buchi_empty(buchi): + #à compléter + return False + +#Entrées : 1 automate de buchi généralisé +#Sortie : renvoie True si cet automate n'admet aucune exécution et false sinon +def is_GBA_empty(gba): + #à compléter + for init in gba.initial_state: + for accept in gba.accepting_sets: + for acc in accept: + if path(gba, init, acc, gba.accepting_sets): + return False + return True + + diff --git a/surete/tp_ltl/src/kripke.py b/surete/tp_ltl/src/kripke.py new file mode 100755 index 0000000..3d5f341 --- /dev/null +++ b/surete/tp_ltl/src/kripke.py @@ -0,0 +1,101 @@ +# -*-coding:UTF-8 -* +from graphviz import Digraph +from GBA import * + + +KripkeEdge = tuple[int, int] + + +# Kripke structure +class Kripke: + + def __init__(self, all_states: list[int], initial_states: list[int], propositions: list[str], edges: list[KripkeEdge], valuations: dict[int, set[str]]): + + # States: a set of integers + self.all_states = set(all_states) + # Initial states: a set of integers + self.initial_states = set(initial_states).intersection(self.all_states) + # There must be an initial state; if there isn't, an initial state 0 + # is added + if not self.initial_states: + self.initial_states.add(0) + self.all_states.add(0) + self.ap = propositions + self.next_states = {state: set[int]() + for state in self.all_states} + for edge in set(edges): + if (edge[0] in self.all_states) and (edge[1] in self.all_states): + self.next_states[edge[0]].add(edge[1]) + self.valuation = valuations + self.labels = {state:str(self.valuation[state]) for state in self.all_states} + + # Adds a new state to the structure + def add_state(self, val): + add_state = max(self.all_states) + 1 + self.all_states.add(add_state) + self.next_states[add_state] = set() + self.valuation[add_state] = val + self.labels[add_state]= str(val) + return add_state + + # Removes the state 'state' from the structure if it exists. + def remove_state(self, state): + if state in self.all_states: + self.all_states.remove(state) + if state in self.initial_states: + self.initial_states.remove(state) + del self.labels[state] + del self.valuation[state] + # Remove the successors of 'state', but also all the edges + # leading to 'state' + del self.next_states[state] + for origin in self.all_states: + if state in self.next_states[origin]: + self.next_states[origin].remove(state) + + + # Returns the set of all states reachable from the state 'origin' + # with one transition + def get_successors(self, origin): + if not origin in self.all_states: + raise KeyError("The origin " + str(origin) \ + + " isn't a known state.") + return self.next_states[origin] + + # Exports a picture of the automaton to 'file'.pdf. + def export(self, file): + graph = Digraph(filename = file) + graph.graph_attr['rankdir'] = 'LR' + for state in self.all_states: + node_shape = 'circle' + graph.attr('node', shape = node_shape, style = 'filled', \ + fillcolor = 'white') + graph.node(str(state), label = self.labels[state]) + if state in self.initial_states: + graph.node(str(state) + "_i", style = "invisible") + graph.edge(str(state) + "_i", str(state)) + for state in self.all_states: + for next_state in self.next_states[state]: + edge_colour = 'black' + edge_label = "" + graph.edge(str(state), str(next_state), label=edge_label, + color=edge_colour) + graph.render() + + + def toGBA(self): + edges = list[tuple[int, list[str], int]]() + for state in self.all_states: + val = list[str]() + for prop in self.ap: + if prop in self.valuation[state]: + val.append(prop) + else: + val.append("~"+prop) + for next_state in self.next_states[state]: + edges.append((state, val ,next_state)) + return GBA(self.all_states, self.initial_states, self.ap, edges, [self.all_states]) + +if __name__ == "__main__": + mlaver=Kripke([0,1,2,3,4],[0],["b","f","d","v"],[(0,1),(0,2),(1,3),(1,0),(2,3),(3,2),(3,4),(4,4)],{0:set(),1:{"f"},2:{"b"},3:{"b","f"},4:{"b","f","d","v"}}) + mlaver.toGBA().export("GBAlaver") diff --git a/surete/tp_ltl/src/product.py b/surete/tp_ltl/src/product.py new file mode 100644 index 0000000..95aefde --- /dev/null +++ b/surete/tp_ltl/src/product.py @@ -0,0 +1,49 @@ +from GBA import * + +#Entrée : une formule sous forme de liste de littéraux (ie une variable ou sa négation) +#Vérifie que cette formule est consistente cad qu'elle ne contient pas à la fois une variable et sa négation +def is_consistent(formula: Iterable[str]): + for l in formula: + if "~" + l in formula: + return False + return True + +#Entrées : 2 automates de buchi généralisés +#Sortie : le produit synchrone de ces automates +def product[T, U](gba1: GBA[T], gba2: GBA[U]): + states = {(state1, state2) for state1 in gba1.all_states for state2 in gba2.all_states} + initials = {(state1, state2) for state1 in gba1.initial_states for state2 in gba2.initial_states} + formulas = {f1.union(f2) for f1 in gba1.formulas for f2 in gba2.formulas} + ap = gba1.ap.union(gba2.ap) + edges = list[edge]() + + + #à compléter + product_impl(gba1, gba2, edges) + + + accepting = list[frozenset[tuple[state[T], state[U]]]]() + for acc in gba1.accepting_states: + accepting.append(frozenset({(state1, state2) for state1 in acc for state2 in gba2.all_states})) + for acc in gba2.accepting_states: + accepting.append(frozenset({(state1, state2) for state1 in gba1.all_states for state2 in acc})) + return GBA(states, initials, ap, edges, accepting) + + +def product_impl[T, U](gpa_left: GBA[T], gba_right: GBA[U], edges: list[edge[tuple[state[T], state[U]]]]): + for (d1, f1), dest1 in gpa_left.next_states.items(): + for (d2, f2), dest2 in gba_right.next_states.items(): + for item1 in dest1: + for item2 in dest2: + vari = f1.union(f2) + if is_consistent(vari): + edges.append(((d1, d2), vari, (item1, item2))) + + +if __name__ == "__main__": + gba1 =GBA([0,1],[0,1],["a"],[(0,[],0),(0,["a"],1),(1,["a"],1)],[[1]]) + gba2 =GBA([0,1],[0,1],["b"],[(0,[],0),(0,["b"],1),(1,["b"],1)],[[1]]) + produitTest = product(gba1,gba2) + produitTest.export("produitTest") + produit = GBA([0,1,2,3],[0,1,2,3],["a", "b"],[(0,[],0),(0,["a","b"],3),(0,["a"],1),(1,["a"],1),(0,["b"],2),(1,["a","b"],3),(2,["b"],2), (2,["a","b"],3), (3,["a","b"],3)],[[1,3],[2,3]]) + produit.export("produit") diff --git a/surete/tp_ltl/src/py.typed b/surete/tp_ltl/src/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/surete/tp_ltl/src/utils.py b/surete/tp_ltl/src/utils.py new file mode 100644 index 0000000..d0f6600 --- /dev/null +++ b/surete/tp_ltl/src/utils.py @@ -0,0 +1,9 @@ +from typing import Iterable, TypeVar + +T = TypeVar("T") +edge = tuple[T | int, Iterable[str], T | int] +del T + +T = TypeVar("T") +state = T | int +del T \ No newline at end of file diff --git a/surete/tp_ltl/sujet.pdf b/surete/tp_ltl/sujet.pdf new file mode 100644 index 0000000000000000000000000000000000000000..33f80b02540ac323889495fd4bee7e7af3f3640f GIT binary patch literal 185907 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

Gm|nH%q+$%DnlFp*4=rAnn^-1utxm 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 literal 0 HcmV?d00001 diff --git a/surete/tp_ltl/test/.gitignore b/surete/tp_ltl/test/.gitignore new file mode 100644 index 0000000..4029495 --- /dev/null +++ b/surete/tp_ltl/test/.gitignore @@ -0,0 +1 @@ +/output \ No newline at end of file diff --git a/surete/tp_ltl/test/test.sh b/surete/tp_ltl/test/test.sh new file mode 100755 index 0000000..bcdc95c --- /dev/null +++ b/surete/tp_ltl/test/test.sh @@ -0,0 +1,42 @@ +#!/bin/bash +set -e +cd "$(dirname "$(realpath "$0")")" + + +PROJ="$(dirname "$PWD")" + + +if ! [ -f "$PROJ/venv/bin/activate" ] +then "$PROJ/setup.sh" +fi + +. "$PROJ/venv/bin/activate" + + +rm -fr output +mkdir -p output +cd output + + +function run() { + src="$1" + name="$(basename "$src")" + ( + set +e + python "$src" > "$name.log" 2>&1 + if [ "$?" = "0" ] + then echo "OK $name" + else echo "ERR $name 'test/output/$name.log'" + fi + set -e + ) || true +} + + +run "$PROJ/src/kripke.py" +run "$PROJ/src/GBA.py" +run "$PROJ/src/LTL.py" +run "$PROJ/src/LTLchecker.py" +run "$PROJ/src/LTLtoGBA.py" +run "$PROJ/src/product.py" +run "$PROJ/src/emptyTest.py"