[CS@TUK] Questions and Answers  Recent questions and answers in * TF "Intelligent Systems"
https://q2a.cs.unikl.de/qa/teachingfieldintelligentsystems
Powered by Question2AnswerAnswered: Greatest simulation relation
https://q2a.cs.unikl.de/2553/greatestsimulationrelation?show=2555#a2555
<p>You mean s5q2 in SIM1, I guess.</p><p>No, the solution is correct as far as I can say. For checking whether K1<=K2 holds, you have to check the following diagrams:</p><pre style="boxsizing: borderbox; overflow: auto; fontfamily: Menlo, Monaco, Consolas, "Courier New", monospace; fontsize: 13px; padding: 9.5px; margintop: 0px; marginbottom: 10px; lineheight: 1.42857; wordbreak: breakall; backgroundcolor: rgb(245, 245, 245); border: 1px solid rgb(204, 204, 204); bordertopleftradius: 4px; bordertoprightradius: 4px; borderbottomrightradius: 4px; borderbottomleftradius: 4px;"> S0 > {}

Q0 > {Q1;Q3}
S0 > {}

Q1 > {Q0;Q2}
S0 > {}

Q3 > {Q1}
S1 > {S0;S2}

Q0 > {Q1;Q3}
S1 > {S0;S2}

Q1 > {Q0;Q2}
S1 > {S0;S2}

Q3 > {Q1}
S2 > {S0;S3}

Q2 > {Q0}
S3 > {S0;S4}

Q0 > {Q1;Q3}
S3 > {S0;S4}

Q1 > {Q0;Q2}
S3 > {S0;S4}

Q3 > {Q1}
S4 > {S0;S5}

Q0 > {Q1;Q3}
S4 > {S0;S5}

Q1 > {Q0;Q2}
S4 > {S0;S5}

Q3 > {Q1}
S5 > {S0}

