[CS@TUK] Questions and Answers - Recent questions and answers in * TF "Emb. Sys. and Rob."
https://q2a.cs.uni-kl.de/qa/teaching-field-embedded-systems-and-robotics
Powered by Question2AnswerAnswered: September 6, 2022, Problem 8.(f)
https://q2a.cs.uni-kl.de/3448/september-6-2022-problem-8-f?show=3449#a3449
Your solution is correct, since you can prove that the following LTL formula is valid: <br />
<br />
!a & !b & X G (!a&b) -> X[a SU b] & ![(X a) SU b]* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3448/september-6-2022-problem-8-f?show=3449#a3449Tue, 31 Jan 2023 20:03:37 +0000Answered: Isn't it satisfying S1 and NOT satisfying S2?
https://q2a.cs.uni-kl.de/3435/isnt-it-satisfying-s1-and-not-satisfying-s2?show=3436#a3436
Yes, your solutions is an alternative one that is correct. The only path of the structure visits the "a"-state, the "b"-state and the "c"-state infinitely often, but there is not state where all these variables hold at the same time, and therefore such a state can also not be visited infinitely often. Albeit larger, your solution is even nicer than the given one.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3435/isnt-it-satisfying-s1-and-not-satisfying-s2?show=3436#a3436Mon, 30 Jan 2023 09:52:55 +0000Answered: Local model checking [ 02-2019 5a]
https://q2a.cs.uni-kl.de/3429/local-model-checking-02-2019-5a?show=3432#a3432
If a proof goal s|-phi is generated for a mu-formula phi such that this goal already appeared before, then we can conclude that phi does not hold on that state s. However, as Daniel pointed out, it may still hold on a predecessor of s like s5 if there are other disjunctive subgoals that may satisfy the formula (as it is the case in the example).* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3429/local-model-checking-02-2019-5a?show=3432#a3432Sat, 28 Jan 2023 15:12:31 +0000Answered: VRS Exam [February 17, 2021], Problem 8e
https://q2a.cs.uni-kl.de/3428/vrs-exam-february-17-2021-problem-8e?show=3430#a3430
<p><span style="font-size:14px">Well for:</span></p><p><span style="font-size:14px">Gd <span style="font-family:Helvetica,Arial,sans-serif">∧ (FGd </span><span style="font-family:Helvetica,Arial,sans-serif">∨ Fb</span><span style="font-family:Helvetica,Arial,sans-serif">)</span></span></p><p><span style="font-size:14px"><span style="font-family:Helvetica,Arial,sans-serif">to hold, it is clear that Gd needs to hold. However Gd directly implies that FGd also holds due to:</span></span></p><p><span style="font-size:14px"><span style="font-family:Helvetica,Arial,sans-serif">Gd => FGd</span></span></p><p><span style="font-size:14px"><span style="font-family:Helvetica,Arial,sans-serif">so if Gd holds, FGd holds too and thus we don't need to care about the Fb part. That's the reason </span></span><span style="font-size:14px"><span style="font-family:Helvetica,Arial,sans-serif">why the whole term reduces to Gd.</span></span></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3428/vrs-exam-february-17-2021-problem-8e?show=3430#a3430Sat, 28 Jan 2023 14:43:08 +0000Answered: VRS Exam [August 25th, 2020], Problem 8b. Part 1
https://q2a.cs.uni-kl.de/3426/vrs-exam-august-25th-2020-problem-8b-part-1?show=3427#a3427
<p><span style="font-size:14px">If you treat the inner formula as "<em>phi</em> := <span style="font-family:Helvetica,Arial,sans-serif">(<strong>v</strong>x.b </span><span style="font-family:Helvetica,Arial,sans-serif">∧ ♦</span><em>x</em><span style="font-family:Helvetica,Arial,sans-serif">)" then your solution reduces to:</span></span></p><p><span style="font-size:14px"><span style="font-family:Helvetica,Arial,sans-serif"><strong>µ</strong>x.(<strong>v</strong>y.♦y ∧ phi </span><span style="font-family:Helvetica,Arial,sans-serif">∨ ♦x)</span></span></p><p><span style="font-size:14px"><span style="font-family:Helvetica,Arial,sans-serif">while the sample solution is reduced to:</span></span></p><p><span style="font-size:14px"><span style="font-family:Helvetica,Arial,sans-serif"><strong>µ</strong>y.(<strong>v</strong>x.♦x ∧ phi </span><span style="font-family:Helvetica,Arial,sans-serif">∨ </span><span style="font-family:Helvetica,Arial,sans-serif">♦y)</span></span></p><p><span style="font-size:14px"><span style="font-family:Helvetica,Arial,sans-serif">which are both equivalent because the only difference is that the variables x and y are switched. The important part is that the variable x in the formula <em>phi</em> does not depend on the variables outside of <em>phi</em> because the variable is rebound in <em>phi</em>, so instead you could also use:</span></span></p><p><span style="font-size:14px">"<em>phi</em> := <span style="font-family:Helvetica,Arial,sans-serif">(<strong>v</strong>z.b </span><span style="font-family:Helvetica,Arial,sans-serif">∧ ♦<em>z</em>)"</span></span></p><p><span style="font-size:14px"><span style="font-family:Helvetica,Arial,sans-serif">instead without changing the meaning.</span></span></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3426/vrs-exam-august-25th-2020-problem-8b-part-1?show=3427#a3427Sat, 28 Jan 2023 14:24:13 +0000Answered: Exam 16.02.2022, Problem 8g) Natural Language to LTL
https://q2a.cs.uni-kl.de/3424/exam-16-02-2022-problem-8g-natural-language-to-ltl?show=3425#a3425
Yes, I agree with you. We can even write more explicitly the following formula:<br />
<br />
G((!a & X a -> X G a) & (a & X !a -> X G !a))<br />
<br />
The above is equivalent to your suggestion.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3424/exam-16-02-2022-problem-8g-natural-language-to-ltl?show=3425#a3425Fri, 27 Jan 2023 19:36:01 +0000Answered: Exam 25.08.2020, 8d): Universal omega-Automaton to LO2
https://q2a.cs.uni-kl.de/3422/exam-25-08-2020-8d-universal-omega-automaton-to-lo2?show=3423#a3423
Your computation is correct, as far as I can say. However, to translate the automaton formula, you don't have to double negate it to get an existential automaton inside. If you drive in the outermost negation, it is still a LO2 formula, and is the one obtained directly from the universal automaton.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3422/exam-25-08-2020-8d-universal-omega-automaton-to-lo2?show=3423#a3423Fri, 27 Jan 2023 13:32:53 +0000Answered: FDD to ZDD 09/2022 1d
https://q2a.cs.uni-kl.de/3413/fdd-to-zdd-09-2022-1d?show=3416#a3416
<p>About the edited part and the mistake in your solution. Look at this:</p><pre> correct: c&!b&a|c&!b&!a|!c&!b&a|!c&<span style="color:#e74c3c">!b</span>&!a|c&b&a
yours: c&!b&a|c&!b&!a|!c&!b&a|!c&<span style="color:#e74c3c"> b</span>&!a|c&b&a
</pre><p>The SNF/BDD would be obtained as follows:</p><pre> a=1:
c&!b&a|c&!b&!a|!c&!b&a|!c&!b&!a|c&b&a
= c&!b|!c&!b|c&b
b=1: c&!b|!c&!b|c&b = c
b=0: c&!b|!c&!b|c&b = c|!c = 1
a=0:
c&!b&a|c&!b&!a|!c&!b&a|!c&!b&!a|c&b&a
= c&!b|!c&!b
= !b </pre><p>The BDD looks therefore as follows:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=8717633797962169586" style="height:354px; width:204px"></p><p>but the ZDD is not the same and looks as follows:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=9751072698037401062" style="height:358px; width:195px"></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3413/fdd-to-zdd-09-2022-1d?show=3416#a3416Thu, 26 Jan 2023 14:15:13 +0000Answered: SNF - LTL model checking
https://q2a.cs.uni-kl.de/3404/snf-ltl-model-checking?show=3405#a3405
!(!a | Xq0) & !(a & Xq1)<br />
De Morgan<br />
a & !Xq0 & (!a | Xq1)<br />
Multiply out<br />
a & !Xq0 & !a | a & !Xq0 & Xq1<br />
Simplify a&…&!a to false, and simplify false | something to something<br />
a & !Xq0 & Xq1* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3404/snf-ltl-model-checking?show=3405#a3405Wed, 25 Jan 2023 13:05:47 +0000Answered: how to construct an endochronous wrapper mbes
https://q2a.cs.uni-kl.de/3401/how-to-construct-an-endochronous-wrapper-mbes?show=3403#a3403
In the simplest case, the function implemented by the node is a sequential function. Then, there is a tree whose nodes are labeled with the input variables that should be followed for reading the inputs until enough inputs are there to fire the node. The inputs that are not needed are replaced with some dummy values since they don't matter. This way, we produce values for all outputs, but remove the outputs that should be not present afterwards.<br />
<br />
For endochronous functions that are not sequential the implementation is more individual and depends on the particular function. Since it is endochronous, there is however a way how to read the inputs and how to decide whether there are enough inputs there to fire an action.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3401/how-to-construct-an-endochronous-wrapper-mbes?show=3403#a3403Wed, 25 Jan 2023 12:22:44 +0000Answered: VRS updated Cheat Sheet required!
https://q2a.cs.uni-kl.de/3370/vrs-updated-cheat-sheet-required?show=3385#a3385
<p>In the additional material sections of <a rel="nofollow" href="https://es.cs.uni-kl.de/teaching/vrs/exercises/">https://es.cs.uni-kl.de/teaching/vrs/exercises/</a> you can download the "VRS-SurvivalPackage" (the suitcase symbol) which now contains an updated cheat sheet which was created by students in the last summer term (SS 2022) and thus contains all the content you probably need currently (for example the Zielonka algorithm). As always we cannot give any guarantee about its contents so please take care when using it and maybe cross check certain things if you think they may be wrong (or if you are not sure if you understand the notes properly).</p><p></p><p></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3370/vrs-updated-cheat-sheet-required?show=3385#a3385Tue, 24 Jan 2023 16:05:22 +0000Answered: VRS - Exam [02.16.2022], Problem 5b
https://q2a.cs.uni-kl.de/3381/vrs-exam-02-16-2022-problem-5b?show=3383#a3383
<p>Good question! </p><p>Yes, you are right, and the solution has a little bug. Let us clarify this. First of all, your formula for the right hand side of X r1 is perfect, and it can be simplified as follows:</p><pre> X r1 <-> (r0 & !r1 & a) | (r0 & !r1 & !a) | (!r0 & r1 & !a) | (r0 & r1)
<-> (r0 & !r1 & (a | !a)) | (!r0 & r1 & !a) | (r0 & r1)
<-> (r0 & !r1) | (!r0 & r1 & !a) | (r0 & r1)
<-> (r0 & !r1) | (r0 & r1) | (!r0 & r1 & !a)
<-> (r0 & (!r1 | r1)) | (!r0 & r1 & !a)
<-> r0 | (!r0 & r1 & !a)
<-> r0 | r1 & !a
</pre><p>So, we should use the above formula (which would be fine). It is certainly not equivalent to true. The state transition diagram obtained for this formula looks as follows where we have a self-loop on the unreachable state s0:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=5815214445163381162" style="height:256px; width:451px"></p><p>However, symbolic representations of transition relations are not uniquely defined. We may modify them on the unreachable states as we like, and can use this to minimize the formulas or their BDD representations.</p><p>Looking at the state transitition diagram, you can see that the state !r0&!r1, i.e. state s0, is not reachable. Taking this into account, we can simplify the formula as follows:</p><p> X r1 <-> r0 | !a</p><p>Note that r0 | r1 & !a and r0 | !a are not equivalent, but they only differ if !r0&!r1&!a holds, i.e., on the not reachable state which we don't care. The above formulas has been obtained by logic minimization with a don't care formula !r0&!r1. This way, our transition system looks as follows:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=8808348083695314290" style="height:528px; width:380px"></p><p>As you can see, we have the same transitions on the reachable states, but on the unreachable state, there are now two transitions. But we don't care about transitions on the unreachable states.</p><p>The example solution had a bug in that it has been written that all transitions lead to states where next r1 holds, and that we can therefore use X r1 <-> true. The same has been written for the other transition relation for state variable s1. While that is true for s1, it is not true for r1, since there is a transition {r1} -> {r0} where next time r1 is false. So, the given transition relation is indeed incorrect. Its transition system would looks as follows:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=12597054522958865229" style="height:427px; width:380px"></p><p>Now transitions on the reachable states also changed since the transition {r1} -> {r0} with input a is lost. This is therefore not correct. </p><p>Still, as you can see, the transition relation can be modified such that the transitions on the unreachable states change, and this can be used to simplify the transition relation.</p><p>If that all sounds too complicated, don't worry: Using X r1 <-> r0 | r1 & !a is perfectly fine as well, since you can see above that the transition on the reachable states are exactly the same.</p><p></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3381/vrs-exam-02-16-2022-problem-5b?show=3383#a3383Mon, 23 Jan 2023 09:16:09 +0000Answered: Parallel Prefix Sum, Work Computation
https://q2a.cs.uni-kl.de/3376/parallel-prefix-sum-work-computation?show=3377#a3377
<p>For the computation of the work, we need the geometric sum formula which is \sum_{i=1}^n q^i = q*\frac{q^n-1}{q-1}.</p><p>The work of the bottom-up traversal is then computed as follows:</p><pre> W_{bottom-up}(n)
= \sum_{h=1}^{\log(n)} \frac{n}{2^h}
= n * \sum_{h=1}^{\log(n)} \frac{1}{2}^h
= n * \frac{1}{2} * \frac{\frac{1}{2}^\log{n}-1}{\frac{1}{2}-1}
= n * \frac{1}{2} * \frac{\frac{1}{n}-1}{\frac{1}{2}-1}
= \frac{1}{2} * \frac{1-n}{\frac{1}{2}-1}
= \frac{1-n}{1-2}
= \frac{1-n}{-1}
= n-1
</pre><p>The work of the top-down traversal is computed as follows:</p><pre> W_{top-down}(n)
= \sum_{h=1}^{\log(n)-1} (\frac{n}{2^{\log(n)-i}} - 1)
= (\sum_{h=1}^{\log(n)-1} \frac{n}{2^{\log(n)-i}}) - (\log(n)-1)
= (\sum_{h=1}^{\log(n)-1} \frac{n*2^i}{2^{\log(n)}}) - (\log(n)-1)
= (\sum_{h=1}^{\log(n)-1} \frac{n*2^i}{n}) - (\log(n)-1)
= (\sum_{h=1}^{\log(n)-1} 2^i) - (\log(n)-1)
= (2*\frac{2^{\log(n)-1}-1}{2-1}) - (\log(n)-1)
= (2* {2^{\log(n)-1}-1}) - (\log(n)-1)
= (2* {n/2-1}) - (\log(n)-1)
= (n - 2) - (\log(n)-1)
= n - 2 - \log(n) + 1
= n - \log(n) - 1</pre><p></p><p></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3376/parallel-prefix-sum-work-computation?show=3377#a3377Sat, 21 Jan 2023 08:04:41 +0000Answered: Doubts regarding VRS exams August 21. 2021
https://q2a.cs.uni-kl.de/3371/doubts-regarding-vrs-exams-august-21-2021?show=3372#a3372
The trick with the negation has been done to generate a conjunction of formulas in the body of the quantifier. Then, one can use the trick mentioned on the note on slide 69 of the chapter on transition systems which is as follows: If you have any formula phi and compute the negation of phi with a variable x, then phi&x is equivalent to phi[x<-1] & x where phi[x<-1] is the formula phi where all occurrences of x were replaced with 1. Analogously, phi&!x is equivalent to phi[x<-0] & !x. This trick often simplifies these calculations significantly and is therefore recommended. It is also explained in the video and the examples in the video and the slides.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3371/doubts-regarding-vrs-exams-august-21-2021?show=3372#a3372Wed, 18 Jan 2023 10:45:32 +0000Answered: Doubt regarding VRS Exam 2022.09 Problem 3c)
https://q2a.cs.uni-kl.de/3367/doubt-regarding-vrs-exam-2022-09-problem-3c?show=3368#a3368
No, the variables are not renamed "vice versa", why do you think so? You can find the symbolic computation of successors and predecessors on page 68 of the chapter on transition systems. The existential successors are computed by first computing the existential quantification on all current variables of the conjunction of the transition relation and the state set, and since that is a formula in the next variables, these are replaced then with the corresponding current variables.<br />
<br />
I have no idea what you mean with a separator? Do you mean quantifier or do you mean cofactors?* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3367/doubt-regarding-vrs-exam-2022-09-problem-3c?show=3368#a3368Tue, 17 Jan 2023 09:32:37 +0000Answered: exercise sheet 7 mbes
https://q2a.cs.uni-kl.de/3365/exercise-sheet-7-mbes?show=3366#a3366
The control-flow predicates insd, inst, enter, term, and move have been defined for a core set of statements. The loop statement is not one of the core statements and can be expressed by the core statements. Once that is done, you can apply the definitions for the control-flow statements to compute insd(loop S), inst(loop S), enter(loop S), term(loop S) and move(loop S).* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3365/exercise-sheet-7-mbes?show=3366#a3366Sun, 15 Jan 2023 10:08:31 +0000Answered: Control-flow actions exam 2013.02.19
https://q2a.cs.uni-kl.de/3363/control-flow-actions-exam-2013-02-19?show=3364#a3364
<p>We consider the following module:</p><pre> module P(event bool ?a,?b,o1, bool o2)
{
loop {
{
l0: pause;
if(b)
emit next(o1);
l1: pause;
if(b)
emit(o2);
} || {
if(a) {
l2: pause;
emit(o1);
}
}
}
}
</pre><p>There are many ways how the control-flow actions can be computed. The best way would be to follow the symbolic compilation as explained in the course. This should generate the following guarded actions:</p><pre> control flow:
st => next(l0) = true
a&st => next(l2) = true
(l1&l2|l2&!(l0|l1)|l1&!l2) => next(l0) = true
l0 => next(l1) = true
a&(l1&l2 | l2&!(l0|l1)|l1&!l2) => next(l2) = true
data flow:
b&l0 => next(o1) = true
b&l1 => o2 = true
l2 => o1 = true
</pre><p>The ones you mention are among the ones above. How are they explained?</p><p>If you consider l0, it is entered whenever the loop body is started, i.e., when the loop is started and when the loop body terminates (and is restarted). If the loop is initially started, we have st (and all other labels are false), so that explains the guarded action st => next(l0) = true.</p><p>To determine when the loop body terminates, we have to consider the termination of a parallel statement. Recall that S1||S2 terminates if term(S1)&!insd(S2) | !insd(S1)&term(S2) | term(S1)&term(S2) holds. We moreover have term(S1) = l1, term(S2) = l2, insd(S1)=l0|l1 and insd(S2) = l2, so that </p><p> term(S1||S2) = l1&!l2 | !(l0|l1)&l2 | l1&l2</p><p>holds. That explains the guarded action (l1&l2|l2&!(l0|l1)|l1&!l2) => next(l0) = true which is just term(S1||S2) => next(l0) = true. </p><p>For the guarded action on l2, note that it is entered at starting time when additionally a holds, which yields guarded action a&st => next(l2) = true. Moreover, l2 is entered if the loop reiterates and a holds, i.e., if a&term(S1||S2) holds. Based on the above results, this yields a&(l1&l2 | l2&!(l0|l1)|l1&!l2) => next(l2) = true.</p><p></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3363/control-flow-actions-exam-2013-02-19?show=3364#a3364Sat, 14 Jan 2023 18:14:10 +0000Answered: Cardinality of R
https://q2a.cs.uni-kl.de/3357/cardinality-of-r?show=3358#a3358
Cardinality means size and the final answer wasn't multiplied by 2^n.<br />
<br />
The second summation is just the sum of integers 0 to x. That would be x*(x+1)/2. Here, x is 2^(n+1)-1, so the sum equals (2^(n+1)-1)*(2^(n+1)-1+1)/2. We drop -1+1 and reorder: (2^(n+1))*(2^(n+1)-1)/2. Now, we divide the first factor by 2 (in order to simplify the /2). Which turns 2^(n+1) to 2^n. The result is (2^n)*(2^(n+1)-1).* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3357/cardinality-of-r?show=3358#a3358Wed, 11 Jan 2023 17:02:09 +0000Answered: MBES exercice sheet 6.1.b
https://q2a.cs.uni-kl.de/3355/mbes-exercice-sheet-6-1-b?show=3356#a3356
For a synchronous program, every variable has a unique value at any point of time. The input variables are thereby determined by the environment, i.e., they receive a new value (randomly) at every point of time. The local and output variables are determined by the module.<br />
<br />
In one macro step, a finite number of micro steps can take place. The number of micro steps is not bounded, but it must be finite. Which actions (micro steps) are executed is precisely determined by the operational semantics. For the statement [weak] abort S when(i); emit(o3), it is the case that if we are inside of S and i holds, then the abort statement terminates and emit(o3) is executed as a further micro step in the same macro step. The SOS rules precisely define that behavior.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3355/mbes-exercice-sheet-6-1-b?show=3356#a3356Sat, 07 Jan 2023 17:38:16 +0000Answered: Doubt regarding VRS Exam 2022.09.06 Problem 6b)
https://q2a.cs.uni-kl.de/3345/doubt-regarding-vrs-exam-2022-09-06-problem-6b?show=3346#a3346
The solution given for the exam ist correct, and yours is unfortunately wrong. To compute the transitions of state ({s2,s3},{s3}), we have to consider the transitions from states s2 and s3 which are as follows: s2--*-->s2, s2--*-->s3 and s3--!b-->s3. Hence, with input !b (regardless of a), we have ({s2,s3},{s3}) --!b--> ({s2,s3},{s3}) and with input b (again regardless of a), we have ({s2,s3},{s3}) --b--> ({s2,s3},{}) since we have to compute the existential successors in both components, and have to intersect the second component with {s3}.<br />
<br />
It is easily seen that your solution cannot be correct, since your automaton is not deterministic. Note that a and b are boolean variables that symbolically encode the four inputs !a&!b, !a&b, a&!b, and a&b. Having outgoing transitions for a as well as for condition b (and !b) gives us choices for the input a&b: Since a holds, we could remain in state ({s2,s3},{s3}) of your automaton, and since b holds, we may switch to state ({s2,s3},{}). Hence, your automaton is not deterministic, and can therefore be not a correct result of a determinization procedure.<br />
<br />
Accepting states of the automaton are those where the second component is not empty. That is only the case for state ({s2,s3},{s3}) and in particular not for state ({s2,s3},{}).<br />
<br />
I think that you mean a sink state instead of a sync state. But why should we have a sink state? It can be generated by the determinization procedure if needed, but it is not generated here, since it is not needed here.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3345/doubt-regarding-vrs-exam-2022-09-06-problem-6b?show=3346#a3346Mon, 02 Jan 2023 19:31:21 +0000Answered: .cby. operator in Poly DPNs
https://q2a.cs.uni-kl.de/3340/cby-operator-in-poly-dpns?show=3342#a3342
(x cby y) is essentially y shifted one step to the right (ignoring the initial value that comes from x). Hence, all values including the boxes move one step to the right. Typically, that moves a box to a place where before there was no box and a place where there was no box may become a real value. Hence, the clocks of y and (x cby y) are usually different ones. Note that the clock is a boolean stream that is 0 if the value is a box, and 1 otherwise.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3340/cby-operator-in-poly-dpns?show=3342#a3342Sun, 11 Dec 2022 10:15:28 +0000Answered: Polychronous DPNs
https://q2a.cs.uni-kl.de/3339/polychronous-dpns?show=3341#a3341
The signals mentioned in the tables do not always have a value for each variable. Sometimes there is a value for one variable, but not for the other at some point of time. The upper table considers just the sequences of values for each variable (not synchronizing them to the same points of time) while the table in the lower part uses box-values to indicate that at that point of time, there is not value. The boxes are just used to indicate the absence of a value and this way, they synchronize the data streams into synchronous reactions (the columns). Without the boxes, the streams are desynchronized. They still have the same values, but their temporal relationship is lost.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3339/polychronous-dpns?show=3341#a3341Sun, 11 Dec 2022 10:12:24 +0000Answered: DPLL algorithm from August 31, 2021 - Multiple solutions?
https://q2a.cs.uni-kl.de/3337/dpll-algorithm-from-august-31-2021-multiple-solutions?show=3338#a3338
Yes, I think it is correct. However, in the last step, you should have first assigned a true, since that is a unit clause. Since a propositional logic formula has usually many satisfying assignments, there are typically also many solutions for SAT solving.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3337/dpll-algorithm-from-august-31-2021-multiple-solutions?show=3338#a3338Sun, 04 Dec 2022 19:42:14 +0000Answered: exercice sheet 4 mbes
https://q2a.cs.uni-kl.de/3335/exercice-sheet-4-mbes?show=3336#a3336
<p>The solution of the balance equations is the same that is right, so that we can compute the same periodic schedule that would run the DPN with bounded memory. The rate vector, i.e., the T-invariant is the same in both cases. </p><p>However, if we do not enforce a periodic schedule and allow the nodes to fire on their own, then the DPN with buffer z6 is still bounded, while without z6 is it not. That is checked with the existence of a positive S-invariant. With buffer z6, there are the S-invariants (1,2,0,0,0,0), (0,0,4,2,0,0) and (1,0,-2,0,2,2) whose sum is (2,2,2,2,2,2) and that is a positive S-invariant so that that DPN is bounded for ALL schedules. Without z6, we just have S-invariants (1,2,0,0,0) and (0,0,4,3,0) whose linear combinations all have a 0 entry in the final component. Hence, buffer z5 may overflow if nodes a,d fire faster than nodes b,c.</p><p>Try the teaching tool <a rel="nofollow" href="https://es.cs.uni-kl.de/tools/teaching/DataflowStaticScheduling.html">https://es.cs.uni-kl.de/tools/teaching/DataflowStaticScheduling.html</a></p><p>with buffer z6</p><pre>(z1:4,z2:4,z3:4,z4:4,z5:4,z6:4) = init()
(z2:0:1:0:1:0:1,z5:1:0:1:0:1:0) = a(z1:1:1:1:1:1:1)
(z4:1:1) = b(z3:0:1,z5:1:0)
(z3:0:1:0:1,z6:1:0:1:0) = c(z4:1:1:1:1)
(z1:1:1) = d(z2:0:1,z6:1:0)
</pre><p>and without z6:</p><pre>(z1:4,z2:4,z3:4,z4:4,z5:4) = init()
(z2:0:1:0:1:0:1,z5:1:0:1:0:1:0) = a(z1:1:1:1:1:1:1)
(z4:1:1) = b(z3:0:1,z5:1:0)
(z3:0:1:0:1) = c(z4:1:1:1:1)
(z1:1:1) = d(z2:0:1)</pre><p></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3335/exercice-sheet-4-mbes?show=3336#a3336Sat, 03 Dec 2022 16:05:49 +0000Answered: Static DPNs
https://q2a.cs.uni-kl.de/3333/static-dpns?show=3334#a3334
The vectors denote the number of tokens available in the buffers of the DPN, each component of such a vector corresponds with one of the buffers. When firing some nodes of the DPN, these nodes consume tokens from the input buffers and produce tokens to its output buffers. <br />
<br />
The initial vector (0,0,0,6) was chosen quite arbitrarily, we just have to make sure that there are enough tokens to survive one period of the schedule. When the first node h fires, it consumes 3 tokens from buffer g->h so that there are then 6-3=3 tokens left. It also produces 3 tokens for each one of the buffers h->f and h->g so that we get there 0+3=3 tokens each. The same happens in the other firings where sometimes two nodes are fired and then their effect is added. <br />
<br />
The important matter of fact is that a periodic schedule must end with its initial state so that all buffers are balanced, and we can repeat that infinitely often. You can do the same with an initial state like (0,0,0,8) or any other one that allows to fire all the nodes for the required number of times.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3333/static-dpns?show=3334#a3334Wed, 30 Nov 2022 09:36:38 +0000Answered: Non-sequential behavior of DPNs
https://q2a.cs.uni-kl.de/3331/non-sequential-behavior-of-dpns?show=3332#a3332
If you do not consider all inputs in parallel, then you consider them in a sequential order. However, as we have to use a blocking read method, it may happen that the buffer that is read first is empty and therefore the reaction cannot take place. Note that the first three actions allow that x3, x1, and x2, respectively may be empty. <br />
<br />
If you check the input buffers instead in parallel, you can decide which one of the five actions has to be applied, so that the process can proceed and can implement that function. This is however, not possible with a sequential behavior.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3331/non-sequential-behavior-of-dpns?show=3332#a3332Wed, 23 Nov 2022 19:51:24 +0000Is there anyone wana discuss the homework of prozessarchitechtur?
https://q2a.cs.uni-kl.de/3328/there-anyone-wana-discuss-the-homework-prozessarchitechtur
* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3328/there-anyone-wana-discuss-the-homework-prozessarchitechturWed, 16 Nov 2022 00:41:46 +0000Answered: Is there any update regarding thé VRS exam results?
https://q2a.cs.uni-kl.de/3324/is-there-any-update-regarding-th%C3%A9-vrs-exam-results?show=3325#a3325
Unfortunately, the results are still not available. We are sorry about that, but inform the students as soon as the results will be there.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3324/is-there-any-update-regarding-th%C3%A9-vrs-exam-results?show=3325#a3325Mon, 31 Oct 2022 09:40:40 +0000Answered: Clos network paull matrix
https://q2a.cs.uni-kl.de/3322/clos-network-paull-matrix?show=3323#a3323
Recall what the meaning of the Paull matrix is: entry (i,j) contains the set of numbers m[i,j] such that the left crossbar i is connected via all k ∈ m[i,j] to the right crossbar j. If crossbar k would occur more than once in a row, e.g., in entries (i,j1) and (i,j2), it would mean that we connect input crossbar i to the middle crossbar k which should then be connected to the two output corssbars j1 and j2. However, that is impossible since the input i of the middle crossbar k is routed either to its output j1 or j2, but not to both.<br />
<br />
Analogously, if crossbar k would occur more than once in a column, e.g., in entries (i1,j) and (i2,j), it would mean that we connect input crossbars i1 and i2 to the middle crossbar k which should then be connected to the output corssbar j. However, that is impossible since only either input i1 or i2 of the middle crossbar k can be connected to its output j, but not to both.<br />
<br />
Hence, every k∈{0,...,r2−1} can occur at most once in each row and at most once in each column. Do you agree?<br />
<br />
For routing in Clos networks, there are many solutions in general. The problem is equivalent to find perfect matchings in bipartite graphs which also has typically more than one solution.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3322/clos-network-paull-matrix?show=3323#a3323Fri, 09 Sep 2022 09:17:04 +0000Answered: Solutions to exam (2022.02.14) accelerated cascading problem
https://q2a.cs.uni-kl.de/3320/solutions-to-exam-2022-02-14-accelerated-cascading-problem?show=3321#a3321
Yes, you are right, we follow in that exam problem the accelerated cascading of the algorithm FirstOnePar which is very similar to the algorithm considered in this exam problem. In the lecture notes, it is assumed that the length of the array is a square number N = M^2, i.e., we partition the array into M parts of size M where M := sqrt(N). Now, this exam problem asks in essence whether that was a good choice. <br />
<br />
So, we consider a more general approach where the array of size N = p*q is split into p groups of size q. In the first step, we compute an array y of size p such that its values y[i] are true iff the group i has an element x[i*q..(i+1)*q-1] which is between m and n. That can be done by N=p*q processors in one step, thus requiring work of N=p*q many actions.<br />
<br />
In the next step, we apply the considered algorithm to the generated array y which has size p. Our algorithm performs work O(p^2) in time O(1) with O(p^2) many processors to do this. So, this step requires only O(p^2) many processors and work and not O(p^2+q^2) as you understood. <br />
<br />
Having found the least i where y[i] holds, we apply the algorithm once again to the part x[i*q..(i+1)*q-1] which is done with work O(q^2) in time O(1) with O(q^2) many processors.<br />
<br />
In total, we have work O(p^2+q^2) in O(1) time with O(p^2+q^2) many processors. Now, we want to find out which values for p and q would be best to minimize p^2+q^2. Obviously, if both would be zero we would have no work to do, so to be more precise, we have to minimize p^2+q^2 with the constraint that p*q=N holds for some constant N. <br />
<br />
That means, q = N/p, and thus, we have to minimize f(p) = p^2 + (N/p)^2 which has a minimum at p=sqrt(N) so that p=q=sqrt(N) follows which yields optimal work O(p^2+q^2) = O(sqrt(N)^2+sqrt(N)^2) = O(N+N) = O(N).* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3320/solutions-to-exam-2022-02-14-accelerated-cascading-problem?show=3321#a3321Thu, 08 Sep 2022 10:58:22 +0000Answered: Translation to LO2
https://q2a.cs.uni-kl.de/3318/translation-to-lo2?show=3319#a3319
It seems to be correct to me.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3318/translation-to-lo2?show=3319#a3319Tue, 06 Sep 2022 13:36:54 +0000Answered: LTL, CTL CTL*
https://q2a.cs.uni-kl.de/3316/ltl-ctl-ctl?show=3317#a3317
S2 is also not true: You have〖E F b〗 = {s0,s1,s2} and thus〖a & E F b〗 = {s1}, thus 〖AX(a & E F b)〗 = {s0;s2}, and since these states cannot be visited only, it follows that S2 holds in none of the states. S1 does also not hold in s0 since the only path leaving there satisfies next that a holds, but then a becomes false so that Ga does not hold.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3316/ltl-ctl-ctl?show=3317#a3317Mon, 05 Sep 2022 18:24:49 +0000Answered: LTL Tool - clarification
https://q2a.cs.uni-kl.de/3307/ltl-tool-clarification?show=3311#a3311
<p>Neither is correct. Better try</p><p>!a &!b & G (!a &!b & X(!a & b) | !a & b & X(!a & !b)) -> F G[a SU b] </p><p>or</p><p>!a &!b & G ((!a &!b -> X(!a & b)) & (!a & b -> X(!a & !b))) -> F G[a SU b] </p><div></div>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3307/ltl-tool-clarification?show=3311#a3311Mon, 05 Sep 2022 10:13:12 +0000Answered: Confusion in Left CTL*
https://q2a.cs.uni-kl.de/3308/confusion-in-left-ctl?show=3310#a3310
<p>No, it is not. The syntax is much richer, and there are many LeftCTL* formulas like E(Fa & Fb) which are not CTL formulas. However, any CTL formula belongs to LeftCTL*, so that CTL ice a strict (and tiny) subset of LeftCTL*. That much about syntax.</p><p>When it comes to semantics, then one can prove that for every LeftCTL* formula, there is an equivalent CTL formula. So, in terms of expressiveness both are the same.</p><p>Therefore, be careful what you mean with "the same".<img title="smiley" alt="smiley" src="https://q2a.cs.uni-kl.de/qa-plugin/wysiwyg-editor/ckeditor/plugins/smiley/images/regular_smile.png" style="height:23px; width:23px"></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3308/confusion-in-left-ctl?show=3310#a3310Mon, 05 Sep 2022 10:10:02 +0000Answered: Understanding behind AF(a ∧ AXa)
https://q2a.cs.uni-kl.de/3306/understanding-behind-af-a-%E2%88%A7-axa?show=3309#a3309
<p>First of all, the portal should be a q2a system for everyone not just a professor is speaking to students, also students can communicate and discuss with other students. To that end, the users are anonymous as I am, too. <img title="wink" alt="wink" src="https://q2a.cs.uni-kl.de/qa-plugin/wysiwyg-editor/ckeditor/plugins/smiley/images/wink_smile.png" style="height:23px; width:23px"></p><p>You explain the formula as it is, I can't do better. Maybe just note that "paths" means always "infinite paths" in temporal logics. Also have a look at slide 38 in the temporal logic chapter, where that formula is also discussed. </p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3306/understanding-behind-af-a-%E2%88%A7-axa?show=3309#a3309Mon, 05 Sep 2022 10:07:42 +0000Answered: Query: 2018.02.14 VRS Problem 6b: Omega Automata
https://q2a.cs.uni-kl.de/3298/query-2018-02-14-vrs-problem-6b-omega-automata?show=3301#a3301
Well, when computing the a-successor for ({s0,s2},{s0}), we have to check the a-transitions from states s0 and s2. There is no transition with input a from s0, and from s2, the there is one to state s0. Hence, we get suc∃({s0,s2},a) = {s0} and suc∃({s0},a) = {}, the intersection with the accepting states does not change that, and thus we get state ({s0},{}).* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3298/query-2018-02-14-vrs-problem-6b-omega-automata?show=3301#a3301Sun, 04 Sep 2022 20:24:20 +0000Answered: [DOUBT] CTL model checking from Exercise 12
https://q2a.cs.uni-kl.de/3296/doubt-ctl-model-checking-from-exercise-12?show=3297#a3297
<p>I don't understand your argumentation about AF b, and I think that you are confused with EFb and AFb. Also, Fb is a path formula so that is does not make sense to reason about the set of states where Fb holds. </p><p>You may argue that the states {s0, s1, s3, s4, s5, s6} form a strongly connected component so that any state in this set can be reached by any other state in this set. Since one of these states satisfies b, you can argue this way that EF b = {s0, s1, s3, s4, s5, s6}, but AFb is another thing. </p><p>The teaching tool explains that clearly. AFb is µZ.(b | []Z) so that the fixpoint computation is done as follows:</p><pre> 〖b〗= {s0;s1;s6}
step 0 : Z = {}
〖Z〗= {}
〖[] Z〗 = {s2}
〖b | [] Z〗 = {s0;s1;s2;s6}
step 1 : Z = {s0;s1;s2;s6}
〖Z〗= {s0;s1;s2;s6}
〖[] Z〗 = {s2}
〖b | [] Z〗 = {s0;s1;s2;s6}
〖Z〗= {s0;s1;s2;s6}
Hence, the fixpoint computation starts with b-states and deadend states, and adds universal predecessors until a fixpoint is reached.</pre>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3296/doubt-ctl-model-checking-from-exercise-12?show=3297#a3297Sun, 04 Sep 2022 19:37:04 +0000Answered: How to determinize NDetF symbolically and explicitly?
https://q2a.cs.uni-kl.de/3293/how-to-determinize-ndetf-symbolically-and-explicitly?show=3294#a3294
<p>Q1: Yes, {r} is the sink state, in the sense it is that state that is added as target state by the subset construction for the missing transitions. But also {q} is a sink state.</p><p>Q2: We do not need state {r,q} in the sense that the subset construction does not generate that state. However, as we encode the states by two state variables, we get four states and have to deal with the fourth state.</p><p>Q3: The transition relation can be encoded in different ways. Since it is deterministic, one can also write it as a conjunction of equations </p><p> (r′ ↔ r ∨ ¬r∧¬q∧¬a∧¬b) ∧ (q′ ↔ q ∨ ¬r∧¬q∧b)</p><p>(See also the updated example solutions)</p><div class="page" title="Page 21" style="caret-color: rgb(0, 0, 0); color: rgb(0, 0, 0);"><div class="layoutArea"><div class="column"><p></p></div></div></div>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3293/how-to-determinize-ndetf-symbolically-and-explicitly?show=3294#a3294Sun, 04 Sep 2022 18:47:49 +0000Answered: [DOUBT] Translation of temporal formula to LO2
https://q2a.cs.uni-kl.de/3281/doubt-translation-of-temporal-formula-to-lo2?show=3285#a3285
F[a WU b] is translated to <br />
<br />
∃t1. t0≤t1 ∧ (∀t0. (t1≤t0 ∧ (∀t2. (t1≤t2 ∧ t2≤t0 → ¬b[t2])) → a[t0]))<br />
<br />
which has a free occurrence of t0 and also bound occurrences. You may rename the bound occurrences and then you get the following<br />
<br />
∃t1. t0≤t1 ∧ (∀t3. (t1≤t3 ∧ (∀t2. (t1≤t2 ∧ t2≤t3 → ¬b[t2])) → a[t3]))<br />
<br />
If now now exchange t2 and t3, you get your formula.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3281/doubt-translation-of-temporal-formula-to-lo2?show=3285#a3285Sun, 04 Sep 2022 08:22:33 +0000Answered: Deterministic Omega Automata
https://q2a.cs.uni-kl.de/3283/deterministic-omega-automata?show=3284#a3284
An automaton is deterministic iff it has only one initial state and the transition relation is a total function from inputs and states to states. Hence, every word has a unique run. That is all that you need.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3283/deterministic-omega-automata?show=3284#a3284Sun, 04 Sep 2022 08:17:41 +0000Answered: [DOUBT] Translation of omega automaton to LO2
https://q2a.cs.uni-kl.de/3276/doubt-translation-of-omega-automaton-to-lo2?show=3279#a3279
Yes, you are right, that should be an implication, and it has now be fixed. Thank you for point out that mistake!* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3276/doubt-translation-of-omega-automaton-to-lo2?show=3279#a3279Sat, 03 Sep 2022 14:50:41 +0000Answered: Zielonka’s Algorithm for Parity Games: Example
https://q2a.cs.uni-kl.de/3275/zielonkas-algorithm-for-parity-games-example?show=3278#a3278
<p>Attractors are computed as explained on slide 150, and some or their properties are also mentioned there. Hence, your formulas for the attractors are correct. For this reason, computing attractors is done by µ-calculus model checking.</p><p>About your second question, win1'={s0, s1, s2, s3} is not a path, but the set of states where player 1 has a winning strategy. We thereby consider the game on page 161 and yes, the highest rank of the four states is the rank of state s1 which is 16 and that number is even. However, state s1 cannot be visited infinitely often. There are just two paths, the one where we always loop in s0 such that the highest rank would be 3, and the other path is s3 s1 (s2 s4)^omega where the states visited infinitely often are s2 and s3 and thus the highest rank visited infinitely often is 5 which is also odd, so that player 1 also wins that play.</p><p>For the game on page 160 that you consider, we have to compute attr1({s4}) and later then also attr0(win0') for the second recursive call. These are computed in the game that is considered as a Kripke structure with the above fixpoints. Hence, in detail, the computation is as follows:</p><p><img alt="" src="https://q2a.cs.uni-kl.de/?qa=blob&qa_blobid=13446782352843037850" style="height:565px; width:160px"></p><p><span style="font-size:14px"> µx.(p <span style="font-family:"Apple Symbols"">∨</span> a<span style="font-family:"Apple Symbols"">∧</span><>φ <span style="font-family:"Apple Symbols"">∨</span> b<span style="font-family:"Apple Symbols"">∧</span>[]φ):</span></p><p>〖p〗= {s4}</p><p>〖q〗= {s5;s6}</p><p>〖a〗= {s0;s1;s2;s3;s4;s5}</p><p>〖b〗= {s6}</p><p></p><pre>step 0 : x = {}
〖x〗= {}
〖<> x〗 = {}
〖[] x〗 = {}
〖a & [] x〗 = {}
〖b & <> x〗 = {}
〖p | a & [] x | b & <> x〗 = {s4}
step 1 : x = {s4}
〖x〗= {s4}
〖<> x〗 = {s3}
〖[] x〗 = {}
〖a & [] x〗 = {}
〖b & <> x〗 = {}
〖p | a & [] x | b & <> x〗 = {s4}
fixpoint reached!</pre><p>and the second attractor:</p><p><span style="font-size:14px">computing states of mu x:bool. (q | a & <> x | b & [] x)</span></p><pre>step 0 : x = {}
〖x〗= {}
〖<> x〗 = {}
〖a & <> x〗 = {}
〖[] x〗 = {}
〖b & [] x〗 = {}
〖q | a & <> x | b & [] x〗 = {s5;s6}
step 1 : x = {s5;s6}
〖x〗= {s5;s6}
〖<> x〗 = {s4;s5;s6}
〖a & <> x〗 = {s4;s5}
〖[] x〗 = {s4;s6}
〖b & [] x〗 = {s6}
〖q | a & <> x | b & [] x〗 = {s4;s5;s6}
step 2 : x = {s4;s5;s6}
〖x〗= {s4;s5;s6}
〖<> x〗 = {s3;s4;s5;s6}
〖a & <> x〗 = {s3;s4;s5}
〖[] x〗 = {s4;s6}
〖b & [] x〗 = {s6}
〖q | a & <> x | b & [] x〗 = {s3;s4;s5;s6}
step 3 : x = {s3;s4;s5;s6}
〖x〗= {s3;s4;s5;s6}
〖<> x〗 = {s2;s3;s4;s5;s6}
〖a & <> x〗 = {s2;s3;s4;s5}
〖[] x〗 = {s2;s4;s6}
〖b & [] x〗 = {s6}
〖q | a & <> x | b & [] x〗 = {s2;s3;s4;s5;s6}
step 4 : x = {s2;s3;s4;s5;s6}
〖x〗= {s2;s3;s4;s5;s6}
〖<> x〗 = {s1;s2;s3;s4;s5;s6}
〖a & <> x〗 = {s1;s2;s3;s4;s5}
〖[] x〗 = {s1;s2;s3;s4;s6}
〖b & [] x〗 = {s6}
〖q | a & <> x | b & [] x〗 = {s1;s2;s3;s4;s5;s6}
step 5 : x = {s1;s2;s3;s4;s5;s6}
〖x〗= {s1;s2;s3;s4;s5;s6}
〖<> x〗 = {s0;s1;s2;s3;s4;s5;s6}
〖a & <> x〗 = {s0;s1;s2;s3;s4;s5}
〖[] x〗 = {s1;s2;s3;s4;s5;s6}
〖b & [] x〗 = {s6}
〖q | a & <> x | b & [] x〗 = {s0;s1;s2;s3;s4;s5;s6}
step 6 : x = {s0;s1;s2;s3;s4;s5;s6}
〖x〗= {s0;s1;s2;s3;s4;s5;s6}
〖<> x〗 = {s0;s1;s2;s3;s4;s5;s6}
〖a & <> x〗 = {s0;s1;s2;s3;s4;s5}
〖[] x〗 = {s0;s1;s2;s3;s4;s5;s6}
〖b & [] x〗 = {s6}
〖q | a & <> x | b & [] x〗 = {s0;s1;s2;s3;s4;s5;s6}
fixpoint reached!</pre>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3275/zielonkas-algorithm-for-parity-games-example?show=3278#a3278Sat, 03 Sep 2022 14:40:46 +0000Answered: Is this correct?
https://q2a.cs.uni-kl.de/3268/is-this-correct?show=3273#a3273
That is not true, you can easily check that the following formula is valid using the LTL prover:<br />
<br />
G(!a&!b) -> !(FG(a&!b) nor G(a&!b) & G!b) & !F G(a&!b)<br />
<br />
Hence, both formulas are false. It is clear that G!b holds, but neither FG(a&!b) nor G(a&!b) would hold, since a does not hold always (as you wrote). But FG(a&!b) is not equivalent to G(a&!b). Moreover, F[a WU b] is equivalent to F (b | G a) which is also not true.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3268/is-this-correct?show=3273#a3273Sat, 03 Sep 2022 08:09:18 +0000Answered: LTL,CTL, CTL*
https://q2a.cs.uni-kl.de/3269/ltl-ctl-ctl?show=3272#a3272
<p>Yes, that is true which you can check with the LTL prover:</p><pre>(a&!b) &
G( ((a&!b)->X(!a&b)) &
((!a&b)->X(a&!b))
)
-> !((G a) & (F b)) & (G[a SU b])</pre><div></div>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3269/ltl-ctl-ctl?show=3272#a3272Sat, 03 Sep 2022 08:01:28 +0000Answered: LTL,CTL,CTL*
https://q2a.cs.uni-kl.de/3270/ltl-ctl-ctl?show=3271#a3271
<p>You have</p><pre> 〖AG a〗 = {s1;s3}
〖AF AG a〗 = {s0;s1;s2;s3}
〖!a & A F A G a〗 = {s0;s2}
〖AFG a〗 = {s0;s1;s2;s3}
〖!a & AFG a〗 = {s0;s2}
</pre><div>Hence, both formulas are satisfied, I think.</div>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3270/ltl-ctl-ctl?show=3271#a3271Sat, 03 Sep 2022 07:57:48 +0000Answered: ω-automata Exam 2022.02.16 5b
https://q2a.cs.uni-kl.de/3263/%CF%89-automata-exam-2022-02-16-5b?show=3266#a3266
As mentioned in the Q&A session today, that is done as follows: For a deterministic automaton, we can always write down the transition relation as a conjunction of equivalences of the form Xq_i <-> phi_i such that phi_i is a propositional logic formula on the current state and input variables that enumerates all transitions pointing to a state where q_i holds next.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3263/%CF%89-automata-exam-2022-02-16-5b?show=3266#a3266Fri, 02 Sep 2022 14:27:14 +0000Answered: Breakpoint construction doubt
https://q2a.cs.uni-kl.de/3259/breakpoint-construction-doubt?show=3265#a3265
<p>In general, I do not recommend such "optimizations" since they quickly lead to mistakes. Automata store something about the previous input sequence in the states, and maybe you destroy that invariant with your "optimizations". Your suggestions turn out to be incorrect, I tried them with a tool, in that I called the original states q0,q1,q2,q3,q4 and the new ones of your automaton p0,p1,p2,p3,p4 and then stated that ((F G (q3|q4)) <-> F G(p3|p4)) holds. I got then the following counterexample:</p><pre>-> State: 1.1 <-
a = TRUE
q0 = TRUE
q1 = FALSE
q2 = FALSE
q3 = FALSE
q4 = FALSE
p0 = TRUE
p1 = FALSE
p2 = FALSE
p3 = FALSE
p4 = FALSE
-> State: 1.2 <-
a = FALSE
q0 = FALSE
q1 = TRUE
p0 = FALSE
p1 = TRUE
-> State: 1.3 <-
a = TRUE
q1 = FALSE
q3 = TRUE
p1 = FALSE
p3 = TRUE
-> State: 1.4 <-
a = FALSE
q3 = FALSE
q4 = TRUE
p3 = FALSE
p4 = TRUE
-> State: 1.5 <-
a = TRUE
q3 = TRUE
q4 = FALSE
p3 = TRUE
p4 = FALSE
-> State: 1.6 <-
q3 = FALSE
q4 = TRUE
p3 = FALSE
p4 = TRUE
-> State: 1.7 <-
a = FALSE
p3 = TRUE
p4 = FALSE
-> State: 1.8 <-
a = TRUE
q3 = TRUE
q4 = FALSE
p2 = TRUE
p3 = FALSE
-- Loop starts here
-> State: 1.9 <-
a = FALSE
q3 = FALSE
q4 = TRUE
-> State: 1.10 <-
a = TRUE
q3 = TRUE
q4 = FALSE
-> State: 1.11 <-
a = FALSE
q3 = FALSE
q4 = TRUE</pre><div></div><p></p>* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3259/breakpoint-construction-doubt?show=3265#a3265Fri, 02 Sep 2022 14:25:19 +0000Answered: LTL,CTL & CTL*
https://q2a.cs.uni-kl.de/3252/ltl-ctl-%26-ctl?show=3257#a3257
No that does not really make sense to me, maybe I got something wrong. First of all, it is not the case that [a WU b] is equivalent to (F b) | (G a), why do you think so?<br />
<br />
I am also not sure whether you are drawing one or two structures since there are two states with label s0. <br />
<br />
The path with the self-loop on the second state s0 satisfies G(a&b) and therefore also [a WU b], but it does not satisfy F!a. However, it does also not satisfy [b SB !a] since b does not hold before a, but at the same time.<br />
<br />
The other path starting in the left state s0 satisfies [a WU b] since b immediately holds, and it also satisfies F!a since in s1, !a holds. Hence, it satisfies S1. It does not satisfy S2 so it is opposite to what you wrote.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3252/ltl-ctl-%26-ctl?show=3257#a3257Fri, 02 Sep 2022 09:05:15 +0000Answered: Computing deadend/reachable states symbolically
https://q2a.cs.uni-kl.de/3253/computing-deadend-reachable-states-symbolically?show=3256#a3256
The definition of deadend states is not clear in the literature. That's why in the VRS course, we distinguish between deadend and finally deadend states to make precise what we mean. However, that distinction has been only recently introduced, and was not there some years ago. At that time, "deadend state" has been derived from the context, i.e., temporal logics have trouble with finally deadend states, and also induction hast that problem. The computation shown above computes the finally deadend states, since the states that have no outgoing transition are clearly those that satisfy []false while the finally deadend states are those that satisfy A false.* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3253/computing-deadend-reachable-states-symbolically?show=3256#a3256Fri, 02 Sep 2022 08:42:29 +0000Confusion between F and G
https://q2a.cs.uni-kl.de/3254/confusion-between-f-and-g
We know that in the case of Fa, a has to come at least once. Is there any possibility in which 'a' comes in every state in the case of Fa?* TF "Emb. Sys. and Rob."https://q2a.cs.uni-kl.de/3254/confusion-between-f-and-gThu, 01 Sep 2022 20:54:56 +0000