[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: VRS Exam in Winter Semester 2023/24
https://q2a.cs.uni-kl.de/3927/vrs-exam-in-winter-semester-2023-24?show=3928#a3928
<p>Hello,</p><p>you can find all exam dates on</p><p><a href="https://www.kis.uni-kl.de/campus/all/subfields.asp?field=Pr%FCfungen&tguid=0x3E97C1E01A714B9F9C0BEE5AB4FFE5FC" rel="nofollow">https://www.kis.uni-kl.de/campus/all/subfields.asp?field=Pr%FCfungen&tguid=0x3E97C1E01A714B9F9C0BEE5AB4FFE5FC</a></p><p>In particular, you can find the exam date of VRS which is</p><p>Wednesday, February 14th, 2024, 08:30 - 11:00, 42-115</p><div></div># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3927/vrs-exam-in-winter-semester-2023-24?show=3928#a3928Mon, 18 Dec 2023 08:54:48 +0000Answered: Fourier Doubt
https://q2a.cs.uni-kl.de/3914/fourier-doubt?show=3916#a3916
Yes, you can select any value in the determined interval. For the last variable that is left, we have already such an interval determined by the greatest of the lower bounds and the least of the upper bounds.<br />
<br />
Once determined such a value, you get another interval in the same way for the next variable, and so on. In particular, you can thereby select integer values if there is an integer solution which makes Fourier-Motzkin not more difficult for integers than for reals. Even more, you can also handle inequalities with < instead of <= which is not possible with Simplex.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3914/fourier-doubt?show=3916#a3916Mon, 28 Aug 2023 15:09:36 +0000Answered: omega automaton
https://q2a.cs.uni-kl.de/3910/omega-automaton?show=3911#a3911
You can list all transitions as minterms which results in a full DNF of the transition relation which is no better than the explicit listing of the transitions (thus not making use of the symbolic representation). You have to use inputs as well for doing so, and that can be done for all automata. As the state transition diagram shown has wildcard * transitions, you better use them also instead of listing all input combinations.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3910/omega-automaton?show=3911#a3911Sun, 27 Aug 2023 12:08:46 +0000Answered: Omega automaton transition relation
https://q2a.cs.uni-kl.de/3892/omega-automaton-transition-relation?show=3898#a3898
Well, the simplest way is that you would have to list all transitions as minterms of a DNF. It would start like this:<br />
<br />
!p&!q&!Xp&!Xq | !p&!q&!Xp&Xq | ...<br />
<br />
You could generate the associated Kripke structure, but that is just more work and you will get the same formula as the one above. So, that is not useful.<br />
<br />
The acceptance condition is the set of gray states (I guess) which is<br />
<br />
p&q<br />
<br />
but from the diagram, we don't know whether that is a safety, liveness or whatever automaton.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3892/omega-automaton-transition-relation?show=3898#a3898Sat, 26 Aug 2023 16:59:03 +0000Answered: Correctness of sequent calculus
https://q2a.cs.uni-kl.de/3890/correctness-of-sequent-calculus?show=3894#a3894
<p>The rules used in the table are</p><ul><li>a<->b := a&b | !a&!b (for the left)</li><li>a<->b := (a->b) &| (b->a) (for the right)</li><li>Each one of these rules branches into two subgoals, why do you think that there are four? </li></ul><p></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3890/correctness-of-sequent-calculus?show=3894#a3894Sat, 26 Aug 2023 16:18:39 +0000Answered: Sequent Calculus
https://q2a.cs.uni-kl.de/3885/sequent-calculus?show=3886#a3886
We have introduced operators other than negation, conjunction and disjunction as macros. You must therefore expand them to apply the rules of the sequent calculus. Apart from that, you should not make simplifications, since otherwise, you may already solve the problem without using sequent calculus at all. The above formula is however quite difficult for the sequent calculus (I mean to handle manually).# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3885/sequent-calculus?show=3886#a3886Sat, 26 Aug 2023 14:01:47 +0000Answered: Omega automaton determinisation
https://q2a.cs.uni-kl.de/3876/omega-automaton-determinisation?show=3879#a3879
For NDetG -> DetG, you can always use the subset construction after removing the unsafe states. <br />
<br />
For NDetF, that is not always possible, at least it works for totally defined automata, and sometimes also for others, which is however not that easy to decide. The safe way for NDetF is therefore to convert it to NDetFG and to use the breakpoint construction to get a DetFG automaton. Note that some NDetF automata do not have equivalent DetF automata at all.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3876/omega-automaton-determinisation?show=3879#a3879Sat, 26 Aug 2023 09:36:23 +0000Answered: Fourier-Motzkin doubt
https://q2a.cs.uni-kl.de/3874/fourier-motzkin-doubt?show=3875#a3875
It is one of the advantages of Fourier-Motzkin to find integer solutions much easier. Once, the variables are eliminated, we backtrack and can thereby choose a value for each variable of the determined interval for that variable. If there is an integer value possible, pick it, otherwise, there is no integer solution.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3874/fourier-motzkin-doubt?show=3875#a3875Sat, 26 Aug 2023 09:30:51 +0000Answered: BDD to ZDD conversion
https://q2a.cs.uni-kl.de/3861/bdd-to-zdd-conversion?show=3863#a3863
What you essentially suggest is to convert the BDD to a FDD and then to a ZDD. I doubt that this is simpler in general. <br />
<br />
However, why not undoing the BDD elimination rule to get a non-reduced BDD and then applying the elimination rule of ZDDs? That can also be done on subtrees first to keep the complexity under control.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3861/bdd-to-zdd-conversion?show=3863#a3863Sat, 26 Aug 2023 08:00:21 +0000Answered: FDD2BDD algorithm doubt
https://q2a.cs.uni-kl.de/3846/fdd2bdd-algorithm-doubt?show=3858#a3858
The algorithm always takes the cofactors, regardless which variable is their root. So, in that case, you just have the leaf node 0.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3846/fdd2bdd-algorithm-doubt?show=3858#a3858Fri, 25 Aug 2023 20:52:25 +0000Answered: Zielonka attractors
https://q2a.cs.uni-kl.de/3850/zielonka-attractors?show=3854#a3854
<p>s1 is a deadend state, and the attractors are defined with modal operators ⟨A⟩ and ⟨B⟩ as follows:</p><ul><li> attrA(φ) := μx.(φ ∨ ⟨A⟩x) </li><li> attrB(φ) := μx.(φ ∨ ⟨B⟩x)</li><li> ⟨A⟩φ := A ∧ <>φ ∨ B ∧ []φ = (A=><>φ|[]φ)</li><li> ⟨B⟩φ := A ∧ []φ ∨ B ∧ <>φ = (A=>[]φ|<>φ)</li></ul><p>Since we compute least fixpoints, we start with the empty set of states. Now, if φ=false, then we have</p><ul><li> ⟨A⟩false := A ∧ <>false ∨ B ∧ []false = B ∧ dead</li><li> ⟨B⟩false := A ∧ []false ∨ B ∧ <>false = A ∧ dead</li></ul><p>Hence, the attractors also collect deadend states controlled by the other player (see also page 145 of VRS-05-MuCalculus). This is correct, since if a player cannot choose a transition (since there is none), then the player will lose the game.</p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3850/zielonka-attractors?show=3854#a3854Fri, 25 Aug 2023 19:13:26 +0000Answered: FG automaton
https://q2a.cs.uni-kl.de/3837/fg-automaton?show=3842#a3842
The equivalence [a SU b] = Aexists({q},1, q<->b|a&next(q), q & FG!q) is not valid: Look, for all points of time, you may have a=0, b=1 and q=1. Then, [a SU b] is always true, but this is not an accepting run of the automaton on the right hand side. Why do you think that the two formulas are equivalent?# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3837/fg-automaton?show=3842#a3842Fri, 25 Aug 2023 16:24:04 +0000Answered: FDD2BDD algorithm
https://q2a.cs.uni-kl.de/3838/fdd2bdd-algorithm?show=3841#a3841
<p>For BDD2FDD, you recursively compute the FDDs of the cofactors. Then, you compute the xor of these FDDs which is (of course) a computation that takes the two FDDs of the recursive calls and computes a FDD as their xor operation. This Apply function works as the one for BDDs, i.e., recursively traverses the FDDs and moves the maximal node upwards.</p><p>For FDD2BDD, you recursively compute the BDDs of the sub functions high(f) and low(f). Then, you compute the xor of these BDDs which is (of course) a computation that takes the two BDDs computed by the recursive calls and computes a BDD as their xor operation. You just use the Apply algorithm for the latter.</p><p>So, what is the question?</p><div></div># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3838/fdd2bdd-algorithm?show=3841#a3841Fri, 25 Aug 2023 16:18:22 +0000Answered: G automaton to F automaton
https://q2a.cs.uni-kl.de/3831/g-automaton-to-f-automaton?show=3833#a3833
What you have done makes sense to me. <br />
<br />
![a SU b] = Aexists({q},!q, q<->b|a&next(q),G true)<br />
<br />
We have two states {} and {q}, both are accepting (safe) states, and {} is the single initial state. We then have to determinize it with the subset construction so that we can then negate it again to obtain a DetF automaton for [a SU b].# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3831/g-automaton-to-f-automaton?show=3833#a3833Fri, 25 Aug 2023 11:51:14 +0000Answered: Doubt regarding Kripke
https://q2a.cs.uni-kl.de/3813/doubt-regarding-kripke?show=3814#a3814
Since s0 and s1 turn out to be bisimilar, we cannot distinguish these states by any mu-calculus formula without past modalities <:> and [:]. That means whether s5 makes a transition to s1 or to s0 does not matter, since from there, we can do the same things.<br />
<br />
If we would allow past modalities (as in the full mu-calculus), your concern must be considered, which is why we then have to consider a stronger kind of bisimulation (see lecture notes).# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3813/doubt-regarding-kripke?show=3814#a3814Thu, 24 Aug 2023 09:29:32 +0000Answered: LTL to LO2 doubt
https://q2a.cs.uni-kl.de/3810/ltl-to-lo2-doubt?show=3811#a3811
The teaching tool uses as few variables as possible. Indeed, one can show that three variables are sufficient because of the special kind of predicate logic that corresponds with LTL. You have used other names to avoid the shadowing of existing variables, which is safer than what the tool does. So, yes, your solution is correct.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3810/ltl-to-lo2-doubt?show=3811#a3811Thu, 24 Aug 2023 08:21:19 +0000Answered: Simplex integer solution
https://q2a.cs.uni-kl.de/3796/simplex-integer-solution?show=3801#a3801
We have to strengthen the constraints to the next integer values for all solutions that are not yet integers. x0 was just the first, one could also choose y1 or y2. <br />
<br />
If floor does not work, the next step would be to try the ceil-value with the same variable as explained on page 118 of the related chapter. If that does also not work, there is no solution, but it may also happen that the recursion does not terminate as explained on 117.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3796/simplex-integer-solution?show=3801#a3801Wed, 23 Aug 2023 14:10:33 +0000Answered: Symbolic computation
https://q2a.cs.uni-kl.de/3792/symbolic-computation?show=3795#a3795
Yes, that seems to be a solution from another exam problem!# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3792/symbolic-computation?show=3795#a3795Wed, 23 Aug 2023 13:15:09 +0000Answered: omega automaton
https://q2a.cs.uni-kl.de/3791/omega-automaton?show=3794#a3794
Temporal logic formulas can often be better understood when these are translated to deterministic automata. F[a SU b] cannot be translated to Det-G but to Det-F. However, if you use the standard translation, you will get two GF-constraints, However, determinizing Büchi automata is very difficult.<br />
<br />
Hence, we use the following workaround: We translate !F[a SU b] to a NDet-G automaton, determinize it to a Det-G automaton, and negate it to get a Det-F automaton equivalent to F[a SU b].# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3791/omega-automaton?show=3794#a3794Wed, 23 Aug 2023 13:12:04 +0000Answered: Omega Automata Transition Diagram.
https://q2a.cs.uni-kl.de/3767/omega-automata-transition-diagram?show=3774#a3774
Not really sure what you mean, but "*" is just a wildcard that abbreviates every input, right?# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3767/omega-automata-transition-diagram?show=3774#a3774Tue, 22 Aug 2023 15:50:54 +0000Answered: LTL validity checking
https://q2a.cs.uni-kl.de/3771/ltl-validity-checking?show=3773#a3773
<p>We get</p><pre> p q
0 0 (0 <-> a | b & Xp) & (0 <-> 0 | a & Xq)
0 1 (0 <-> a | b & Xp) & (1 <-> 0 | a & Xq)
1 0 (1 <-> a | b & Xp) & (0 <-> 1 | a & Xq)
1 1 (1 <-> a | b & Xp) & (1 <-> 1 | a & Xq)
</pre><p>and thus</p><pre> p q
0 0 !(a | b & Xp) & !(a & Xq)
0 1 !(a | b & Xp) & (a & Xq)
1 0 (a | b & Xp) & 0
1 1 (a | b & Xp) & 1
</pre><p>and thus</p><pre> p q
0 0 !(a | b & Xp) & !(a & Xq)
0 1 !(a | b & Xp) & (a & Xq)
1 0 0
1 1 (a | b & Xp)
</pre><p>Now, note that</p><pre> !(a | b & Xp) & !(a & Xq)
= !a & !(b & Xp) & !(a & Xq)
= !a & !(b & Xp) & !(0 & Xq)
= !a & !(b & Xp)
= !a & !b | !a & !Xp
</pre><p>and</p><pre> !(a | b & Xp) & (a & Xq)
= !a & !(b & Xp) & (a & Xq)
= !a & !(b & Xp) & (0 & Xq)
= 0</pre><p></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3771/ltl-validity-checking?show=3773#a3773Tue, 22 Aug 2023 15:49:44 +0000Answered: Zielonka Algorithm
https://q2a.cs.uni-kl.de/3766/zielonka-algorithm?show=3768#a3768
To compute the attractor of player 1 of {s0,s2,s3}, we consider the predecessor states of the states, and check whether they belong to the attractor: <br />
<br />
Predecessors of s0 are s2 and s4, and since s2 is controlled by player 1, it belongs to the attractor. State s4 belongs to player 0, and player 0 may choose the transition from s4 to s1, so s4 does not belong to the attractor.<br />
<br />
Predecessors of s2 are s3 and s7, and since s3 has only this transition to s2, it belongs to the attractor. State s7 belongs to player 0, so it also belong to the attractor.<br />
<br />
The only predecessors of s3 is s0 which belongs to player 0, so it also belong to the attractor.<br />
<br />
Hence, we now already have states {s0,s2,s3,s7}. We consider the predecessors of s7 which are s5 and s6 which both belong to player 0. State s5 has however only that transition so it is added to the attractor, but s6 has another transition to s1, so it does not belong to the attractor. <br />
<br />
We next consider the predecessors of s5 which s2 and s7 which already belong to the attractor, so we got {s0,s2,s3,s5,s7}.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3766/zielonka-algorithm?show=3768#a3768Tue, 22 Aug 2023 14:49:21 +0000Answered: DPLL Algorithm
https://q2a.cs.uni-kl.de/3759/dpll-algorithm?show=3763#a3763
<p>That is certain possible in general, and in this example, it also generates a model of the formula. If we compute the BDD of the formula, we can also see all the possible models (but I think you should have written b or c must be true):</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=9575437827812347374" style="height:830px; width:400px"></p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3759/dpll-algorithm?show=3763#a3763Mon, 21 Aug 2023 18:55:00 +0000Answered: Translation between logic
https://q2a.cs.uni-kl.de/3758/translation-between-logic?show=3762#a3762
<p>AF(phi1 & Xphi2) is not a CTL formula (regardless whether valid or not), since CTL formulas are defined as those CTL* formulas where a temporal operator occurs right after a path quantifier and where after each path quantifier there is a temporal operator. There is however no path quantifier in front of the X operator since there is a conjunction, so it is not a CTL formula. Even worse: AF(phi1 & Xphi2) is not equivalent to any CTL formula!</p><p>AF(phi1 & AX phi2) is a CTL formula provided that phi1 and phi2 are CTL formulas.</p><p>However, X=AX is not correct, please remove this from your cheat sheet. </p><p>The point is that AF(phi1 & AX phi2) and AF(phi1 & X phi2) are not equivalent. The formulas look very similar, but are not the same. If you continue reading the slides, you will find on page 38 a Kripke structure that satisfies one of the formulas, but not the other one.</p><p>Fa & b = b & Fa is certainly valid since conjunction is commutative, and since disjunction is also commutative, also Fa | b = b | Fa is valid.</p><p>However, Fa | b = Fa is not valid, and neither is Fa & b = b. You can find easily counterexamples with the LTL teaching tool.</p><div></div># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3758/translation-between-logic?show=3762#a3762Mon, 21 Aug 2023 18:45:08 +0000Answered: Translation of logics
https://q2a.cs.uni-kl.de/3754/translation-of-logics?show=3755#a3755
No, that is not correct. E is not equivalent to EF, so the first step is already incorrect. Also in the particular formula, the two formulas E([a SU b] & ¬[c SU d]) and EF([a SU b] & ¬ [c SU d]) are not equivalent.<br />
<br />
Second, where do the AG operators in the second step come from?# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3754/translation-of-logics?show=3755#a3755Mon, 21 Aug 2023 13:02:16 +0000Answered: Translation between logics
https://q2a.cs.uni-kl.de/3741/translation-between-logics?show=3742#a3742
If we write E((Fa) ^ (Fb)) without the outermost brackets, it will be E(Fa) ^ (Fb) which is just EFa ^ Fb and since that is another formula, we need to write the brackets. <br />
<br />
Your solution is incorrect. It is true that you can use Fa=!G!a and Fb=!G!b, but you cannot reduce (!G!a)^(!G!b) to !G(!a&!b) while you could reduce (G!a)^(G!b) to G(!a&!b) but that is another formula.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3741/translation-between-logics?show=3742#a3742Mon, 21 Aug 2023 09:30:57 +0000Answered: omega automaton
https://q2a.cs.uni-kl.de/3738/omega-automaton?show=3740#a3740
<p>To translate [a SU b] to an equivalent F-automaton, you may note that [a SU b] holds if we have a&!b for a some finite time until b holds at some time. This leads to the automaton shown on page 69 of VRS-07-TemporalLogic which is a F-automaton. It is not deterministic, since some transitions are missing, but if these are added (leading to an additional sink state), you got your automaton.</p><p>Note, however, that this automaton is only equivalent to [a SU b] at the initial point of time and also until the first point of time where b holds, but no afterwards. If you want an automaton that is always equivalent to [a SU b], then you need a GF-automaton.</p><div></div># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3738/omega-automaton?show=3740#a3740Mon, 21 Aug 2023 09:04:56 +0000Answered: Quantification algorithm
https://q2a.cs.uni-kl.de/3734/quantification-algorithm?show=3735#a3735
For the algorithms, forall(e, phi) and exists(e, phi), phi can be an arbitrary BDD, but e is a conjunction of the variables. The recursive calls will either be done with the same BDD e or with its positive cofactor. Hence, it may finally end up with leaf node True, but never with leaf node False.<br />
<br />
Moreover, if phi is a leaf node, then the result is phi since the definition of the quantification is the conjunction or disjunction of the cofactors which are however for constants just the constant itself. As we have x&x=x and x|x=x, this is just phi.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3734/quantification-algorithm?show=3735#a3735Sun, 20 Aug 2023 13:27:06 +0000Answered: FDD to ZDD
https://q2a.cs.uni-kl.de/3725/fdd-to-zdd?show=3728#a3728
<p>I am not sure what you mean with "<span style="font-family:Helvetica,Arial,sans-serif; font-size:14px">I got set representation of ZDD from FDD.</span>", what you need to do is to read the following:</p><ol><li>get the set representation of the FDD</li><li>determine the RMF of the set representation</li><li>convert the RMF to DNF (expand the cubes of the DNF to midterms)</li><li>convert the DNF to a set representation of the ZDD</li><li>write down the ZDD from the set representation of step 4</li></ol><div></div># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3725/fdd-to-zdd?show=3728#a3728Sun, 20 Aug 2023 08:40:58 +0000Answered: omega-automaton
https://q2a.cs.uni-kl.de/3717/omega-automaton?show=3718#a3718
Yes, there is an algorithm that does that translation. Unfortunately, most students stop reading the slides after the main translation up to page 91 in VRS-07-TemporalLogic. Pages 92-94 and the examples on pages 95-99 show first that some of the fairness constraints are not required. <br />
<br />
Pages 100-102 motivate subclasses of temporal logic that correspond with safety, liveness, persistence and fairness properties. Pages 104-109 show then then we can use implications instead of equivalences for the transition relation, and this is the key to use weaker constraints than the fairness constraints which is then proved on pages 110-114. <br />
<br />
The final translation to safety and liveness constraints is given on pages 115-116, and examples are shown on pages 117-127. <br />
<br />
Have a look at these additional slides, they explain everything you need to solve the exercise.# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3717/omega-automaton?show=3718#a3718Sat, 19 Aug 2023 13:40:28 +0000Answered: LTL Model checking
https://q2a.cs.uni-kl.de/3708/ltl-model-checking?show=3712#a3712
<p>Okay, I will do that in great detail below, and you can do many of these steps at once, of course. Instantiating all cases for p and q yields:</p><pre> p q
0 0 (0 <-> a V b & Xp) ^ (0 <-> 0 V a & Xq)
0 1 (0 <-> a V b & Xp) ^ (1 <-> 0 V a & Xq)
1 0 (1 <-> a V b & Xp) ^ (0 <-> 1 V a & Xq)
1 1 (1 <-> a V b & Xp) ^ (1 <-> 1 V a & Xq)
and thus
p q
0 0 !(a V b & Xp) ^ !(0 V a & Xq)
0 1 !(a V b & Xp) ^ (0 V a & Xq)
1 0 (a V b & Xp) ^ !(1 V a & Xq)
1 1 (a V b & Xp) ^ (1 V a & Xq)
which simplifies to (note that x&phi is equivalent to x&(phi[x<-1]))
p q
0 0 !(a V b & Xp) ^ !(a & Xq)
0 1 !(a V b & Xp) ^ a & Xq
1 0 0
1 1 (a V b & Xp)
and further to
p q
0 0 !(a V b & Xp) ^ !(a & Xq)
0 1 !(1 V b & Xp) ^ a & Xq
1 0 0
1 1 (a V b & Xp)
which results in
p q
0 0 !(a V b & Xp) ^ !(a & Xq)
0 1 0
1 0 0
1 1 a V b & Xp
</pre><p>So, we have no outgoing transitions in states {p} and {q}. For state {p,q}, we have outgoing transitions for a to anyone of the four states, and for b to the states {p} and {p,q} since Xp must hold then. </p><p>The transitions of state {} are more difficult. We further simplify the transition relation and get the following</p><pre> !(a V b & Xp) ^ !(a & Xq)
= !a & !(b & Xp) ^ !(a & Xq)
= !a & !(b & Xp) ^ !(0 & Xq)
= !a & !(b & Xp) ^ !(0)
= !a & !(b & Xp)
= !a & (!b | !Xp)
= !a & !b | !a & !Xp </pre><p>Hence, we have transitions to anyone of the four states with !a&!b and to the states {} and {q} for input !a. </p># Study-Organisation (Master)https://q2a.cs.uni-kl.de/3708/ltl-model-checking?show=3712#a3712Thu, 17 Aug 2023 18:28:12 +0000Answered: 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 +0000Variable ordering
https://q2a.cs.uni-kl.de/3417/variable-ordering
Can you please tell me how to take the variable ordering to draw this BDD for state transition?# Study-Organisation (Master)https://q2a.cs.uni-kl.de/3417/variable-orderingThu, 26 Jan 2023 17:48:31 +0000