Q2 > {Q0}
</pre><p>Checking a diagram means to check whether for every state s1' in the upper right corner, you find a state s2' in the lower right corner such that (s1',s2') are in the current relation. So, if the set in the upper right corner is empty, you don't have to check anything, and things are fine.</p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2553/greatestsimulationrelation?show=2555#a2555Sun, 29 Aug 2021 11:14:20 +0000Answered: wautomata
https://q2a.cs.unikl.de/2535/wautomata?show=2541#a2541
Well, that is simply something that you need to learn (and to remember). On slide 44 of the omegaautomata chapter, the boolean operations on omegaautomata are described, slides 50 and 51 describe how boolean operations on the acceptance conditions can be performed (if at all), and slides 60 and 61 discuss which automata can be expressed in terms of weaker ones. <br />
<br />
On slide 60, you find the formula that is used in the solution to express Fb as a deterministic FGautomaton. <br />
<br />
Maybe these slides are a recommendation for a cheat sheet.* TF "Intelligent Systems"https://q2a.cs.unikl.de/2535/wautomata?show=2541#a2541Fri, 27 Aug 2021 09:40:46 +0000Answered: Global model checking
https://q2a.cs.unikl.de/2537/globalmodelchecking?show=2540#a2540
<p>That seems to be a little mistake. Actually, there is no variable d and the formula does not ask for an implication inf>d. It seems that when producing a comprehensive solution, we have abbreviated the states satisfying EF c by d. Assuming this, we have</p><pre><span style="fontsize:14px"> [inf] = {s0;...;s6}
[!inf] = {s7}
[d] = [EF c] = {s0;s1;s2;s3;s4;s5;s6} = [inf]
[inf > EF c] = [!inf  EF c] = {s7} ∪ {s0;...;s6} = {s0;...;s7}</span></pre>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2537/globalmodelchecking?show=2540#a2540Fri, 27 Aug 2021 09:28:42 +0000Answered: ROBDD variable ordering
https://q2a.cs.unikl.de/2529/robddvariableordering?show=2530#a2530
In the worst case, yes, you may have to compute for the Boolean function a new BDD with the new variable ordering. However, you may do that incrementally using the swap operation that exchanges to neighboring variables in the variable order, and you may consider "local symmetries" like a&b > c where a and b are symmetric in a certain sense.* TF "Intelligent Systems"https://q2a.cs.unikl.de/2529/robddvariableordering?show=2530#a2530Thu, 26 Aug 2021 15:07:47 +0000Answered: Acceptance condition in LTL to Muautomaton
https://q2a.cs.unikl.de/2517/acceptanceconditioninltltomuautomaton?show=2518#a2518
<pre>The formula considered in that exam problem was G[a SU b]  [F c WB a], so that we abbreviate
<span style="fontsize:14px"> q0 = [a SU b] / trans: q0<> b  a & Xq0 / constraint: GF[q0→b]
q1 = G q0 / trans: q1 <> q0 & Xq1 / constraint: GF[q0→q1]
q2 = F c / trans: q2 <> c  Xq2 / constraint: GF[q2→c]
q3 = [q2 WB a] / trans: q3 <> !a & (q2  Xq3) / constraint: GF[q3∨a]</span>
You may add all four constraints, but as explained on slides 8183, it is sufficient to list the constraints only for negative occurrences of weak and positive occurrences of strong operators. Hence, we only need the constraints for q0 and q2. It is also correct to add both constrains for q1 and q3 or one of them. See also the examples after slide 83.</pre>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2517/acceptanceconditioninltltomuautomaton?show=2518#a2518Mon, 23 Aug 2021 15:28:31 +0000Answered: local model checking.
https://q2a.cs.unikl.de/2502/localmodelchecking?show=2503#a2503
Local model checking is a topdown procedure which means that the question whether s5 satisfies !b, i.e., the sequent s5  !b is reduced to the question whether s5 satisfies b, i.e., s5  b. Once propositional variables are found on the right hand side, we can check the truth value by considering the label of state s5. In this case, s5 is labeled with b, so b holds in s5, and therefore, we have s5  b. For this reason, we do not have s5  !b and neither do we have s5  a&!b, so this result propagates upwards the tree.<br />
<br />
About the selection of s4 for the subgoal: That was a matter of luck, the tool stops when the first subgoal of a disjunctive split is satisfied.* TF "Intelligent Systems"https://q2a.cs.unikl.de/2502/localmodelchecking?show=2503#a2503Wed, 11 Aug 2021 11:42:39 +0000Answered: CTL, LTL and CTL∗
https://q2a.cs.unikl.de/2500/ctlltlandctl%E2%88%97?show=2501#a2501
<p></p><p>You can try the model checker in the teaching tools with the following transition system</p><pre> vars b,c;
init 0;
labels 0:c; 1:; 2:b;
transitions 0>1; 1>2; 2>2;
</pre><p>and properties</p><pre>c ∧ E X(b∧¬c);
c ∧ E X E F(b∧¬c);
</pre><p>You will then see that</p><ul><li> 〖b〗= {s2}</li><li> 〖c〗= {s0}</li><li> 〖!c〗= {s1;s2}</li><li> 〖b & !c〗 = {s2}</li><li> 〖EX(b & !c)〗 = {s1;s2}</li><li> 〖c & EX(b & !c)〗 = {}</li><li> 〖EF(b & !c)〗 = {s0;s1;s2}</li><li> 〖EX EF (b & !c)〗 = {s0;s1;s2}</li><li> 〖c & EX EF (b & !c)〗 = {s0}</li></ul><p>The latter is clear since c holds on s0, and s0 has a next state, namely s1, such that EF(b & !c) holds there. Note that b & !c holds on s2, and that s2 can be reached from s0;s1;s2.</p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2500/ctlltlandctl%E2%88%97?show=2501#a2501Mon, 09 Aug 2021 20:37:37 +0000Answered: ωAutomata
https://q2a.cs.unikl.de/2498/%CF%89automata?show=2499#a2499
<p>Have a look at <a rel="nofollow" href="https://q2a.cs.unikl.de/2492/ωautomatafeb2021">https://q2a.cs.unikl.de/2492/ωautomatafeb2021</a></p><p></p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2498/%CF%89automata?show=2499#a2499Mon, 09 Aug 2021 09:32:45 +0000Answered: Symbolic Representation of Kripke Structures
https://q2a.cs.unikl.de/2486/symbolicrepresentationofkripkestructures?show=2488#a2488
<p>You just consider the transition relation ((q⊕p′)∨(p∨q′))∧(p′⊕q′) and use the constant values, i.e.,</p><pre><span style="fontsize:12px">p=0 and q=0 : ((0⊕p′)∨(0∨q′))∧(p′⊕q′) = (p′∨q′)∧(p′⊕q′) = p′⊕q′
p=0 and q=1 : ((1⊕p′)∨(0∨q′))∧(p′⊕q′) = (!p′∨q′)∧(p′⊕q′) = (p'?0:q') = !p′∧q′
p=1 and q=0 : ((0⊕p′)∨(1∨q′))∧(p′⊕q′) = p′⊕q′
p=1 and q=1 : ((1⊕p′)∨(1∨q′))∧(p′⊕q′) = p′⊕q′</span></pre>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2486/symbolicrepresentationofkripkestructures?show=2488#a2488Tue, 03 Aug 2021 13:58:10 +0000Answered: Simplex Algorithm
https://q2a.cs.unikl.de/2484/simplexalgorithm?show=2485#a2485
The part you copied about has already found a rational solution for the inequalities, but we have to find an integer solution. As explained on slide 78, this is done by a branch and bound method, where we pick the first variable (x0) that is not mapped to an integer (v0=11/9) and restart the simplex algorithm with v0' := floor(11/9) = 1 (this is the first line you copied and the constraint for x0 was to be <= +oo). If that would not succeed, we would try again with v0'' := ceil(11/9) = 2. <br />
<br />
Using v0' violates the (strengthened) constraint for x0, so that we have to make a pivoting step with x0 and y1.<br />
<br />
Then we pick the next noninteger value, which is x1 = 1/3 and restart the simplex algorithm with floor (1/3) = 1 (if that would not succeed, we would try again with ceil(1/3) = 0) and so on...* TF "Intelligent Systems"https://q2a.cs.unikl.de/2484/simplexalgorithm?show=2485#a2485Tue, 03 Aug 2021 09:31:30 +0000Answered: LTL Model Checking
https://q2a.cs.unikl.de/2480/ltlmodelchecking?show=2481#a2481
Problem 6 has two parts: Part a) asks for translating a given LTL formula to an equivalent omegaautomaton. There is a simple algorithm for this that you can find in the lecture slides. This algorithm makes use of a table that determines for each temporal logic operator the required transition relation and acceptance condition. These just have to be written down to obtain the omegaautomaton listed in part a). <br />
<br />
Part b) discusses whether two LTL formulas are equivalent based on a given path that consists of a cycle of three states s0>s1>s2>s0>... such that s0 is labeled with {b}, s1 is labeled with {a}, and s2 is labeled with {a,c}. You have to determine the truth values of the subformulas to finally see whether the given formulas are satisfied the same way on the given path or not. As shown in the solution, the formulas are evaluated differently, so that the path is a counterexample to the claim that the two formulas are equivalent. They are not equivalent as demonstrated with that path, and you should explain why that path tells us so.* TF "Intelligent Systems"https://q2a.cs.unikl.de/2480/ltlmodelchecking?show=2481#a2481Mon, 02 Aug 2021 11:36:21 +0000Answered: Problem 1D
https://q2a.cs.unikl.de/2439/problem1d?show=2440#a2440
<p>The two cubes <span style="fontfamily:Helvetica,Arial,sansserif">¬b and a∧b∧c are nonoverlapping since they do not share a common model, i.e., </span><span style="fontfamily:Helvetica,Arial,sansserif">¬b</span><span style="fontfamily:Helvetica,Arial,sansserif">∧a∧b∧c is equivalent to false.</span></p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2439/problem1d?show=2440#a2440Wed, 30 Jun 2021 12:33:12 +0000Answered: Boolean quantification
https://q2a.cs.unikl.de/2437/booleanquantification?show=2438#a2438
<p>Formally, exists x. phi is defined as the disjunction of the cofactors, i.e., phi[x<0]  phi[x<1]. In simply words, we ask whether there is a value for x such that phi becomes true. Since there are only values 0 and 1 for x, this is the disjunction phi[x<0]  phi[x<1]. Hence, we need to find a variable assignment that satisfies phi[x<0] or phi[x<1], so that the models of exists x.phi are the models of phi where we just omit the assignment to x.</p><p>In contrast, forall x. phi is defined as the conjunction of the cofactors, i.e., phi[x<0] & phi[x<1]. Hence, we ask whether phi can become true for all values of x, i.e., we need to find a variable assignment that satisfies both phi[x<0] and phi[x<1]. Thus, we take the intersection of models of phi[x<0] and phi[x<1] as the models of forall x. phi.</p><p>Examples:</p><ul><li>exists x. x = true</li><li>exists x. !x = true</li><li>exists x. x&y = y</li><li>exists x. xy = true</li><li>exists x. x>y = true</li><li>exists x. x<>y = true</li></ul><div>Feel free to make more examples using <a href="https://es.cs.unikl.de/tools/teaching/BDDAlgorithms.html" rel="nofollow">https://es.cs.unikl.de/tools/teaching/BDDAlgorithms.html</a> with the Exists and Forall algorithm on the BDDs.</div><div></div>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2437/booleanquantification?show=2438#a2438Wed, 30 Jun 2021 10:37:59 +0000Answered: ROBDD Solution
https://q2a.cs.unikl.de/2430/robddsolution?show=2431#a2431
<p>As explained in part 1c of that exam, the formula holds if and only if exactly two of the four variables a,b,c,d are true which are exactly six assignments to these variables. Hence, it is a symmetric function, and these functions have BDDs that look the same for all variable orderings (just the labels of the nodes are changed, but the same number of nodes and the same transitions are there for different variable orderings). Hence, once you got one of the BDDs, you get them for all variable orderings. To get one of them, you need to list the six assignments where exactly two of the variables are true. These are the following ones:</p><ul><li><span style="fontfamily:OpenSans,Arial,sansserif; fontsize:14px">!a&b&!c&d</span></li><li><span style="fontfamily:OpenSans,Arial,sansserif; fontsize:14px">!a&!b&c&d</span></li><li><span style="fontfamily:OpenSans,Arial,sansserif; fontsize:14px">a&b&!c&!d</span></li><li><span style="fontfamily:OpenSans,Arial,sansserif; fontsize:14px">a&!b&c&!d</span></li><li><span style="fontfamily:OpenSans,Arial,sansserif; fontsize:14px">a&!b&!c&d</span></li><li><span style="fontfamily:OpenSans,Arial,sansserif; fontsize:14px">!a&b&c&!d</span></li></ul><div><span style="fontfamily:OpenSans, Arial, sansserif"><span style="fontsize:14.000000953674316px">It should be straightforward from there to construct the BDD with any variable ordering.</span></span></div>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2430/robddsolution?show=2431#a2431Mon, 28 Jun 2021 13:14:54 +0000Answered: LTL Equivalence Exercise 8 1c
https://q2a.cs.unikl.de/2425/ltlequivalenceexercise81c?show=2428#a2428
<p>Please consider the answer of <a rel="nofollow" href="https://q2a.cs.unikl.de/2423/ltlequivalenceexercise81a">https://q2a.cs.unikl.de/2423/ltlequivalenceexercise81a</a></p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2425/ltlequivalenceexercise81c?show=2428#a2428Fri, 25 Jun 2021 15:44:43 +0000Answered: LTL Equivalence Exercise 8 1b
https://q2a.cs.unikl.de/2424/ltlequivalenceexercise81b?show=2427#a2427
<p>Simply consider the answer of <a rel="nofollow" href="https://q2a.cs.unikl.de/2423/ltlequivalenceexercise81a">https://q2a.cs.unikl.de/2423/ltlequivalenceexercise81a</a></p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2424/ltlequivalenceexercise81b?show=2427#a2427Fri, 25 Jun 2021 15:44:19 +0000Answered: LTL Equivalence Exercise 8 1a
https://q2a.cs.unikl.de/2423/ltlequivalenceexercise81a?show=2426#a2426
<p>Well, have a look at <a rel="nofollow" href="https://q2a.cs.unikl.de/2418/exercize8problem1b">https://q2a.cs.unikl.de/2418/exercize8problem1b</a>.</p><p>Simply adapt that to your problem: Given formulas S1=[b SU [c WU a]] and S2=[b SU [c SU a]], we first check whether the one implies the other one.</p><p>The tool quickly tells us that [b SU [c SU a]] > [b SU [c WU a]] is valid, while we get a counterexample for [b SU [c WU a]] > [b SU [c SU a]] so that S1&!S2 is satisfiable. That counterexample consists of an infinite path where G(!a&!b&c) holds. Hence, we know that the following are valid:</p><ul><li>G(!a&!b&c) > [b SU [c WU a]]</li><li>G(!a&!b&c) > ![b SU [c SU a]]</li></ul><p>which is also easily seen with the semantics of the LTL operators. Hence, we already have a first formula to distinguish between the two formulas, namely G(!a&!b&c).</p><p>To find a second one, we ask the tool whether this is the only counterexample in that we let the tool check the following</p><p> !G(!a&!b&c) > ([b SU [c WU a]] > [b SU [c SU a]])</p><p>A counterexamle would satisfy !G(!a&!b&c) & [b SU [c WU a]] & ![b SU [c SU a]]. The tools gives a counterexample which is an infinite path where G(!a&b&c) holds. So, we have a second counterexample.</p><p>So, since S1&!S2 is satisfiable, we have case 1 mentioned in the exercise, so that your answer could be</p><p>1; G(!a&!b&c); G(!a&b&c)</p><p>Right?</p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/2423/ltlequivalenceexercise81a?show=2426#a2426Fri, 25 Jun 2021 15:43:38 +0000Answered: What is the intuition behind the "correctness" of k fold cross validation?
https://q2a.cs.unikl.de/2330/whattheintuitionbehindcorrectnessfoldcrossvalidation?show=2331#a2331
Hi dimant, thank you for the great question! <br />
<br />
You are right. Sadly, CV *over*estimates the error of f, the classifier trained on all data. This means the true error of f will usually be slightly lower. In this sense, CV gives a conservative estimate: in truth, f is even more accurate than CV lets us think.<br />
<br />
There is no way to measure the error of f. To measure it, we would need to train on all data, but then no data would be left for testing. The best we can do is to take:<br />
k := n1<br />
This method, called leaveoneout CV (LOOCV) will give you a very, very precise estimate of the error of the classifier trained on all data. As far as I know, Billy is preparing an exercise on LOOCV.* TF "Intelligent Systems"https://q2a.cs.unikl.de/2330/whattheintuitionbehindcorrectnessfoldcrossvalidation?show=2331#a2331Sat, 01 May 2021 14:19:30 +0000Answered: Exam Paper: 2019.02.13 Question 6d
https://q2a.cs.unikl.de/1959/exampaper20190213question6d?show=1962#a1962
You are talking about the dark grey state {{q}, {p,q}}{{p,q}} and its transition labeled !a&!b, right?<br />
<br />
The oiginal automaton knows two states: {q} and {p,q}. After reading !b, we go nondeterministically to either of them. That's what the grey state is representing. The two states differ in the inputs for which they have transitions. {q} requires !b, {p,q} is stricter and requires specifically a&!b. That's where the case distinction in the grey state comes from. If we read a&!b, we can takes all transitions of {q} (since we satisfy !b) as well as the transition from {p,q} (which doesn't add more successor states). Hence, a&!b leads to a selfloop in the grey state. For b, we have no transitions anywhere and move to the fail state. It remains to consider !a&!b. Here, the only transitions are ones of {q}.<br />
<br />
The second set in the tuple is the set of accepting successors of the previous second set. As the previous second set contains only {p,q}, which has no successors for !a&!b, the second set is empty in the next state. The first set should (after the standard procedure) be {{q},{p,q}} as we can reach both reading !b in {q}. Apparently, the creator of the suggested solution has merged this newly created state {{q}, {p,q}}{} to {{q}}{}. You can try to convince yourself that this optimization neither adds nor removes accepting runs. However, it is not the standard procedure we taught in class.<br />
<br />
tl;dr: The loop back is more like “ah, snap, we should have nondeterministically stayed in the initial state as we can't close the loop of the accepting state here”.* TF "Intelligent Systems"https://q2a.cs.unikl.de/1959/exampaper20190213question6d?show=1962#a1962Mon, 18 Jan 2021 00:58:22 +0000Answered: Exam 2016 Sept 2.c
https://q2a.cs.unikl.de/1796/exam2016sept2c?show=1800#a1800
Well, you should know that BDDs are making case distinctions on variables. So the above BDD means if c then (if b then 0 else 1) else (if a then 1 else 0) which is the formula (c>!b) & (!c>a). This simply means that we enumerate the paths from the root node to the 1leaf as disjunctions of cubes.* TF "Intelligent Systems"https://q2a.cs.unikl.de/1796/exam2016sept2c?show=1800#a1800Sat, 22 Aug 2020 19:04:27 +0000Answered: LTL equivalnace
https://q2a.cs.unikl.de/1680/ltlequivalnace?show=1681#a1681
<p>As we have ¬F¬a = Ga, and p⊕¬p = 1, it follows that S1 is always true. S2, however, can become false, as you can see with the following traces:</p><pre> a : 0101...
Ga : 0000...
XGa : 0000...
!a : 1010...
G!a : 0000...
(XGa)⊕(G!a) : 0000...
</pre><p>Here, you can see that the ⊕ operator (just as any other boolean operator) will be applied to the corresponding points of time of the two inputs, i.e., p⊕q denotes pointwise xor of the signal p and q. </p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/1680/ltlequivalnace?show=1681#a1681Wed, 19 Aug 2020 21:42:58 +0000Answered: Signal traces
https://q2a.cs.unikl.de/1561/signaltraces?show=1562#a1562
You have to consider the semantics of the temporal operators to decide this. For example, looking at [b SU c], you can already put an 1 at those places where c holds. Then, you consider any prefix before such a place where b holds until that point of time. These points of time also satisfy [b SU c], and the rest doesn't.* TF "Intelligent Systems"https://q2a.cs.unikl.de/1561/signaltraces?show=1562#a1562Mon, 17 Aug 2020 13:52:30 +0000Answered: Translation to mu calculus
https://q2a.cs.unikl.de/1516/translationtomucalculus?show=1519#a1519
Usually, the way to go is to translate a CTL* formula to CTL, and then the µcalculus translation is straightforward. Alternatives are CTL^2, but let's not go into that, and of course, one can also directly translate CTL* to µcalculus, but that is quite difficult. <br />
<br />
So, let's consider the given formula AF[b SU (a&Xa)]. If we could duplicate the path quantifier, i.e., to obtain AFA[b SU (a&Xa)], we would be almost there. However, that is not equivalent, and therefore we cannot do this. Luckily, the LTL formula F[a SU b] means nothing else than Fb, since F[a SU b] means the following in LO1 (which is the semantics):<br />
<br />
∃t0. 0≤t0 ∧ (∃t1. t0≤t1 ∧ (∀t2. (t0≤t2 ∧ t2<t1 → a[t2])) ∧ b[t1])<br />
<br />
It means that there are t0 and t1 with t0≤t1 such that (1) ∀t2. (t0≤t2 ∧ t2<t1 → a[t2]) and (2) b[t1] holds. If such numbers exist, then we can also choose t0:=t1 which satisfies trivially (1). Hence, the above formula is equivalent to Fb.<br />
<br />
So, we consider now the translation of the equivalent formula AF(a&Xa) to the µcalculus. It may seem to be simple to translate this now to CTL, but it is not: At this point, you need to remember lecture slide 36 of the temporal logic chapter. While slide 35 proved that CTL can be translated to the alternationfree µcalculus, slide 36 tells us that this inclusion is strict, since the formula AF(a&Xa) can be translated to the alternationfree µcalculus, but not to CTL. Its equivalence to the given µcalculus formula is proved also on slide 36.* TF "Intelligent Systems"https://q2a.cs.unikl.de/1516/translationtomucalculus?show=1519#a1519Sun, 16 Aug 2020 09:28:14 +0000Answered: Translation
https://q2a.cs.unikl.de/1502/translation?show=1503#a1503
The negation of EF phi is AG ¬phi. (In words: “Not all paths have a point at which something holds” is the same as “There is a path where at every points the opposite of something holds)<br />
<br />
Thus we get AG ¬¬EF a. The double negation cancels itself out. We are left with AGEF a.* TF "Intelligent Systems"https://q2a.cs.unikl.de/1502/translation?show=1503#a1503Sat, 15 Aug 2020 16:22:27 +0000Answered: exam 2019.02. Q7.a
https://q2a.cs.unikl.de/1423/exam201902q7a?show=1424#a1424
q1 abbreviates G(q0) and q0 abbreviates [a SU b] and both occurrences are positive. Hence, we can drop the GF constraint for q1, but must use the one for q0. Same way, q2 abbreviates F c and q3 abbreviates [q2 WB a] with both having positive occurrences, and thus, we just need the GF constraint for q2, but not the one for q3.<br />
<br />
See also slide 82 of the temporal logic chapter.* TF "Intelligent Systems"https://q2a.cs.unikl.de/1423/exam201902q7a?show=1424#a1424Thu, 13 Aug 2020 12:04:02 +0000Answered: Exam 2018.02.14. ques 5.c.
https://q2a.cs.unikl.de/1404/exam20180214ques5c?show=1415#a1415
<p>I do not really see where I can help here; which of the following sentences of the solution troubles you?</p><ul><li>E[a WU false] is equivalent to EGa</li><li>EGa does not hold in any state since all states that satisfy a, i.e., {s1, s6} have only successor states which do not satisfy a. </li><li>EGa reduces to false</li><li>the entire formula reduces to (false → ...) which is true, and therefore holds in all states.</li></ul>* TF "Intelligent Systems"https://q2a.cs.unikl.de/1404/exam20180214ques5c?show=1415#a1415Thu, 13 Aug 2020 09:49:44 +0000Answered: Exam 2019.08. 4d.
https://q2a.cs.unikl.de/1401/exam2019084d?show=1402#a1402
You first consider EGa which are the states that have an outgoing infinite path where a holds. Thus, just consider the astates {s0;s1;s2;s5;s7} and try to find such path starting in these states. Clearly, the cycle s2>s1>s5>s2 is such a path and shows that these state belong to EGa. Also s0 can join this cycle with s0>s5, however, s7 has no outgoing transition and does not satisfy this. Hence, we found that EGa is {s0;s1;s2;s5}.<br />
<br />
AF{s0;s1;s2;s5} are the states where all outgoing paths (if any) will eventually reach one of the states {s0;s1;s2;s5}. This is immediate for states {s0;s1;s2;s5}, and it is easy to see that the rest does also have transitions to this set (and s7 does not have infinite outgoing paths and therefore also satisfies this).* TF "Intelligent Systems"https://q2a.cs.unikl.de/1401/exam2019084d?show=1402#a1402Wed, 12 Aug 2020 19:10:46 +0000Answered: Exam 2018.02. 6a
https://q2a.cs.unikl.de/1365/exam2018026a?show=1367#a1367
<p>The original automaton did not have state s1', and instead accepted all words having a run that eventually stays in states {s0,s1}. Hence, after some time, we should not use the transition s1>s3 any more, since we should stay in {s0,s1} after some time. The same can be achieved with the modified automaton where a copy of state s1 was made as shown above. You can now see that the following is equivalent for any word </p><p></p><p>(1) the word has a run in the original automaton that eventually stays in states {s0,s1}</p><p></p><p>(2) the word has a run in the modified automaton that reaches state s1'</p><p></p><p>For (1)>(2), you just use the run of the original automaton until the point of time where states {s0,s1} are entered, but never left again. Instead of switching from s0>s1 you then switch to s0>s1'. For (2)>(1) it is even simpler; just use the run of the modified automaton but replace s1' by s1.</p><div></div>* TF "Intelligent Systems"https://q2a.cs.unikl.de/1365/exam2018026a?show=1367#a1367Tue, 11 Aug 2020 17:45:22 +0000Answered: VRS Exam 2019.02. Problem 6c.
https://q2a.cs.unikl.de/1358/vrsexam201902problem6c?show=1359#a1359
<p>You just have to determine the satisfying assignments of the transition relation. Why not using the teaching tool <a href="https://es.cs.unikl.de/tools/teaching/SymbolicStateTrans.html" rel="nofollow">https://es.cs.unikl.de/tools/teaching/SymbolicStateTrans.html</a> with the following inputs to doublecheck your result?</p><pre> state variables<span style="whitespace:pre" class="Appletabspan"> </span> : p;q
input variables<span style="whitespace:pre" class="Appletabspan"> </span> : a
initial states<span style="whitespace:pre" class="Appletabspan"> </span> : !p&q
transition relation<span style="whitespace:pre" class="Appletabspan"> </span> : (p > a & next(p)) & !b & q & next(q)
state set<span style="whitespace:pre" class="Appletabspan"> </span> : false</pre><pre>
</pre>* TF "Intelligent Systems"https://q2a.cs.unikl.de/1358/vrsexam201902problem6c?show=1359#a1359Tue, 11 Aug 2020 14:29:15 +0000Answered: VRS Exam 2018.08. Problem 6.a.
https://q2a.cs.unikl.de/1355/vrsexam201808problem6a?show=1356#a1356
You derive the symbolic description of the automaton by determining any propositional logic formula for its transition relation, i.e., any propositional logic formula whose satisfying assignments are the transitions of the automaton. The simplest formula you may derive is a DNF of the transitions. In the above case, that means<br />
<br />
!p&!next(p)  p&!a&next(p)  p&a&!next(p)<br />
<br />
Note that this formula is equivalent to next(p) <> p&!a (as listed in the above figure).* TF "Intelligent Systems"https://q2a.cs.unikl.de/1355/vrsexam201808problem6a?show=1356#a1356Mon, 10 Aug 2020 20:47:34 +0000Answered: Finite State Transition diagram
https://q2a.cs.unikl.de/1350/finitestatetransitiondiagram?show=1351#a1351
The transition relation is an ifthenelse. Since in the first four lines p is false, right part of the ifthenelse (the elsepart) needs to be satisfied. The right part requires p' and a to be equal. This is the case of a = p' = 1 (fourth line), and a = p' = 0 (first line), but not for a = 0, p' = 1 (second line) or a = 1, p' = 0 (third line).* TF "Intelligent Systems"https://q2a.cs.unikl.de/1350/finitestatetransitiondiagram?show=1351#a1351Mon, 10 Aug 2020 18:32:17 +0000Answered: Exists Algorithm
https://q2a.cs.unikl.de/1221/existsalgorithm?show=1222#a1222
<p>According to your figure, we have the following BDD nodes (I guess the missing lowedge of N4 points to 0?):</p><pre> N2 = (a => 1  0)
N3 = (b => 1  N2)
N4 = (c => 1  0)
N5 = (c => N3  0)
N6 = (d => N4  N5)
E2 = (a => 1  0)
E3 = (d => E2  0)
</pre><p>I think that the computation should be as follows:</p><pre> Exists(E3,N6)
= Exists((d => E2  0), (d => N4  N5))
= OR(Exists(E2,N4),Exists(E2,N5))
= OR((c => Exists(E2,1)  Exists(E2,0)),Exists(E2,N5))
= OR((c => 1  0),Exists(E2,N5))
= OR(N4,Exists(E2,N5))
= OR(N4, (c => Exists(E2,N3)  Exists(E2,0)))
= OR(N4, (c => Exists(E2,N3)  0))
= OR(N4, (c => (b ? Exists(E2,1) : Exists(E2,N2))  0))
= OR(N4, (c => (b ? 1 : Exists(E2,N2))  0))
= OR(N4, (c => (b ? 1 : OR(Exists(1,1),Exists(1,0)))  0))
= OR(N4, (c => (b ? 1 : OR(1,0))  0))
= OR(N4, (c => (b ? 1 : 1)  0))
= OR(N4, (c => 1  0))
= OR(N4, N4)
= N4</pre><p>Right?</p><p></p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/1221/existsalgorithm?show=1222#a1222Thu, 30 Jul 2020 19:24:37 +0000Answered: Sequent Calculus
https://q2a.cs.unikl.de/1214/sequentcalculus?show=1215#a1215
<p>Remember that we defined propositional logic on top of the Hilbert base, i.e., negation, conjunction, and disjunction and introduced all other operators as abbreviations. So, you may just use that abbreviation which is how you should read these operators. </p><p>Clearly, any equivalent form will also do, so you can use in particular one of the following two:</p><pre>p⊕q = p&!q  !p&q
p⊕q = (!p!q)&(pq)</pre><p>Which one is better? That depends on your example. Choose a version that minimized branching. </p><p>You may also test which rules are used in the teaching tool for the sequent calculus, and if you create proof trees for <span style="whitespace:prewrap">p⊕q and its negation, you will obtain the following two (internally, there is no </span><span style="whitespace:prewrap">⊕, so it is expanded to a negated equivalence)</span><span style="whitespace:prewrap">:</span></p><p><span style="whitespace:prewrap"><img alt="" src="https://q2a.cs.unikl.de/?qa=blob&qa_blobid=8374451999140344793" style="height:359px; width:381px"></span></p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/1214/sequentcalculus?show=1215#a1215Mon, 27 Jul 2020 17:01:49 +0000Answered: Doubts in Global Model Checking (Exercise Sheet 6)
https://q2a.cs.unikl.de/1006/doubtsinglobalmodelcheckingexercisesheet6?show=1008#a1008
<ol><li>The first doubt is just a typo / attention test. You passed the attention test! Congratulations, and thanks for reporting this!</li><li>The states s3 and s8 satisfy y = {s3, s8}. Besides that, the box operator is a universal quantifier. As s3 and s8 have no successors, it is trivially true that all their successors satisfy any property. That's why they are included in any result of the box operator.</li></ol>* TF "Intelligent Systems"https://q2a.cs.unikl.de/1006/doubtsinglobalmodelcheckingexercisesheet6?show=1008#a1008Sun, 07 Jun 2020 21:27:37 +0000Answered: How the query converted to DNF?
https://q2a.cs.unikl.de/479/howthequeryconvertedtodnf?show=482#a482
<p>You can see that every single minterm (coclause/conjunction of literals containing all variables) is present in the DNF. This looks like the origin is a truth table from which all minterms were formed.</p><table cellpadding="1" border="1" style="width:500px"><tbody><tr><td style="textalign:center">t1</td><td style="textalign:center">t2</td><td style="textalign:center">t3</td><td style="textalign:center">t1&(t2!t3)</td></tr><tr><td style="textalign:center">0</td><td style="textalign:center">0</td><td style="textalign:center">0</td><td style="textalign:center">0</td></tr><tr><td style="textalign:center">0</td><td style="textalign:center">0</td><td style="textalign:center">1</td><td style="textalign:center">0</td></tr><tr><td style="textalign:center">0</td><td style="textalign:center">1</td><td style="textalign:center">0</td><td style="textalign:center">0</td></tr><tr><td style="textalign:center">0</td><td style="textalign:center">1</td><td style="textalign:center">1</td><td style="textalign:center">0</td></tr><tr><td style="textalign:center"><strong>1</strong></td><td style="textalign:center"><strong>0</strong></td><td style="textalign:center"><strong>0</strong></td><td style="textalign:center"><strong>1</strong></td></tr><tr><td style="textalign:center">1</td><td style="textalign:center">0</td><td style="textalign:center">1</td><td style="textalign:center">0</td></tr><tr><td style="textalign:center"><strong>1</strong></td><td style="textalign:center"><strong>1</strong></td><td style="textalign:center"><strong>0</strong></td><td style="textalign:center"><strong>1</strong></td></tr><tr><td style="textalign:center"><strong>1</strong></td><td style="textalign:center"><strong>1</strong></td><td style="textalign:center"><strong>1</strong></td><td style="textalign:center"><strong>1</strong></td></tr></tbody></table><p>The highlighted lines of the truth table represent the satisfying assignments of the formula. The disjunction of the corresponding minterms is exactly the DNF you presented.</p><p>One can also multiply out and get a formula like this:</p><pre>(t1 ∧ t2) ∨ (t1 ∧ ¬t3)</pre><p>The leftmost coclause doesn't contain t3, the right most one doesn't contain t2. This means, that the coclause is satisfied for arbitrary values of the respective variable. One introduce the missing variables by creating one coclause where it is added positively (without negation), and where it is added negatively (with negation). This yields:</p><pre>(t1 ∧ t2 ∧ t3) ∨ (t1 ∧ t2 ∧ ¬t3) ∨ (t1 ∧ t2 ∧ ¬t3) ∨ (t1 ∧ →t2 ∧ ¬t3)</pre><p>The coclause (t1 ∧ t2 ∧ ¬t3) occurs twice. We remove one of the copies and get</p><pre>(t1 ∧ t2 ∧ t3) ∨ (t1 ∧ t2 ∧ ¬t3) ∨ (t1 ∧ →t2 ∧ ¬t3)</pre><p>Exactly the DNF you presented.</p>* TF "Intelligent Systems"https://q2a.cs.unikl.de/479/howthequeryconvertedtodnf?show=482#a482Mon, 27 Apr 2020 16:50:13 +0000