[CS@TUK] Questions and Answers - Recent questions and answers in # Study-Organisation (Master)
https://q2a.cs.uni-kl.de/qa/%23-study-organization-ma
Powered by Question2AnswerAnswered: Sequent calculus
https://q2a.cs.uni-kl.de/3597/sequent-calculus?show=3598#a3598
You have replaced (c->a)->b by !(!c&a)&a, but it should be rather !(!c|a)|a since an implication phi->psi can be defined as !phi | psi.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3597/sequent-calculus?show=3598#a3598Wed, 26 Apr 2023 09:48:09 +0000Answered: LTL Translation Formula September 6, 2022
https://q2a.cs.uni-kl.de/3575/ltl-translation-formula-september-6-2022?show=3576#a3576
These formulas solve one of the problems to convert a CTL* formula to CTL (if possible). You can find them and their explanations in the temporal logic chapter on slides 45-46, and a lot of instances of them to other temporal operators on slides 47-49 (if you want to fill your cheat sheet).# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3575/ltl-translation-formula-september-6-2022?show=3576#a3576Tue, 14 Feb 2023 08:45:54 +0000Answered: Zielonka Attr A
https://q2a.cs.uni-kl.de/3546/zielonka-attr-a?show=3566#a3566
<p>Game 4 looks as follows:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=4281399116799325901" style="height:104px; width:349px"></p><p>The highest rank is h=6, so that player 0 can win if player 0 can mange to visit the states with that rank infinitely often. Player 0 controls the oval nodes, and player 1 controls the rectangles nodes. Attractor(0,{s6}) are those states where player 0 can enforce that state s6 is reached whatever player 1 might try to avoid this. So, in state s6, we are already there, so that clearly, we see that in general Q is a subset of attractor(i,Q). State s1 does not belong to the attractor, since player 1 controls that state and player 1 might choose the transition to state s4 instead of the one to s6. The game may continue alternating between s1 and s4, so that s6 is never reached. For the same reason, also s4 is not part of the attractor, so that attractor(0,{s6})={s6} holds. </p><p>Note that player 0 still wins in all of the states of that game, since player 0 may choose the transitions in blue in the oval nodes. If player 1 infinitely often chooses the transition to s6, the highest rank visited infinitely often is 6 so player 0 wins, and otherwise, the highest rank visited infinitely often is 4 so player 0 wins also. </p><p></p><p>Game 3 looks as follows:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=10929652653957227868" style="height:100px; width:234px"></p><p>The highest rank is h=4, owned by player 0, and it only is the rank of state s4. We have attractor(0,{s4}) = {s1,s4} since it is clear that s4 belongs to the attractor. Also s1 belongs to the attractor since player 1 can only choose the transition to state s4, so that player 1 cannot avoid that s4 is reached. </p><p>So, in general attractor(j,Q) is the set of states where player j can enforce that a state in Q is reached, no matter what transitions the other player chooses in the states controlled by that other player. This can be expressed formally in µ-calculus as µx.(Q | <j>x) where ⟨A⟩φ := A ∧ ♦φ ∨ B ∧ φ = (A ⇒ ♦φ| φ), but in most cases, it can be seen from the game which states belong to the attractor.</p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3546/zielonka-attr-a?show=3566#a3566Mon, 13 Feb 2023 14:53:03 +0000Answered: Zielonka - Practice Questions
https://q2a.cs.uni-kl.de/3545/zielonka-practice-questions?show=3565#a3565
<p>Well, it is not that easy to come up with a couple of meaningful examples. If we try to generate them randomly, they are often not good in the sense that they produce bad computations. However, with every example that is there, you get typically many recursive calls and these are further examples that you can study. Anyway, we try to generate more examples and will make them available in the future. </p><p>Little side remark: In the lecture, it was told the µ-calculus model checking is equivalent to a parity game (pages 122-133). Hence, from every µ-calculus model-checking problem, you can get a parity game that you can use. If you use the local model checking tool (on <a rel="nofollow" href="https://es.cs.uni-kl.de/tools/teaching/ModelChecking.html">https://es.cs.uni-kl.de/tools/teaching/ModelChecking.html</a>), you find an option to convert the model-checking problem to a parity game. That is nothing else but the local model checking that applies all rules even if these are not needed for the proof. </p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3545/zielonka-practice-questions?show=3565#a3565Mon, 13 Feb 2023 14:18:15 +0000Answered: Conditions to find the attractor
https://q2a.cs.uni-kl.de/3548/conditions-to-find-the-attractor?show=3564#a3564
Simply consider the Zielonka algorithm on page 152: First, we determine the highest rank h that we find on some state of the game, and then we compute player i as i := h mod 2, so i is 1 if h is an odd number, and i is 0 if h is an even number. <br />
<br />
The thought behind this is that we try to find a strategy to infinitely often visit states with highest rank h, which would give the player i a winning strategy.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3548/conditions-to-find-the-attractor?show=3564#a3564Mon, 13 Feb 2023 14:11:56 +0000Answered: LTL omega automata
https://q2a.cs.uni-kl.de/3550/ltl-omega-automata?show=3563#a3563
You start with the initial states, maybe there is only one or two. Then, you consider the transition relation where the state variables have been replaced with the constants that determine the initial state that you consider. Then, you compute the satisfying assignments of the specialized transition relation which enumerates the transitions from that initial state. That gives you further states that are reachable, and you have to proceed next the same way with them. <br />
<br />
Proceeding this way will make sure that you will not waste time for computing transitions of unreachable states.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3550/ltl-omega-automata?show=3563#a3563Mon, 13 Feb 2023 14:05:30 +0000Answered: Problem 7 sep 2022
https://q2a.cs.uni-kl.de/3556/problem-7-sep-2022?show=3557#a3557
An omega automaton accepts an infinite word, if (1) there is an infinite run through the automaton, and (2) that run satisfies the acceptance condition. If the acceptance condition is simply true, then it is enough that the word has an infinite run through the automaton. That kind of omega-automaton essentially belongs to every class of nondeterministic automata, and we may consider it also as a safety automaton so that the subset construction can be used for its determinization.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3556/problem-7-sep-2022?show=3557#a3557Mon, 13 Feb 2023 13:27:23 +0000Answered: Prob 6 NDet FG (SEP 2022)
https://q2a.cs.uni-kl.de/3526/prob-6-ndet-fg-sep-2022?show=3537#a3537
Lets take the state p = q = 0 which is the starting state of any transition the remaining relation (!Xp | a) & (!a | Xp) talks about. Now you can check for every possible "ending state" of a transition what inputs you need for that (if possible at all):<br />
<br />
p' = q' = 0 => Relation reduces to: (1 | a) & (!a | 0) = 1 & !a = !a<br />
<br />
=> the loop from state {} to state {} needs input !a<br />
<br />
p' = 0, q' = 1 => The same result as before as q' does not appear in the relation<br />
<br />
=> the transition from state {} to state {q} needs input !a<br />
<br />
p' = 1, q' = 0 => Relation reduced to (0 | a) & (!a | 1) = a & 1 = a<br />
<br />
=> the transition from state {} to state {p} needs input a<br />
<br />
p' = q' = 1 => Again the same result as before<br />
<br />
=> the transition from state {} to state {p,q} needs input a<br />
<br />
Technically by doing this you are trying every of the 16 possible combinations of p, q, p' and q' and you could create a truth table for all of these 16 cases. However as you just saw you don't need to actually do all cases as some are equal to some others; for example in the current case the value of q' didn't matter as it didn't appear in this relation when starting at p = q = 0 thus you only needed to check half of the cases.<br />
<br />
Another easy example for that is the case p = 1 and q = 0 where the relation is just p', so the only condition is that the successor state has p in its label, thus the four cases are directly clear:<br />
<br />
Draw a transition from {p} to {p} and to {p,q} with a star symbol * each (i.e. the input doesn't matter or all inputs are allowed for those transitions); on the other side there are no transitions from {p} to either {} or {q} as the relation evaluates to false in those cases.<br />
<br />
For that reason you normally don't want to do a truth table for all 16 entries but just a partial truth table as you did here (for the starting states) as this allows you do reduce some time when evaluating all possible cases.<br />
<br />
Final example for p = q = 1:<br />
<br />
The relation is a direct conjunction so the only possible transition goes to state p' = q' = 1 by having input !b.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3526/prob-6-ndet-fg-sep-2022?show=3537#a3537Fri, 10 Feb 2023 20:00:31 +0000Answered: Translation to CTL
https://q2a.cs.uni-kl.de/3524/translation-to-ctl?show=3534#a3534
<p>Pulling the negation inwards is explained on page 25 of chapter 7. From a logical point you can also reason that: Not having c until d means that !c must have happened at least once before d. If d never holds (violating the "strong until" definition) then of course the weak definition of "before" is sufficient to describe that behavior (and the other way round).</p><p>On the other side, you can also use page 29 of chapter 7 to first rewrite the "strong until" as a "strong before" and then applying the negation to that "strong before" which gives you:</p><p>¬ [c <u>U</u> d] = ¬ [d <u>B</u> (¬c ∧ ¬d)] = [¬d U (¬c ∧ ¬d)]</p><p>so the second conversion is also correct. You can also reason that conversion from the "before" directly:</p><p>Either !d holds infinitely (then both the "weak before" and "weak until" are true) or there is some point where !c holds before the first appearance of d, which thus must be a point where !c & !d holds (which also "solves" the weak until).</p><p>As page 28 and 29 show, every temporal operator (beside X) can be written as "strong until" while "strong until" itself can be rewritten as any of the other binary temporal operators, so there is effectively a conversion from every temporal operator to every other temporal operator (by going over "strong until") except the two unary ones (i.e. "G" and "F") which can of course not solely represent the binary operators (but can be represented by them). However not all combinations of those conversions are described explicitely in the script, so you may need to do this yourself (for example by going over the "strong until" as just explained).</p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3524/translation-to-ctl?show=3534#a3534Fri, 10 Feb 2023 19:33:24 +0000Answered: Sept 2022 Lo1 to ltl
https://q2a.cs.uni-kl.de/3525/sept-2022-lo1-to-ltl?show=3532#a3532
<p>First of all, you have a small mistake in there, as the time over the "b" variables should be "t1" and not "t2" (this is important!). That said you can then do the following:</p><p><span style="color:#202124; font-family:arial,sans-serif">∀</span><span style="font-family:Helvetica,Arial,sans-serif">t1.</span><span style="color:#202124; font-family:arial,sans-serif">∀</span><span style="font-family:Helvetica,Arial,sans-serif">t2.((t1 < t2 & a</span><sup>(t2)</sup><span style="font-family:Helvetica,Arial,sans-serif"> ) -> (a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">))</span></p><p><span style="font-family:Helvetica,Arial,sans-serif">= </span><span style="color:#202124; font-family:arial,sans-serif">∀</span><span style="font-family:Helvetica,Arial,sans-serif">t1.</span><span style="color:#202124; font-family:arial,sans-serif">∀</span><span style="font-family:Helvetica,Arial,sans-serif">t2.(!(t1 < t2 & a</span><sup>(t2)</sup><span style="font-family:Helvetica,Arial,sans-serif"> ) | (a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">)) [by definition of the implication]</span></p><p><span style="font-family:Helvetica,Arial,sans-serif">= </span><span style="color:#202124; font-family:arial,sans-serif">∀</span><span style="font-family:Helvetica,Arial,sans-serif">t1.(</span><span style="color:#202124; font-family:arial,sans-serif">∀</span><span style="font-family:Helvetica,Arial,sans-serif">t2.!(t1 < t2 & a</span><sup>(t2)</sup><span style="font-family:Helvetica,Arial,sans-serif"> ) | (a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">)) [as </span><span style="font-family:Helvetica,Arial,sans-serif">(a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">) does not depend on t2</span><span style="font-family:Helvetica,Arial,sans-serif">]</span></p><p><span style="font-family:Helvetica,Arial,sans-serif">= </span><span style="color:#202124; font-family:arial,sans-serif">∀</span><span style="font-family:Helvetica,Arial,sans-serif">t1.(!</span>Ǝ<span style="font-family:Helvetica,Arial,sans-serif">t2.(t1 < t2 & a</span><sup>(t2)</sup><span style="font-family:Helvetica,Arial,sans-serif"> ) | (a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">)) [pull the negation outwards</span><span style="font-family:Helvetica,Arial,sans-serif">]</span></p><p><span style="font-family:Helvetica,Arial,sans-serif">= </span><span style="color:#202124; font-family:arial,sans-serif">∀</span><span style="font-family:Helvetica,Arial,sans-serif">t1.(</span>Ǝ<span style="font-family:Helvetica,Arial,sans-serif">t2.(t1 < t2 & a</span><sup>(t2)</sup><span style="font-family:Helvetica,Arial,sans-serif"> ) -> (a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">)) [by definition of the implication again</span><span style="font-family:Helvetica,Arial,sans-serif">]</span></p><p><span style="font-family:Helvetica,Arial,sans-serif">which is finally the result you wanted. In its core, the reason for that is that one part</span> of the inner term can be excluded from the bounds of the quantification of "t2", and due to the negation that arises from resolving the implication, this quantification symbol is flipped to an "Exists".</p><p>From a more "logical explanation" point you can argue that as follows:</p><p><span style="color:#202124; font-family:arial,sans-serif">∀</span><span style="font-family:Helvetica,Arial,sans-serif">t2.((t1 < t2 & a</span><sup>(t2)</sup><span style="font-family:Helvetica,Arial,sans-serif"> ) -> (a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">)) is true if either </span><span style="font-family:Helvetica,Arial,sans-serif">(a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">) holds (in this case the quantification is irrelevant) or if that is not the case, </span><span style="font-family:Helvetica,Arial,sans-serif">(t1 < t2 & a</span><sup>(t2)</sup><span style="font-family:Helvetica,Arial,sans-serif"> ) must be false (which then of course needs to be false for all time points "t2"). Thus if there exists a time point "t2" where </span><span style="font-family:Helvetica,Arial,sans-serif">(t1 < t2 & a</span><sup>(t2)</sup><span style="font-family:Helvetica,Arial,sans-serif"> ) is known to be true, this implies that </span><span style="font-family:Helvetica,Arial,sans-serif">(a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">) needs to hold, for the whole term to be true.</span></p><p><span style="font-family:Helvetica,Arial,sans-serif">This previous sentence is however the exact natural language definition of:</span></p><p>Ǝ<span style="font-family:Helvetica,Arial,sans-serif">t2.(t1 < t2 & a</span><sup>(t2)</sup><span style="font-family:Helvetica,Arial,sans-serif"> ) -> (a</span><sup>(t1)</sup>-><span style="font-family:Helvetica,Arial,sans-serif">b</span><sup>(t1)</sup><span style="font-family:Helvetica,Arial,sans-serif">)</span></p><p><span style="font-family:Helvetica,Arial,sans-serif">which explains the equivalence logically due to the explanation.</span></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3525/sept-2022-lo1-to-ltl?show=3532#a3532Fri, 10 Feb 2023 19:04:11 +0000Answered: CTL LTL Feb 2022 7b
https://q2a.cs.uni-kl.de/3517/ctl-ltl-feb-2022-7b?show=3518#a3518
<p>Do you mean this structure?</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=4947894413714421903" style="height:173px; width:211px"></p><p>The path s0->s1^omega satisfies [a SU FGb], but it does not satisfy [a SU Gb], which is no surprise since that path is the one given in the example solution. Why did you add the other state s2?</p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3517/ctl-ltl-feb-2022-7b?show=3518#a3518Wed, 08 Feb 2023 14:09:15 +0000Answered: CTL* February 16, 2022, 7e
https://q2a.cs.uni-kl.de/3462/ctl-february-16-2022-7e?show=3465#a3465
The formula !a&EGa cannot hold in any state since it is a contradiction. You can see that by unrolling EGa into a & EX EG a which then contradicts directly !a. Hence, S2 is simply false and cannot hold in any state.<br />
<br />
EGa holds in state s0, but not in state s1. Consider now E(F!a & Era) which is equivalent to (EF!a)&(EGa). This holds in state s0 since the path s0->s1^omega satisfies F!a and the path s0^omega satisfies EGa. Hence, s0 satisfies (EF!a)&(EGa), but s1 does not. Finally, abbreviate this formula by a new variable b which is therefore a label of s0, but not of s1, and consider the formula EGb. It clearly holds in s0, but not in s1, and therefore S1 holds in s0.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3462/ctl-february-16-2022-7e?show=3465#a3465Fri, 03 Feb 2023 05:53:59 +0000Answered: Set representation to ZDD
https://q2a.cs.uni-kl.de/3455/set-representation-to-zdd?show=3456#a3456
<p>To construct a ZDD, recall that a ZDD is a data structure to store a set of sets of some elements. For instance, the set of sets of integers {{2}, {3}, {2,3}} is stored this way:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=14240015273978188205" style="height:130px; width:450px"></p><p>For the ZDD of a propositional logic formula, we want to store the minterms. For the minterms which are represented as set of sets of variables {{a,b,c},{a,c},{a},{c},{}} and to this end, we first decompose the set of sets of states by variable a (see page 142 of the related chapter): </p><ul><li>a=1: {{b,c},{c},{}}<ul><li>b=1: {{c}}</li><li>b=0: {{c},{}}</li></ul></li><li>a=0: {{c},{}}<ul><li>b does not matter</li></ul></li></ul><div>and so on so get the ZDD</div><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=3642695250661273846" style="height:355px; width:194px"></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3455/set-representation-to-zdd?show=3456#a3456Thu, 02 Feb 2023 09:27:42 +0000Answered: restrict algorithm
https://q2a.cs.uni-kl.de/3453/restrict-algorithm?show=3454#a3454
The graph beta describes the care set. It is given as an input and is constructed by a particular application. For instance, for a transition system, the reachable states are of interest and the others don't care.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3453/restrict-algorithm?show=3454#a3454Wed, 01 Feb 2023 11:55:46 +0000Answered: Convert to FDD
https://q2a.cs.uni-kl.de/3451/convert-to-fdd?show=3452#a3452
<p>Not sure what you are doing. If you have to compute the FDD of a formula like (a ∨ ¬b) ∧ c, it is sufficient to compute the RMNF since that is the textual representation of the FDD.</p><pre> (a∨¬b)∧c
= ((0∨¬b)∧c) ⊕ a∧((0∨¬b)∧c⊕(1∨¬b)∧c)
= ¬b∧c ⊕ a∧(¬b∧c⊕c)
= ¬b∧c ⊕ a∧(b∧c)
= (¬0∧c) ⊕ b∧(¬0∧c⊕¬1∧c) ⊕ a∧((0∧c) ⊕ b∧(0∧c⊕1∧c))
= c ⊕ b∧c ⊕ a∧b∧c
From here, it should be easy to draw the FDD.</pre># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3451/convert-to-fdd?show=3452#a3452Wed, 01 Feb 2023 08:48:49 +0000Answered: zdd2fdd conversion
https://q2a.cs.uni-kl.de/3441/zdd2fdd-conversion?show=3442#a3442
<p>There is a similar question with an answer that should also help you: see <a rel="nofollow" href="https://q2a.cs.uni-kl.de/3413/fdd-to-zdd-09-2022-1d">https://q2a.cs.uni-kl.de/3413/fdd-to-zdd-09-2022-1d</a></p><p>But it is not difficult: ¬b⊕a&b&c is almost in DNF:</p><pre> ¬b⨁a&b&c
= b&(¬1⨁a&1&c) | ¬b&(¬0⨁a&0&c)
= b&(a&c) | ¬b&(1⨁0)
= a&b&c | ¬b
</pre><p>For the set representation of the ZDD, Davio composition is useless (it is used for FDDs). Instead, you need the full DNF where all minterms are listed. In the above DNF, we just have one minterm a&b&c and a cube ¬b that is to be expanded to four minterms:</p><pre> a&b&c | ¬b
= a&b&c | a&¬b | ¬a&¬b
= a&b&c | a&¬b&¬c | ¬a&¬b&¬c | a&¬b&c | ¬a&¬b&c
</pre><p>The latter gives us the set representation of the minterms:</p><p> {{a,b,c},{a},{},{a,c},{c}}</p><p>And now, we can draw the ZDD!</p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3441/zdd2fdd-conversion?show=3442#a3442Tue, 31 Jan 2023 09:27:54 +0000Answered: Zielonka - Qh
https://q2a.cs.uni-kl.de/3439/zielonka-qh?show=3440#a3440
<p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=12029553745687565924" style="height:407px; width:450px"></p><p>attr1({s0}) is the set of states where player 1 can enforce that state s0 is reached, no matter what player 0 will do. Player 1 controls the rectangled states, so all rectangled states that can reach s0 only through rectangled states belong to attr1({s0}). This way, we get s1,s2,s8, but s4 and s6 have to pass through states controlled by player 0, and unfortunately, s3 can always select the transition to s4 so that the states s3,s4,s5,s6,s7 do not belong to attr1({s0}). Hence, attr1({s0}) = {s0,s1,s2,s8}</p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3439/zielonka-qh?show=3440#a3440Mon, 30 Jan 2023 15:20:36 +0000Answered: Zielonka - Attr(Qh)
https://q2a.cs.uni-kl.de/3437/zielonka-attr-qh?show=3438#a3438
<p>attr0{Q) is the set of states where player 0 can enforce that a state in Q is reached, no matter what player 1 will do in the states controlled by player 1. The game graph you are discussing looks as follows:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=4402193131527584409" style="height:118px; width:600px"></p><p>attr0({s7}) = {s7} since for all other states, player 1 can select the transition s6->s5 to avoid that s7 will be reached. Note that all states except for s7 can only reach s7 by first visiting s6, but there the control is given to player 1, and player 1 may select the transition s6->s5. Hence, player 0 can only enforce reaching s7 when we are already in s7. </p><p>The game graph on page 160 looks as follows:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=7056827485847784225" style="height:128px; width:600px"></p><p>Here, attr1({s4}) = {s4} since we can reach s4 only from state s3 which is controlled by player 0. Player 0 may choose there however the transition s3->s2, so that s4 would not be reached. Hence, player 1 can only enforce reaching s4 when we are already in s4. </p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=14735630796166253461" style="height:139px; width:600px"></p><p>On slide 161 (see above), attr0({s1}) = {s0,s1,s5,s6} since states s2 and s3 cannot reach s1 at all, and therefore, player 0 cannot enforce reaching s1 from there. However, player 0 can enforce this from the other states which are therefore in the attractor set.</p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3437/zielonka-attr-qh?show=3438#a3438Mon, 30 Jan 2023 13:37:01 +0000Answered: Variable ordering
https://q2a.cs.uni-kl.de/3417/variable-ordering?show=3418#a3418
Determining the optimal variable ordering is very difficult (NP-complete), so that we just use heuristics. I have used the sifting heuristic described in the course to determine the very good variable ordering for the mentioned BDD. That reduces the overall work a lot as you can see, and that holds also when you make the case distinctions of the BDD to determine all transitions. In general, determining an optimal variable ordering is however not that easy, so you have to make an "educated guess".# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3417/variable-ordering?show=3418#a3418Thu, 26 Jan 2023 17:54:16 +0000Answered: Omega automata to LTL
https://q2a.cs.uni-kl.de/3409/omega-automata-to-ltl?show=3412#a3412
<p>You have to consider the automaton and have to determine the sequences that are accepted by the automaton. </p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=10275966652424914470" style="height:212px; width:300px"></p><p>It is a deterministic FG automaton where we finally have to repeat the self loop on q2. Hence, we start in the initial state q0 and wait there for an occurrence of "a": As long as !a holds, we wait for "a" in q1, and if "a" is there, we switch to q2. After the first point of time where "a" holds, we switch between states q2 and q3 where only b matters. To satisfy the acceptance condition, we finally have to remain in state q2.</p><p>This can be expressed in different ways in LTL. For instance, we could write [(F G !b) SW a] or alternatively (F a) & (F G !b).</p><p>So, there is no general formula that you can apply here, but you need to understand what the automaton wants and you then have to describe that in LTL (in your words/symbols).</p><p>Having written this, I should also add that for non counting automata (but not for others), there are also algorithms that can translation the noncounting automaton to an LTL formula, but that is beyond the scope of the lecture. </p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3409/omega-automata-to-ltl?show=3412#a3412Wed, 25 Jan 2023 18:53:12 +0000Answered: NDET-F State transition
https://q2a.cs.uni-kl.de/3408/ndet-f-state-transition?show=3411#a3411
<p>Well, there are many ways how to solve that exercise. The task was to generate an automaton that is equivalent to [a SU b] with an acceptance condition of the form Fq. Following the semantics of [a SU b], it holds if there is a point of time where b holds and until then a must hold. Thus, we may start in a state {} with a self-loop for a&!b and a transition to state {q} when b holds. Clearly, we have to reach state {q}. There is no transition for !a&!b in state {} since then [a SU b] would be false, so that transition is missing intentionally. Once reached state {q}, nothing else has to be demanded, but we must consume further inputs which are don't cares. Hence, there is a self-loop on {q} for any input.</p><p>We can now write down the transitions as single midterms</p><ul><li><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000001px">¬q & a & ¬b & ¬q'</span></li><li><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000001px"><span style="font-size:14.000001px">¬q & b & q'</span></span></li><li><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000001px"><span style="font-size:14.000001px">q & q'</span></span></li></ul><div><span style="font-family:Helvetica, Arial, sans-serif"><span style="font-size:14.000001px">The disjunction of these yields the above transition relation. </span></span></div># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3408/ndet-f-state-transition?show=3411#a3411Wed, 25 Jan 2023 18:44:13 +0000Answered: LTL - SNF -State transition
https://q2a.cs.uni-kl.de/3407/ltl-snf-state-transition?show=3410#a3410
I have added a conjunction with !q2 since we want to derive the transition relation for the states where !q2 holds. Note that phi&!q2=phi[q2<-0]&!q2 holds, where phi[q2<-0] denotes the formula phi where all occurrences of q2 are replaced with 0.<br />
<br />
For the same reason, (q0 <-> a | a & Xq0) & !a is equivalent to (q0 <-> 0 | 0 & Xq0) & !a which is again equivalent to (q0 <-> 0) & !a.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3407/ltl-snf-state-transition?show=3410#a3410Wed, 25 Jan 2023 18:35:54 +0000Answered: SNF for LTL state transition
https://q2a.cs.uni-kl.de/3400/snf-for-ltl-state-transition?show=3402#a3402
<p>Well, using the teaching tool, I get the following SNF which is not as nice as the BDD since there are some sub-formulas that can be shared:</p><ul style="box-sizing:border-box; font-family:OpenSans,Arial,sans-serif; font-size:14px; list-style-position:outside; margin-bottom:10px; margin-top:0px; padding-left:1.2em; padding-right:0px"><li style="box-sizing: border-box;"><pre style="box-sizing: border-box; overflow: auto; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; font-size: 13px; padding: 9.5px; margin-top: 0px; margin-bottom: 10px; line-height: 1.42857; word-break: break-all; background-color: rgb(245, 245, 245); border: 1px solid rgb(204, 204, 204); border-radius: 4px;"> (q ? (b ? false
: (Xq ? (a ? (Xp ? true
: false)
: (p ? (Xp ? true
: false)
: (Xp ? false
: true)))
: false))
: (a ? (Xp ? true
: false)
: (p ? (Xp ? true
: false)
: (Xp ? false
: true))))
</pre></li></ul><p></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3400/snf-for-ltl-state-transition?show=3402#a3402Wed, 25 Jan 2023 12:17:12 +0000Answered: LTL state transition
https://q2a.cs.uni-kl.de/3397/ltl-state-transition?show=3398#a3398
<p>The truth table would have 64 entries for the variables p,q,a,b,Xp,Xq which is not recommended here. Instead, I show you a BDD with the optimal variable ordering which is quite small: </p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=9736145197991618874" style="height:522px; width:200px"></p><p>We may also read a DNF from this diagram:</p><pre> !Xp&!p&!a&!q |
!Xp&!p&!a&Xq&!b&q |
Xp&p&!a&!q |
Xp&p&!a&Xq&!b&q |
Xp&a&!q |
Xp&a&Xq&!b&q</pre># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3397/ltl-state-transition?show=3398#a3398Wed, 25 Jan 2023 09:43:20 +0000Answered: LTL model checking - state transition
https://q2a.cs.uni-kl.de/3392/ltl-model-checking-state-transition?show=3395#a3395
<p>I get the following:</p><pre> (q0 <-> a | a & Xq0) & (q1 <-> a | ¬a & Xq1) & (q2 <-> q1 | q0 & Xq2) & !q2
= (q0 <-> a | a & Xq0) & (q1 <-> a | ¬a & Xq1) & !(q1 | q0 & Xq2) & !q2
= (q0 <-> a | a & Xq0) & (q1 <-> a | ¬a & Xq1) & !q1 & !(q0 & Xq2) & !q2
= (q0 <-> a | a & Xq0) & !(a | ¬a & Xq1) & !q1 & !(q0 & Xq2) & !q2
= (q0 <-> a | a & Xq0) & !a & !(¬a & Xq1) & !q1 & !(q0 & Xq2) & !q2
= (q0 <-> 0) & !a & !Xq1 & !q1 & !(q0 & Xq2) & !q2
= !q0 & !a & !Xq1 & !q1 & !(0 & Xq2) & !q2
= !q0 & !a & !Xq1 & !q1 & !q2</pre># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3392/ltl-model-checking-state-transition?show=3395#a3395Wed, 25 Jan 2023 09:29:58 +0000Answered: LTL Model checking
https://q2a.cs.uni-kl.de/3393/ltl-model-checking?show=3394#a3394
<p>About 1): adding each fairness constraint obtained by the simple translation from LTL to automata (shown on pages 83-84) is also correct. However, that will always generate a nondeterministic generalized Büchi automaton which is hard to determinize. Thus, we often wish to use as few of these constraints as possible, and if we are lucky, none of them is required at all. Pages 92-94 therefore first explain that we can neglect the fairness constraint for positive occurrences of weak temporal operators and we can also neglect the fairness constraint for negative occurrences of strong temporal operators. Another improvement is given on slides 115-116 where instead of fairness constraints, one may use coBüchi constraints in some cases. That may enable simple determinization procedures.</p><p>About 2): The formula ¬q0 & ¬q1 & a & ¬b & ¬q0' & ¬q1' describes only a single transition which is a self-loop on state {} with input {a}. Hint: you can use <a href="https://es.cs.uni-kl.de/tools/teaching/SymbolicStateTrans.html" rel="nofollow">https://es.cs.uni-kl.de/tools/teaching/SymbolicStateTrans.html</a> to quickly generate state transition diagrams. In general, you have to consider the satisfying assignments of the formula, which means to compute its truth table or a BDD or something where you can read these from.</p><div></div># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3393/ltl-model-checking?show=3394#a3394Wed, 25 Jan 2023 09:19:47 +0000Answered: Ndet automata
https://q2a.cs.uni-kl.de/3387/ndet-automata?show=3388#a3388
I don't understand your first question, maybe you can make that clearer? For the second question, the answer is found on page 86 of the automaton chapter: An automaton is totally defined if for every state and every input, there is a transition, otherwise, the automaton is partially defined. Partially defined automata have therefore states where they cannot react to one of the inputs since there is no transition for the input.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3387/ndet-automata?show=3388#a3388Tue, 24 Jan 2023 18:51:28 +0000Answered: I got your explanaition. Can you please give me hints to approach these type of question in exam.
https://q2a.cs.uni-kl.de/3380/explanaition-please-hints-approach-these-type-question-exam?show=3382#a3382
I am afraid that there are no general hints for such exercises. You need some experience with the formulas and have to know a couple of equivalences. The equivalences you need should be listed in the slides, and you can put some on your cheat sheet for the exam. The experience comes with solving many exercises. If you do both, you should be sufficiently prepared for the exam.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3380/explanaition-please-hints-approach-these-type-question-exam?show=3382#a3382Mon, 23 Jan 2023 08:34:50 +0000Answered: LTL to LTL
https://q2a.cs.uni-kl.de/3378/ltl-to-ltl?show=3379#a3379
<p>Your solution is not correct. You are right that LTL formulas must not have path quantifiers, so your formulas are LTL formulas. However, the formulas are not equivalent to each other:</p><p>Just consider a transition system with a single state with a self-loop where a holds but where b is false. Then, [a WU G F b] holds on the single path of that structure while both [a SU b] and G b are false.</p><p>Also for the second equivalence, [true SU a] is equivalent to F a, but not to G b. You can check the equivalence of LTL formulas with <a rel="nofollow" href="https://es.cs.uni-kl.de/tools/teaching/TemporalLogicProver.html">https://es.cs.uni-kl.de/tools/teaching/TemporalLogicProver.html</a></p><p></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3378/ltl-to-ltl?show=3379#a3379Sun, 22 Jan 2023 11:51:47 +0000Answered: local model checking
https://q2a.cs.uni-kl.de/3374/local-model-checking?show=3375#a3375
<p>Well, the loops in the proof trees in local model checking are always worth a discussion, even though everything is found on the slides, so that I just cite the related slides below and comment on them. Have a look at the example below where we just have a transition system with a single state where "a" holds, but "b" is false (taken from slide 107 of the mu-calculus chapter).</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=9668841035650042929" style="height:377px; width:388px"></p><p>The proof tree for the formula nu x.(b | a&<>x) is shown above and as can be seen, it has a loop. Note that the formula is equivalent to the CTL formula E[a WU b] and that the least fixpoint mu x.(b | a&<>x) is equivalent to the CTL formula E[a SU b] (note that the Kripke structure has no deadend states which simplifies these equivalences).</p><p>Using global model checking (or just reasoning with the semantics of the formulas), we can see that E[a WU b] holds on the state while E[a SU b] does not hold there: For the weak until, it is allowed to always have "a" true and never reach a state where "b" holds, but the strong until demands that a state where "b" holds is finally reached and until that time, only states where "a" holds must be visited.</p><p>However, the equivalent mu-calculus formulas nu x.(b | a&<>x) and mu x.(b | a&<>x) generate similar proof trees (but the result for the least fixpoint is different!). Hence, we must read that proof tree differently for least and greatest fixpoint formulas. </p><p>As explained on slide 108, states closing a loop satisfy greatest but not least fixpoint formulas. Slide 109 explains why that is so, and to keep the story short: for least fixpoints, we try to choose as few states as possible to satisfy them, while for greatest fixpoints, we try to choose as many states as possible to satisfy them. In case of loops, we have the freedom to choose, since those states satisfy the fixpoint equation.</p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3374/local-model-checking?show=3375#a3375Thu, 19 Jan 2023 10:25:06 +0000Answered: CTL* Sept 2022 Problem 8a
https://q2a.cs.uni-kl.de/3361/ctl-sept-2022-problem-8a?show=3362#a3362
<p>You are wondering about this solution:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=18264186119469936014" style="height:140px; width:431px"></p><p>S2 is a CTL formula so that it is easy to compute the states that satisfy S2: AFp holds exactly on s2 while AFq holds exactly on s1, hence, their disjunction holds exactly on states {s1,s2}. AFp does not hold in s0 since there is a path s0->s2->s2->... where p never holds, and for the analog reason, AFq does not hold in s0. </p><p>The formula AF(p|q) holds in the states where all outgoing infinite paths finally reach a state where p|q holds. The formula p|q holds exactly in states {s1,s2} so that these states at least also satisfy AF(p|q). AF(p|q) also holds in s0 since all paths leaving s0 must finally reach s1 or s2, hence, states where p|q holds.</p><p></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3361/ctl-sept-2022-problem-8a?show=3362#a3362Sat, 14 Jan 2023 13:04:00 +0000Answered: How can I access Summer 2022 exercise sheet?
https://q2a.cs.uni-kl.de/3347/how-can-i-access-summer-2022-exercise-sheet?show=3349#a3349
I suppose you are talking about VRS? Except some slight differences which mainly target errors in the exercises the content should be the same. The only thing that is really new in the 2022 sheets is the Zielonka-algorithm which was also asked in the exam, so if you want to prepare for the next exam you should take a look at the previous exam and learn the algorithm.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3347/how-can-i-access-summer-2022-exercise-sheet?show=3349#a3349Tue, 03 Jan 2023 12:29:54 +0000Answered: Thesis topic struggles
https://q2a.cs.uni-kl.de/3326/thesis-topic-struggles?show=3327#a3327
<p>The faculty has to provide a topic for a thesis for each one of the students. If you cannot find one on your own, you have to consult the Prüfungsausschuss (<a rel="nofollow" href="https://www.informatik.uni-kl.de/organisation/ausschuesse/pra/">https://www.informatik.uni-kl.de/organisation/ausschuesse/pra/</a>) who will then have to find a topic for you.</p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3326/thesis-topic-struggles?show=3327#a3327Mon, 07 Nov 2022 14:19:10 +0000Answered: LTL Model checking
https://q2a.cs.uni-kl.de/2984/ltl-model-checking?show=2985#a2985
Positive and negative occurrences essentially means under an even and odd number of negations, i.e., in !a&b|!(!c&d) the variables a and d have negative occurrences while b and c have positive ones.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/2984/ltl-model-checking?show=2985#a2985Thu, 18 Aug 2022 12:21:23 +0000Answered: Simulation and Bisimulation
https://q2a.cs.uni-kl.de/2981/simulation-and-bisimulation?show=2982#a2982
This question has already been answered before: <a href="https://q2a.cs.uni-kl.de/2787/query-regarding-simulation-and-bisimulation" rel="nofollow">https://q2a.cs.uni-kl.de/2787/query-regarding-simulation-and-bisimulation</a><br />
<br />
If s1 does not have successors, nothing has to be checked, and SIM2 holds. If s1 does have successors, but s2 does not have successors, SIM2 does obviously not hold.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/2981/simulation-and-bisimulation?show=2982#a2982Thu, 18 Aug 2022 08:17:28 +0000Answered: Doubt regarding converting to CTL
https://q2a.cs.uni-kl.de/2968/doubt-regarding-converting-to-ctl?show=2969#a2969
Looks fine to me, it is an alternative solution.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/2968/doubt-regarding-converting-to-ctl?show=2969#a2969Wed, 17 Aug 2022 11:03:14 +0000Answered: Exam 2020.02.19
https://q2a.cs.uni-kl.de/2960/exam-2020-02-19?show=2962#a2962
<div class="page" title="Page 51" style="caret-color: rgb(0, 0, 0); color: rgb(0, 0, 0);"><div class="layoutArea"><div class="column"><p>FGφ ∨ FGψ is not equivalent to FG(φ ∨ ψ), but we can reduce the disjunction using a new state variable as shown on slide 51 of the related chapter. </p></div></div></div># Study-Organisation (Master)https://q2a.cs.uni-kl.de/2960/exam-2020-02-19?show=2962#a2962Tue, 16 Aug 2022 08:35:10 +0000Answered: Query Regarding LO2
https://q2a.cs.uni-kl.de/2942/query-regarding-lo2?show=2945#a2945
You have mixed up the weak and strong until operators. In the exam problem, it was a weak until, while your solution considers a strong until.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/2942/query-regarding-lo2?show=2945#a2945Mon, 15 Aug 2022 13:34:19 +0000Answered: Omega automaton to LO2
https://q2a.cs.uni-kl.de/2937/omega-automaton-to-lo2?show=2944#a2944
<p>There is not really a need to convert the automaton to an existential one, but if so, you should not forget about negating the acceptance condtion, i.e.,</p><p> A∀({q, p}, ¬q ∧ ¬p,(Xq ↔ (¬q ∧ ¬a)) ∧ (Xp ↔ (¬p → q)), GFp) = <br> !A∃({q, p}, ¬q ∧ ¬p,(Xq ↔ (¬q ∧ ¬a)) ∧ (Xp ↔ (¬p → q)), !GFp)</p><p>Then, you could proceed as follows (there was a mistake in your solution):</p><pre> !∃ p,q.
¬q[0]∧¬p[0] ∧
(∀t.
(q[t+1] ↔ (¬q[t] ∧ ¬a[t])) ∧
(p[t+1] ↔ (¬p[t] → q[t])))
∧ !∀t1.∃t2. t1<t2 ∧ p[t2]
</pre><p>which is already LO2, but if we want to push the negation inwards, we get</p><pre> ∀ p,q.
¬q[0]∧¬p[0] ∧
(∀t.
(q[t+1] ↔ (¬q[t] ∧ ¬a[t])) ∧
(p[t+1] ↔ (¬p[t] → q[t])))
→ ∀t1.∃t2. t1<t2 ∧ p[t2]</pre><p>You could directly write down the above from the initial formula. </p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/2937/omega-automaton-to-lo2?show=2944#a2944Mon, 15 Aug 2022 13:30:51 +0000Answered: LTL to LO1
https://q2a.cs.uni-kl.de/2938/ltl-to-lo1?show=2939#a2939
<p>You can just follow the semantics of the formulas, but the way to reduce the operators to Until operators to apply the algorithm on the slide should also work fine. If you move in the negation symbol (which you don't have to), you should get the following:</p><p style="box-sizing: border-box; margin: 0px 0px 10px; font-family: OpenSans, Arial, sans-serif; font-size: 14px;">(∃t1. t0≤t1 ∧ b[t1]) ∧ (∀t1. (t0≤t1 → ¬a[t1]))</p><p>You can compute that also with <a href="https://es.cs.uni-kl.de/tools/teaching/TemporalLogicProver.html" rel="nofollow">https://es.cs.uni-kl.de/tools/teaching/TemporalLogicProver.html</a></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/2938/ltl-to-lo1?show=2939#a2939Mon, 15 Aug 2022 12:21:22 +0000Answered: Doubt regarding Fourier-Motzkin
https://q2a.cs.uni-kl.de/2931/doubt-regarding-fourier-motzkin?show=2933#a2933
If you solve the inequalities for x1, you will see that the left hand sides are minus infinity, so that x1 does not have lower bounds. That is a preferable case since then we can remove all equations where x1 occurs (see slides 85-90).# Study-Organisation (Master)https://q2a.cs.uni-kl.de/2931/doubt-regarding-fourier-motzkin?show=2933#a2933Mon, 15 Aug 2022 10:00:33 +0000Answered: How to find transition relation for automaton
https://q2a.cs.uni-kl.de/2925/how-to-find-transition-relation-for-automaton?show=2926#a2926
I think that you already wrote the transition relations on the paper next to the automaton, didn' you? Maybe you just have to think of a more efficient encoding of the states.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/2925/how-to-find-transition-relation-for-automaton?show=2926#a2926Mon, 15 Aug 2022 08:28:17 +0000Answered: LO2 to omega Automaton
https://q2a.cs.uni-kl.de/2923/lo2-to-omega-automaton?show=2924#a2924
You can find these automata on slide 30 of the related chapter.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/2923/lo2-to-omega-automaton?show=2924#a2924Sun, 14 Aug 2022 20:26:05 +0000Answered: Doubt regarding Automaton
https://q2a.cs.uni-kl.de/2917/doubt-regarding-automaton?show=2919#a2919
The class NDetF is more expressive than the class DetF, hence, there are NDetF automata that cannot be converted to a DetF automaton. This is explained in the slides and also examples were given where the subset construction computes an automaton that is not equivalent to the given NDetF automaton. Sometimes making the NDetF automaton gives an equivalent automaton, but not always. So, you have to check whether the automaton you got with the sink state is equivalent to the original one. If so, you can apply the subset construction since that construction is safe for totally defined NDetF automata, but not for all the others.<br />
<br />
If you add a sink state to the automaton you described, it will accept also any word a(!a)(!a)... which are words that are not accepted by the original automaton. Hence the subset construction does not work here. <br />
<br />
The alternative to convert NDetF to NDetFG and then applying the breakpoint construction is always correct, thus maybe preferable, but you get more states by the breakpoint construction and the conversion from NDetF to NDetFG also introduces further states.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/2917/doubt-regarding-automaton?show=2919#a2919Sun, 14 Aug 2022 09:15:41 +0000Answered: omega automaton
https://q2a.cs.uni-kl.de/2911/omega-automaton?show=2912#a2912
<p>If you use <span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">Fϕ = A∃ ({q}, ¬q, q ′ ↔ q ∨ ϕ, FGq), you get some trouble. You may negate both sides to get </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">G¬ϕ = ¬Fϕ = </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">¬</span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">A∃ ({q}, ¬q, q ′ ↔ q ∨ ϕ, FGq) </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">= </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">A∃ ({q}, ¬q, q ′ ↔ q ∨ ϕ, </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">¬</span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">FGq), but that gives you a deterministic Büchi automaton. </span></p><p><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">Why not converting G</span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">¬b to a co-Büchi automaton using </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">G</span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">¬b = </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">A∃ ({q}, q, q′ ↔ q & </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">¬b </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">, FGq)? Then, the rest is easy:</span></p><p><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">FGa∧G¬b = </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">FGa ∧ </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">A∃ ({q}, q, q′ ↔ q & </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">¬b </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">, FGq) = </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">A∃ ({q}, q, q′ ↔ q & </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">¬b </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">,</span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">FGa∧</span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">FGq)</span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px"> = </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">A∃ ({q}, q, q′ ↔ q & </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">¬b </span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">,</span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">FG(a∧</span><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">q))</span></p><p><span style="font-family:Helvetica,Arial,sans-serif; font-size:14.000000953674316px">Combin</span></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/2911/omega-automaton?show=2912#a2912Sun, 14 Aug 2022 08:39:02 +0000Answered: Symbolic Computation
https://q2a.cs.uni-kl.de/2908/symbolic-computation?show=2909#a2909
<p>See slides 67-71 of chapter 4 (transition systems for the explanations of the symbolic predecessor and successor computations. Also, the teaching tool on <a href="https://es.cs.uni-kl.de/tools/teaching/SymbolicStateTrans.html" rel="nofollow">https://es.cs.uni-kl.de/tools/teaching/SymbolicStateTrans.html</a> can help you to check your computations. For the above example, it computes</p><pre style="box-sizing: border-box; overflow: auto; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; font-size: 13px; padding: 9.5px; margin-top: 0px; margin-bottom: 10px; line-height: 1.42857; word-break: break-all; background-color: rgb(245, 245, 245); border: 1px solid rgb(204, 204, 204); border-radius: 4px;">∃next(p).∃next(q).(next(p)|o&a&!q<->next(q)<->p)&(next(p)<->!next(q))
= ∃next(q).!next(q)&(p<->next(q))|(p<->!q&a&o<->next(q))&next(q)
= !p|(p<->!q&a&o)</pre># Study-Organisation (Master)https://q2a.cs.uni-kl.de/2908/symbolic-computation?show=2909#a2909Sat, 13 Aug 2022 18:48:23 +0000Answered: Bisimulation
https://q2a.cs.uni-kl.de/2903/bisimulation?show=2904#a2904
It depends: If there is no simulation relation, then there is also no bisimulation relation since the bisimulation relation would also be a simulation relation. Hence, if there is no simulation relation, you don't have to compute the greatest bisimulation relation since it follows immediately that there is no bisimulation relation.<br />
<br />
If there is no bisimulation relation, there may still be a simulation relation, and even K1 may simulate K2 and K2 may simulate K1 in that case (see slide 42 for such an example).<br />
<br />
If there is a bisimulation relation, it is also a simulation relation, but not necessarily the greatest one. So, you would still have to compute the greatest one that must then exist.<br />
<br />
The particular intermediate steps cannot really be reused, except for the initial relation where state pairs with the same labels are constructed. That one is the same in these cases. Also the simulation diagrams are the same for all computations, but they are used in different ways.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/2903/bisimulation?show=2904#a2904Sat, 13 Aug 2022 17:11:04 +0000Answered: Dead states, Reachable States, Initial States , Unreachable States
https://q2a.cs.uni-kl.de/2898/states-reachable-states-initial-states-unreachable-states?show=2899#a2899
<p>When using the teaching tool, you get the following result:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=1351999862494780177" style="height:661px; width:400px"></p><p>It also shows you the initial, reachable, dead, and finally dead states. The definitions of these sets of states can be found on slide 9 of chapter 4 (transition systems). Initial states can be dead states, and initial states are always reachable (by definition). </p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/2898/states-reachable-states-initial-states-unreachable-states?show=2899#a2899Sat, 13 Aug 2022 09:54:24 +0000Answered: FDD to ROBDD
https://q2a.cs.uni-kl.de/2894/fdd-to-robdd?show=2895#a2895
<p>Sure, you can proceed completely analogously:</p><ol><li>compute the set representations of all nodes of the FDD</li><li>convert the set representations to the Reed Muller Normal Form (RMNF)</li><li>convert the obtained RMNF to Shannon normal form to get the BDD</li></ol><div></div># Study-Organisation (Master)https://q2a.cs.uni-kl.de/2894/fdd-to-robdd?show=2895#a2895Sat, 13 Aug 2022 08:50:52 +0000Restrict Algorithm Exercise Sheet 3
https://q2a.cs.uni-kl.de/2891/restrict-algorithm-exercise-sheet-3
<p></p><p>Hi, I was going through the Restrict Algorithm. I am bit confused about the rules taken below. As per the Restrict Algorithm : <span style="color:#2ecc71"><span style="font-family:"Helvetica Neue"; font-size:13px">Restrict(Apply(</span><span style="font-family:"Apple Symbols"; font-size:13px; font-stretch:normal; line-height:normal">∨</span><span style="font-family:"Helvetica Neue"; font-size:13px">, β1 , β0 ), φ)</span><span style="font-family:"Helvetica Neue"; font-size:13px"> </span><span style="font-family:"Helvetica Neue"; font-size:13px">ifD(xφ)<D(xβ)</span><span style="font-family:"Apple Symbols"; font-size:13px; font-stretch:normal; line-height:normal">∧</span></span><span style="font-family:"Helvetica Neue"; font-size:13px"><span style="color:#2ecc71"> β0,β1!=BDD(0)</span>, </span></p><p><span style="font-family:"Helvetica Neue"; font-size:13px">β1is the positive cofactor and β0 is the negative cofactor. But in the below it is taken as </span><span style="color:#e74c3c"><strong style="caret-color:#000000; font-family:OpenSans; font-size:17pt; font-weight:700">Restrict</strong><span style="caret-color:#000000; font-family:OpenSans; font-size:17pt">(N_15,N_23) = </span><strong style="caret-color:#000000; font-family:OpenSans; font-size:17pt; font-weight:700">Restrict</strong></span><span style="caret-color:#000000; font-family:OpenSans; font-size:17pt"><span style="color:#e74c3c">(OR(N_5,N_12),N_23)</span>, which is </span><span style="font-family:"Helvetica Neue"; font-size:small"> </span> <span style="font-family:"Helvetica Neue"; font-size:13px">Restrict(Apply(</span><span style="font-family:"Apple Symbols"; font-size:13px; font-stretch:normal; line-height:normal">∨</span><span style="font-family:"Helvetica Neue"; font-size:13px">, β0 , β1 ), φ)</span><span style="font-family:Helvetica Neue; font-size:small"> ? Is there any purpose to take like that (toggling </span><span style="font-family:"Helvetica Neue"; font-size:13px">β0</span><span style="font-family:"Helvetica Neue"; font-size:13px"> and β1)</span><span style="font-family:"Helvetica Neue"; font-size:small">? Could you please help me to solve the issue?</span></p><p></p><p></p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=17579550556139795462" style="height:151px; width:300px"><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=469053271676908973" style="height:141px; width:300px"></p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=3150719765019085832" style="height:144px; width:400px"><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=5855917912130934524" style="height:146px; width:300px"></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/2891/restrict-algorithm-exercise-sheet-3Fri, 12 Aug 2022 15:45:30 +0000