language string | syntax string | semantics-glossary string | mutated bool | semantics-type string | mutation-pattern string | task string | setup-name string | random-mode bool | question string | options list | option_rule_ids list | answer_index int64 | answer_rule_id int64 | sampling_mode string | num_rules int64 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `*` expression are values, the result is obtained by multiplying those two values. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n ---------------------------------------------\n 〈a1 * a2,𝜎,χ〉 → 〈a1' * a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n v3 = v1 * v2\n --------------------------\n 〈v1 * v2,𝜎,χ〉 → v3\n\n }",
"Rule 2 := {\n\n v2 ≠ 0 ... | [
13,
15,
18,
14,
27
] | 1 | 15 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the expression on the right-hand side of `=` can still be evaluated further, then evaluation proceeds by first evaluating that expression. | [
"Rule 0 := {\n\n 𝜎(x) ≠ ⟂\n ----------------------------------------------\n 〈x = v :: SL,𝜎,χ〉 ⇉ 〈SL,𝜎[x ↦ v],χ〉\n\n }",
"Rule 1 := {\n\n 〈a,𝜎,χ〉 → 〈a',𝜎,χ〉\n -----------------------------------------------------------\n 〈x = a :: SL,𝜎,χ〉 ⇉ 〈x... | [
5,
4,
3,
6,
63
] | 1 | 4 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `>` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 > a2,𝜎,χ〉 → 〈v1 > a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 > a2,𝜎,χ〉 → 〈a1' > a2,𝜎,χ〉\n\n }",
... | [
37,
36,
38,
39,
35
] | 1 | 36 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `<=` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -----------------------------------------------\n 〈v1 <= a2,𝜎,χ〉 → 〈v1 <= a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -----------------------------------------------\n 〈a1 <= a2,𝜎,χ〉 → 〈a1' <= ... | [
33,
32,
34,
35,
39
] | 1 | 32 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `<` is already a value and the right operand can still be evaluated, then evaluation proceeds within the right operand. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 < a2,𝜎,χ〉 → 〈a1' < a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 < a2,𝜎,χ〉 → 〈v1 < a2',𝜎,χ〉\n\n }",
... | [
28,
29,
30,
31,
39
] | 1 | 29 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `/` expression are values and the right operand value is not zero, the result is obtained by integer division of the left operand value by the right operand value. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n ---------------------------------------------\n 〈a1 / a2,𝜎,χ〉 → 〈a1' / a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n v2 ≠ 0 v3 = v1 / v2\n ----------------------------\n 〈v1 / v2,𝜎,χ〉 → v3\n\n }",
"Rule 2 := {\n\n ... | [
16,
18,
17,
19,
15
] | 1 | 18 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `*` is already a value and the right operand can still be evaluated, then evaluation proceeds within the right operand. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n ---------------------------------------------\n 〈a1 * a2,𝜎,χ〉 → 〈a1' * a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n ---------------------------------------------\n 〈v1 * a2,𝜎,χ〉 → 〈v1 * a2',𝜎,χ〉\n\n... | [
13,
14,
18,
15,
27
] | 1 | 14 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the predicate `q` in the `LOOP(q) {SL1}` statement is a boolean value and `q = true`, then the statement `LE` is inserted after the statements in statement list `SL1` (LOOP-block) and the execution proceeds with the statements in the statement list `SL1`. | [
"Rule 0 := {\n\n q = false\n -----------------------------------------------\n 〈LOOP(q) {SL1} :: SL,𝜎,χ〉 ⇉ 〈SL,𝜎,pop(χ)〉\n\n }",
"Rule 1 := {\n\n 〈b,𝜎,χ〉 → 〈b',𝜎,χ〉\n ---------------------------------------------------------------\n 〈LOO... | [
69,
68,
70,
65,
77
] | 2 | 70 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `-` expression are values, the result is obtained by subtracting the right operand value from the left operand value. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------------\n 〈a1 - a2,𝜎,χ〉 → 〈a1' - a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n v3 = v1 - v2\n ----------------------------\n 〈v1 - v2,𝜎,χ〉 → v3\n\n }",
"Rule 2 := {\n\n v2 ≠ 0... | [
10,
12,
18,
11,
27
] | 1 | 12 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If a `continue` statement is encountered and the control stack is empty, then an error occurs and the program execution stops immediately. | [
"Rule 0 := {\n\n χ ≠ ε ∧ s = LE s1 = top(χ)\n ----------------------------------------------------\n 〈continue :: s :: SL,𝜎,χ〉 ⇉ 〈s1 :: SL,𝜎,pop(χ)〉\n\n }",
"Rule 1 := {\n\n χ ≠ ε ∧ s ≠ LE\n -----------------------------------------------------\n ... | [
75,
74,
76,
65,
77
] | 2 | 76 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `&&` expression are boolean values and either the left operand value or the right operand value is `false`, the result is `false`. | [
"Rule 0 := {\n\n 〈b1,𝜎,χ〉 → 〈b1',𝜎,χ〉\n ---------------------------------------------\n 〈b1 && b2,𝜎,χ〉 → 〈b1' && b2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n q1 = false ⋁ q2 = false\n -----------------------------\n 〈q1 && q2,𝜎,χ〉 → false\n\n }",
"Rule 2 := {\n\n ... | [
52,
55,
53,
54,
35
] | 1 | 55 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If a variable on the left-hand side of `=` already exists in the program state and the right-hand side of `=` has been fully evaluated to a value, then that variable is updated with that value in the program state. | [
"Rule 0 := {\n\n 〈a,𝜎,χ〉 → 〈a',𝜎,χ〉\n -----------------------------------------------------------\n 〈x = a :: SL,𝜎,χ〉 ⇉ 〈x = a' :: SL,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 𝜎(x) ≠ ⟂\n ----------------------------------------------\n 〈x = v :: SL,𝜎,χ〉 ⇉... | [
4,
5,
3,
6,
63
] | 1 | 5 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the expression on the right-hand side of `=` can still be evaluated further, then evaluation proceeds by first evaluating that expression. | [
"Rule 0 := {\n\n 𝜎(x) ≠ ⟂\n ----------------------------------------------\n 〈x = v :: SL,𝜎,χ〉 ⇉ 〈SL,𝜎[x ↦ v],χ〉\n\n }",
"Rule 1 := {\n\n 〈a,𝜎,χ〉 → 〈a',𝜎,χ〉\n -----------------------------------------------------------\n 〈x = a :: SL,𝜎,χ〉 ⇉ 〈x... | [
5,
4,
3,
6,
63
] | 1 | 4 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `-` expression are values, the result is obtained by subtracting the right operand value from the left operand value. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------------\n 〈a1 - a2,𝜎,χ〉 → 〈a1' - a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n v3 = v1 - v2\n ----------------------------\n 〈v1 - v2,𝜎,χ〉 → v3\n\n }",
"Rule 2 := {\n\n v2 ≠ 0... | [
10,
12,
18,
11,
27
] | 1 | 12 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `<` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 < a2,𝜎,χ〉 → 〈v1 < a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 < a2,𝜎,χ〉 → 〈a1' < a2,𝜎,χ〉\n\n }",
... | [
29,
28,
30,
31,
39
] | 1 | 28 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `<` expression are values and the left operand value is less than the right operand value, the result is `true`. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 < a2,𝜎,χ〉 → 〈a1' < a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n v1 < v2\n ---------------------------\n 〈v1 < v2,𝜎,χ〉 → true\n\n }",
"Rule 2 := {\n\n 〈a2,... | [
28,
30,
29,
31,
39
] | 1 | 30 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the predicate `q` in the `if(q) {SL1} else {SL2}` statement is a boolean value and `q = true`, then the execution proceeds with the statements in the statement list `SL1` (if-block). | [
"Rule 0 := {\n\n q = false\n ---------------------------------------------------------------\n 〈if(q) {SL1} else {SL2} :: SL,𝜎,χ〉 ⇉ 〈SL2 ++ SL,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈b,𝜎,χ〉 → 〈b',𝜎,χ〉\n --------------------------... | [
66,
64,
65,
68,
77
] | 2 | 65 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When a `halt` statement is encountered, the program execution stops immediately. | [
"Rule 0 := {\n\n χ ≠ ε ∧ s ≠ LE\n -----------------------------------------------------\n 〈continue :: s :: SL,𝜎,χ〉 ⇉ 〈continue :: SL,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n q = true\n -----------------------------------------------------------... | [
74,
65,
78,
73,
69
] | 2 | 78 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the expression on the right-hand side of `=` can still be evaluated further, then evaluation proceeds by first evaluating that expression. | [
"Rule 0 := {\n\n 𝜎(x) ≠ ⟂\n ----------------------------------------------\n 〈x = v :: SL,𝜎,χ〉 ⇉ 〈SL,𝜎[x ↦ v],χ〉\n\n }",
"Rule 1 := {\n\n 〈a,𝜎,χ〉 → 〈a',𝜎,χ〉\n -----------------------------------------------------------\n 〈x = a :: SL,𝜎,χ〉 ⇉ 〈x... | [
5,
4,
3,
6,
63
] | 1 | 4 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When a `break` statement is encountered and the statement following it is `LE` and the control stack is not empty, then the control stack is popped and the execution proceeds with the statements following the statements `break` and `LE`. | [
"Rule 0 := {\n\n χ = ε\n -------------------------------------\n 〈break :: SL,𝜎,χ〉 ⇉ 〈ERROR,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n χ ≠ ε ∧ s ≠ LE\n -----------------------------------------------\n 〈break :: s :: SL,𝜎,χ〉 ⇉ 〈break :: SL,𝜎,χ〉\n\n }",
... | [
73,
71,
72,
65,
77
] | 2 | 72 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the operand of a unary expression using `+` can still be evaluated, then evaluation proceeds within that operand. | [
"Rule 0 := {\n\n -----------------------\n 〈+ v,𝜎,χ〉 → v\n\n }",
"Rule 1 := {\n\n 〈a,𝜎,χ〉 → 〈a',𝜎,χ〉\n ---------------------------------------\n 〈+ a,𝜎,χ〉 → 〈+ a',𝜎,χ〉\n\n }",
"Rule 2 := {\n\n 〈a,𝜎,χ〉 → 〈a',𝜎,χ〉\n ---------------------------... | [
27,
26,
24,
15,
22
] | 1 | 26 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the predicate `q` in the `LOOP(q) {SL1}` statement is a boolean value and `q = true`, then the statement `LE` is inserted after the statements in statement list `SL1` (LOOP-block) and the execution proceeds with the statements in the statement list `SL1`. | [
"Rule 0 := {\n\n q = false\n -----------------------------------------------\n 〈LOOP(q) {SL1} :: SL,𝜎,χ〉 ⇉ 〈SL,𝜎,pop(χ)〉\n\n }",
"Rule 1 := {\n\n 〈b,𝜎,χ〉 → 〈b',𝜎,χ〉\n ---------------------------------------------------------------\n 〈LOO... | [
69,
68,
70,
65,
77
] | 2 | 70 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `&&` expression are boolean values and both the left and right operand values are `true`, the result is `true`. | [
"Rule 0 := {\n\n 〈b1,𝜎,χ〉 → 〈b1',𝜎,χ〉\n ---------------------------------------------\n 〈b1 && b2,𝜎,χ〉 → 〈b1' && b2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n q1 = true ⋀ q2 = true\n ----------------------------\n 〈q1 && q2,𝜎,χ〉 → true\n\n }",
"Rule 2 := {\n\n ... | [
52,
54,
53,
55,
35
] | 1 | 54 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `<` is already a value and the right operand can still be evaluated, then evaluation proceeds within the right operand. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 < a2,𝜎,χ〉 → 〈a1' < a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 < a2,𝜎,χ〉 → 〈v1 < a2',𝜎,χ〉\n\n }",
... | [
28,
29,
30,
31,
39
] | 1 | 29 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `||` expression are boolean values and either the left operand value or the right operand value is `true`, the result is `true`. | [
"Rule 0 := {\n\n 〈b1,𝜎,χ〉 → 〈b1',𝜎,χ〉\n -------------------------------------------\n 〈b1 || b2,𝜎,χ〉 → 〈b1' || b2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n q1 = true ⋁ q2 = true\n ---------------------------\n 〈q1 || q2,𝜎,χ〉 → true\n\n }",
"Rule 2 := {\n\n ... | [
56,
58,
57,
59,
35
] | 1 | 58 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If a `continue` statement is encountered and the control stack is empty, then an error occurs and the program execution stops immediately. | [
"Rule 0 := {\n\n χ ≠ ε ∧ s = LE s1 = top(χ)\n ----------------------------------------------------\n 〈continue :: s :: SL,𝜎,χ〉 ⇉ 〈s1 :: SL,𝜎,pop(χ)〉\n\n }",
"Rule 1 := {\n\n χ ≠ ε ∧ s ≠ LE\n -----------------------------------------------------\n ... | [
75,
74,
76,
65,
77
] | 2 | 76 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `>` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 > a2,𝜎,χ〉 → 〈v1 > a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 > a2,𝜎,χ〉 → 〈a1' > a2,𝜎,χ〉\n\n }",
... | [
37,
36,
38,
39,
35
] | 1 | 36 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If a variable is associated with a value in the current program state, then evaluating it yields that value. | [
"Rule 0 := {\n\n 𝜎(x) = ⟂\n --------------------------\n 〈x,𝜎,χ〉 → 〈ERROR,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 𝜎(x) = v\n -------------\n 〈x,𝜎,χ〉 → v\n\n }",
"Rule 2 := {\n\n 〈a,𝜎,χ〉 → 〈a',𝜎,χ〉\n ---------------------------------------\n ... | [
2,
1,
26,
17,
24
] | 1 | 1 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `%` is already a value and the right operand can still be evaluated, then evaluation proceeds within the right operand. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n ---------------------------------------------\n 〈a1 % a2,𝜎,χ〉 → 〈a1' % a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n ---------------------------------------------\n 〈v1 % a2,𝜎,χ〉 → 〈v1 % a2',𝜎,χ〉\n\n... | [
20,
21,
22,
23,
15
] | 1 | 21 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `&&` expression are boolean values and either the left operand value or the right operand value is `false`, the result is `false`. | [
"Rule 0 := {\n\n 〈b1,𝜎,χ〉 → 〈b1',𝜎,χ〉\n ---------------------------------------------\n 〈b1 && b2,𝜎,χ〉 → 〈b1' && b2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n q1 = false ⋁ q2 = false\n -----------------------------\n 〈q1 && q2,𝜎,χ〉 → false\n\n }",
"Rule 2 := {\n\n ... | [
52,
55,
53,
54,
35
] | 1 | 55 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `==` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 == a2,𝜎,χ〉 → 〈v1 == a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 == a2,𝜎,χ〉 → 〈a1' == a2,𝜎,χ〉\n\n ... | [
45,
44,
46,
47,
35
] | 1 | 44 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `>` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 > a2,𝜎,χ〉 → 〈v1 > a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 > a2,𝜎,χ〉 → 〈a1' > a2,𝜎,χ〉\n\n }",
... | [
37,
36,
38,
39,
35
] | 1 | 36 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `%` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n ---------------------------------------------\n 〈v1 % a2,𝜎,χ〉 → 〈v1 % a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n ---------------------------------------------\n 〈a1 % a2,𝜎,χ〉 → 〈a1' % a2,𝜎,χ〉\n\n... | [
21,
20,
22,
23,
15
] | 1 | 20 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `<` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 < a2,𝜎,χ〉 → 〈v1 < a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 < a2,𝜎,χ〉 → 〈a1' < a2,𝜎,χ〉\n\n }",
... | [
29,
28,
30,
31,
39
] | 1 | 28 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `==` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 == a2,𝜎,χ〉 → 〈v1 == a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 == a2,𝜎,χ〉 → 〈a1' == a2,𝜎,χ〉\n\n ... | [
45,
44,
46,
47,
35
] | 1 | 44 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `*` is already a value and the right operand can still be evaluated, then evaluation proceeds within the right operand. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n ---------------------------------------------\n 〈a1 * a2,𝜎,χ〉 → 〈a1' * a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n ---------------------------------------------\n 〈v1 * a2,𝜎,χ〉 → 〈v1 * a2',𝜎,χ〉\n\n... | [
13,
14,
18,
15,
27
] | 1 | 14 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `-` expression are values, the result is obtained by subtracting the right operand value from the left operand value. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------------\n 〈a1 - a2,𝜎,χ〉 → 〈a1' - a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n v3 = v1 - v2\n ----------------------------\n 〈v1 - v2,𝜎,χ〉 → v3\n\n }",
"Rule 2 := {\n\n v2 ≠ 0... | [
10,
12,
18,
11,
27
] | 1 | 12 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `!=` is already a value and the right operand can still be evaluated, then evaluation proceeds within the right operand. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n ---------------------------------------------\n 〈a1 != a2,𝜎,χ〉 → 〈a1' != a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n ---------------------------------------------\n 〈v1 != a2,𝜎,χ〉 → 〈v1 != a2',𝜎,χ〉\n\n... | [
48,
49,
50,
51,
35
] | 1 | 49 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `*` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n ---------------------------------------------\n 〈v1 * a2,𝜎,χ〉 → 〈v1 * a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n ---------------------------------------------\n 〈a1 * a2,𝜎,χ〉 → 〈a1' * a2,𝜎,χ〉\n\n... | [
14,
13,
18,
15,
27
] | 1 | 13 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `==` expression are values and the left operand value is equal to the right operand value, the result is `true`. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 == a2,𝜎,χ〉 → 〈a1' == a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n v1 = v2\n ---------------------------\n 〈v1 == v2,𝜎,χ〉 → true\n\n }",
"Rule 2 := {\n\n 〈a2,�... | [
44,
46,
45,
47,
35
] | 1 | 46 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `==` is already a value and the right operand can still be evaluated, then evaluation proceeds within the right operand. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -------------------------------------------\n 〈a1 == a2,𝜎,χ〉 → 〈a1' == a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n -------------------------------------------\n 〈v1 == a2,𝜎,χ〉 → 〈v1 == a2',𝜎,χ〉\n\n ... | [
44,
45,
46,
47,
35
] | 1 | 45 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When a `halt` statement is encountered, the program execution stops immediately. | [
"Rule 0 := {\n\n χ ≠ ε ∧ s ≠ LE\n -----------------------------------------------------\n 〈continue :: s :: SL,𝜎,χ〉 ⇉ 〈continue :: SL,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n q = true\n -----------------------------------------------------------... | [
74,
65,
78,
73,
69
] | 2 | 78 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `<=` expression are values and the left operand value is less than or equal to the right operand value, the result is `true`. | [
"Rule 0 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n -----------------------------------------------\n 〈a1 <= a2,𝜎,χ〉 → 〈a1' <= a2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n v1 ≤ v2\n -----------------------------\n 〈v1 <= v2,𝜎,χ〉 → true\n\n }",
"Rule 2 := {\n\n ... | [
32,
34,
33,
35,
39
] | 1 | 34 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If a variable on the left-hand side of `=` does not exist in the program state and the right-hand side of `=` has been fully evaluated to a value, then an error occurs and the program execution stops immediately. | [
"Rule 0 := {\n\n 〈a,𝜎,χ〉 → 〈a',𝜎,χ〉\n -----------------------------------------------------------\n 〈x = a :: SL,𝜎,χ〉 ⇉ 〈x = a' :: SL,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 𝜎(x) = ⟂\n ---------------------------------------------\n 〈x = v :: SL,𝜎,χ〉 ⇉ ... | [
4,
6,
3,
5,
63
] | 1 | 6 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | When both operands of a `||` expression are boolean values and both the left and right operand values are `false`, the result is `false`. | [
"Rule 0 := {\n\n 〈b1,𝜎,χ〉 → 〈b1',𝜎,χ〉\n -------------------------------------------\n 〈b1 || b2,𝜎,χ〉 → 〈b1' || b2,𝜎,χ〉\n\n }",
"Rule 1 := {\n\n q1 = false ⋀ q2 = false\n ----------------------------\n 〈q1 || q2,𝜎,χ〉 → false\n\n }",
"Rule 2 := {\n\n ... | [
56,
59,
57,
58,
35
] | 1 | 59 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the predicate `q` in the `LOOP(q) {SL1}` statement is a boolean value and `q = false` and if `SL` is the list of statements following `LOOP(q) {SL1}`, then the execution proceeds with the statements in `SL`. | [
"Rule 0 := {\n\n q = true\n ----------------------------------------------------------\n 〈LOOP(q) {SL1} :: SL,𝜎,χ〉 ⇉ 〈SL1 ++ (LE :: SL),𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈b,𝜎,χ〉 → 〈b',𝜎,χ〉\n -------------------------------------------------... | [
70,
68,
69,
65,
77
] | 2 | 69 | near_miss | 5 |
IMP | <program> ::= <stmt_list>
<stmt_list> ::= ε | <stmt> ';' <stmt_list>
<stmt> ::= 'int' <id>
| <id> '=' <aexp>
| 'if' '(' <bexp> ')' '{' <stmt_list> '}' 'else' '{' <stmt_list> '}'
| 'while' '(' <bexp> ')' '{' <stmt_list> '}'
| 'LOOP' '(' <bexp> ')' '{' <stmt_list> '}... |
Metavariables:
- x ranges over sort id
- v ranges over sort literal
- q ranges over sort bool
- a ranges over sort aexp
- b ranges over sort bexp
- s ranges over sort stmt
- SL ranges over sort stmt_list and SL ::= ε // Empty stmt_list
|... | false | SOS | null | nl2rule | uk | false | If the left operand of a binary expression using `/` can be evaluated further, then evaluation proceeds within that left operand. | [
"Rule 0 := {\n\n 〈a2,𝜎,χ〉 → 〈a2',𝜎,χ〉\n ---------------------------------------------\n 〈v1 / a2,𝜎,χ〉 → 〈v1 / a2',𝜎,χ〉\n\n }",
"Rule 1 := {\n\n 〈a1,𝜎,χ〉 → 〈a1',𝜎,χ〉\n ---------------------------------------------\n 〈a1 / a2,𝜎,χ〉 → 〈a1' / a2,𝜎,χ〉\n\n ... | [
17,
16,
18,
19,
15
] | 1 | 16 | near_miss | 5 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 148