language string | syntax string | semantics-glossary string | mutated bool | semantics-type string | mutation-pattern string | num_rules int64 | 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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `%` expression are values and the right operand value is not zero, then the remainder of the integer division of the left operand value by the right operand value is the result. | [
"Rule 0 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"... | [
2,
8,
9,
6,
10
] | 1 | 8 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If a variable has no associated value in the current program state, then attempting to evaluate it results in an error and the program execution stops immediately. | [
"Rule 0 := {\n rule <k> I1 - I2 => I1 -Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 2 := {\n rule <k> X:Id => I ...</k>\n <state>... X |-> I ...</state>\n }",
"Rule 3 := {\n r... | [
4,
2,
1,
8,
10
] | 1 | 2 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `!` expression is a boolean value, the result is obtained by negating that boolean value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
18,
16,
17,
13
] | 1 | 18 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of an `==` expression are values, the result is obtained by comparing whether the left operand value is equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
16,
17,
18,
13
] | 1 | 16 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>=` expression are values, the result is obtained by comparing whether the left operand value is greater than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
15,
17,
18,
13
] | 1 | 15 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `%` expression are values and the right operand value is zero, then an error occurs and the program execution stops immediately. | [
"Rule 0 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"... | [
2,
9,
8,
6,
10
] | 1 | 9 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `/` expression are values and the right operand value is zero, then an error occurs and the program execution stops immediately. | [
"Rule 0 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"... | [
2,
7,
6,
8,
10
] | 1 | 7 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `break` statement is encountered and the statement following it is a `breakMarker`, then both the `break` and `breakMarker` are removed and execution continues with the statements following the loop. | [
"Rule 0 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n }",
"Rule 1 := {\n rule <k> continue; => ERROR </k>\n <whileStack> .List </whileStack>\n }",
"Rule 2 := {\n rule <k> break; ~> breakMarker => . ... </k>\n }",
"Rule... | [
33,
31,
35,
34,
23
] | 2 | 35 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"... | [
2,
6,
7,
8,
10
] | 1 | 6 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `continueMarker` is encountered, it is removed from the computation and execution continues. | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> breakMarker => . ... </k>\n }",
"Rule 2 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 3 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </while... | [
23,
27,
28,
33,
32
] | 2 | 28 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `+` expression are values, the result is obtained by adding those two values. | [
"Rule 0 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 + I2 => I1 +Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rul... | [
9,
7,
3,
10,
2
] | 2 | 3 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If a variable has no associated value in the current program state, then attempting to evaluate it results in an error and the program execution stops immediately. | [
"Rule 0 := {\n rule <k> I1 - I2 => I1 -Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 2 := {\n rule <k> X:Id => I ...</k>\n <state>... X |-> I ...</state>\n }",
"Rule 3 := {\n r... | [
4,
2,
1,
8,
10
] | 1 | 2 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"... | [
2,
6,
7,
8,
10
] | 1 | 6 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>` expression are values, the result is obtained by comparing whether the left operand value is greater than the right operand value. | [
"Rule 0 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
15,
14,
17,
18,
13
] | 1 | 14 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>=` expression are values, the result is obtained by comparing whether the left operand value is greater than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
15,
17,
18,
13
] | 1 | 15 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `break` statement is encountered and the statement following it is not a `breakMarker` and the `<whileStack>` stack is not empty, then the statement following it is dropped and the `break` remains the head of the computation. | [
"Rule 0 := {\n rule <k> break; => ERROR </k>\n <whileStack> .List </whileStack>\n }",
"Rule 1 := {\n rule <k> continue; => ERROR </k>\n <whileStack> .List </whileStack>\n }",
"Rule 2 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </... | [
34,
31,
33,
35,
23
] | 2 | 33 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If a variable has no associated value in the current program state, then attempting to evaluate it results in an error and the program execution stops immediately. | [
"Rule 0 := {\n rule <k> I1 - I2 => I1 -Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 2 := {\n rule <k> X:Id => I ...</k>\n <state>... X |-> I ...</state>\n }",
"Rule 3 := {\n r... | [
4,
2,
1,
8,
10
] | 1 | 2 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | A declaration of the form `int x` introduces `x` into the program state and assigns it the value `0` before execution continues. | [
"Rule 0 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> int X; => . ... </k>\n <state> Rho:Map (.Map => X|->0) </state>\n }",
"Rule 2 := {\n rule <k> X = I:Int; => . ...</k>\n <state>... X |-> (_ => I) ...</state>\n }",
"Rule 3 := {\n rul... | [
29,
36,
21,
1,
8
] | 1 | 36 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `<=` expression are values, the result is obtained by comparing whether the left operand value is less than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 <= I2 => I1 <=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 > I2 =... | [
15,
13,
17,
18,
14
] | 1 | 13 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `break` statement is encountered and the statement following it is a `breakMarker`, then both the `break` and `breakMarker` are removed and execution continues with the statements following the loop. | [
"Rule 0 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n }",
"Rule 1 := {\n rule <k> continue; => ERROR </k>\n <whileStack> .List </whileStack>\n }",
"Rule 2 := {\n rule <k> break; ~> breakMarker => . ... </k>\n }",
"Rule... | [
33,
31,
35,
34,
23
] | 2 | 35 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `breakMarker` is encountered, it is removed from the computation and execution continues. | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> breakMarker => . ... </k>\n }",
"Rule 3 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </while... | [
23,
28,
27,
33,
32
] | 2 | 27 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>=` expression are values, the result is obtained by comparing whether the left operand value is greater than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
15,
17,
18,
13
] | 1 | 15 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `continue` statement is encountered and the statement following it is a `continueMarker`, then both the `continue` and `continueMarker` are removed and execution continues. | [
"Rule 0 := {\n rule <k> continue; ~> S:Stmt => continue; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n requires notBool isContmark(S)\n }",
"Rule 1 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 2 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n ... | [
30,
23,
29,
32,
31
] | 2 | 29 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `!` expression is a boolean value, the result is obtained by negating that boolean value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
18,
16,
17,
13
] | 1 | 18 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> I1 - I2 => I1 -Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> X:Id => I ...</k>\n <state>... X |-> I ...</state>\n }",
"Rule 2 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 3 := {\n r... | [
4,
1,
2,
8,
10
] | 1 | 1 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `-` expression is a value, the result is obtained by negating the value. | [
"Rule 0 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> - I1 => 0 -Int I1 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 % I2 => ERROR ... </k>\n req... | [
8,
6,
11,
9,
2
] | 2 | 11 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `continueMarker` is encountered, it is removed from the computation and execution continues. | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> breakMarker => . ... </k>\n }",
"Rule 2 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 3 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </while... | [
23,
27,
28,
33,
32
] | 2 | 28 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> continue; ~> breakMarker => continue; ...</k>\n }",
"Rule 2 := {\n rule <k> if (true) S else _ ; => S ... </k>\n }",
"Rule 3 := {\n rule <k> while1 (B) S => if (B) {S continueMarker (while1 (B) S)}... | [
23,
32,
22,
25,
33
] | 2 | 22 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `!` expression is a boolean value, the result is obtained by negating that boolean value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
18,
16,
17,
13
] | 1 | 18 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `+` expression is a value, the result is obtained by adding zero to that value. | [
"Rule 0 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 % I2 => ERROR ... </k>\n req... | [
8,
6,
10,
9,
2
] | 2 | 10 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>` expression are values, the result is obtained by comparing whether the left operand value is greater than the right operand value. | [
"Rule 0 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
15,
14,
17,
18,
13
] | 1 | 14 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> continue; ~> breakMarker => continue; ...</k>\n }",
"Rule 2 := {\n rule <k> if (true) S else _ ; => S ... </k>\n }",
"Rule 3 := {\n rule <k> while1 (B) S => if (B) {S continueMarker (while1 (B) S)}... | [
23,
32,
22,
25,
33
] | 2 | 22 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `/` expression are values and the right operand value is zero, then an error occurs and the program execution stops immediately. | [
"Rule 0 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"... | [
2,
7,
6,
8,
10
] | 1 | 7 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"... | [
2,
6,
7,
8,
10
] | 1 | 6 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If the predicate `q` in the `while1(q) S` statement is a boolean value, then the statement is transformed into an `if-else` statement that checks the predicate and either executes the body of `while1(q) S` statement followed by a continue marker and re-evaluates the `while1(q) S` statement, or exits through the `else` ... | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> while1 (B) S => if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>\n <whileStack> ListItem(X:Int) S1:List</whileStack>\n }",
"Rule ... | [
23,
28,
25,
33,
32
] | 2 | 25 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `/` expression are values and the right operand value is zero, then an error occurs and the program execution stops immediately. | [
"Rule 0 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"... | [
2,
7,
6,
8,
10
] | 1 | 7 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If the predicate `q` in the `if(q) SL1 else SL2` statement is a boolean value and `q = false`, then the execution proceeds with the statements in the statement list `SL2` (else-block). | [
"Rule 0 := {\n rule <k> if (true) S else _ ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> continue; ~> breakMarker => continue; ...</k>\n }",
"Rule 2 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 3 := {\n rule <k> while1 (B) S => if (B) {S continueMarker (while1 (B) S)}... | [
22,
32,
23,
25,
33
] | 2 | 23 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If the predicate `q` in the `if(q) SL1 else SL2` statement is a boolean value and `q = false`, then the execution proceeds with the statements in the statement list `SL2` (else-block). | [
"Rule 0 := {\n rule <k> if (true) S else _ ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> continue; ~> breakMarker => continue; ...</k>\n }",
"Rule 2 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 3 := {\n rule <k> while1 (B) S => if (B) {S continueMarker (while1 (B) S)}... | [
22,
32,
23,
25,
33
] | 2 | 23 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `!=` expression are values, the result is obtained by comparing whether the left operand value is not equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
17,
16,
18,
13
] | 1 | 17 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `+` expression are values, the result is obtained by adding those two values. | [
"Rule 0 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 + I2 => I1 +Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rul... | [
9,
7,
3,
10,
2
] | 2 | 3 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `continue` statement is encountered and the statement following it is not a `continueMarker` and the `<whileStack>` stack is not empty, then the statement following it is dropped and the `continue` remains the head of the computation. | [
"Rule 0 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 2 := {\n rule <k> continue; ~> S:Stmt => continue; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n requires notBool isContmark(S)\n ... | [
29,
23,
30,
32,
31
] | 2 | 30 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `break` statement is encountered and the statement following it is a `breakMarker`, then both the `break` and `breakMarker` are removed and execution continues with the statements following the loop. | [
"Rule 0 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n }",
"Rule 1 := {\n rule <k> continue; => ERROR </k>\n <whileStack> .List </whileStack>\n }",
"Rule 2 := {\n rule <k> break; ~> breakMarker => . ... </k>\n }",
"Rule... | [
33,
31,
35,
34,
23
] | 2 | 35 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `%` expression are values and the right operand value is not zero, then the remainder of the integer division of the left operand value by the right operand value is the result. | [
"Rule 0 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"... | [
2,
8,
9,
6,
10
] | 1 | 8 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If the predicate `q` in the `while1(q) S` statement is a boolean value, then the statement is transformed into an `if-else` statement that checks the predicate and either executes the body of `while1(q) S` statement followed by a continue marker and re-evaluates the `while1(q) S` statement, or exits through the `else` ... | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> while1 (B) S => if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>\n <whileStack> ListItem(X:Int) S1:List</whileStack>\n }",
"Rule ... | [
23,
28,
25,
33,
32
] | 2 | 25 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"... | [
2,
6,
7,
8,
10
] | 1 | 6 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | A declaration of the form `int x` introduces `x` into the program state and assigns it the value `0` before execution continues. | [
"Rule 0 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> int X; => . ... </k>\n <state> Rho:Map (.Map => X|->0) </state>\n }",
"Rule 2 := {\n rule <k> X = I:Int; => . ...</k>\n <state>... X |-> (_ => I) ...</state>\n }",
"Rule 3 := {\n rul... | [
29,
36,
21,
1,
8
] | 1 | 36 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of an `&&` expression are boolean values, the result is obtained by applying the logical AND operation to those two boolean values. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> B1 && B2 => B1 andBool B2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <... | [
14,
19,
16,
17,
13
] | 1 | 19 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the statement `while(B) SL` is executed, the semantics first pushes the entire statement `while(B) SL` onto the `<whileStmtStack>`. It then replaces the statement with the internal form `while1(B) SL`, inserts a `breakMarker`, and schedules `pop` and `popStmt` to run afterward to restore the `<whileStack>` and `<w... | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> (while (B) S ;) => pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>\n }",
"Rule 3 := {\n rule <k> break; ~... | [
23,
28,
24,
33,
32
] | 2 | 24 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `<=` expression are values, the result is obtained by comparing whether the left operand value is less than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 <= I2 => I1 <=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 > I2 =... | [
15,
13,
17,
18,
14
] | 1 | 13 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `*` expression are values, the result is obtained by multiplying those two values. | [
"Rule 0 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 * I2 => I1 *Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rul... | [
9,
7,
5,
10,
2
] | 2 | 5 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `+` expression are values, the result is obtained by adding those two values. | [
"Rule 0 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 + I2 => I1 +Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rul... | [
9,
7,
3,
10,
2
] | 2 | 3 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>=` expression are values, the result is obtained by comparing whether the left operand value is greater than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
15,
17,
18,
13
] | 1 | 15 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of an `&&` expression are boolean values, the result is obtained by applying the logical AND operation to those two boolean values. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> B1 && B2 => B1 andBool B2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <... | [
14,
19,
16,
17,
13
] | 1 | 19 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"... | [
2,
6,
7,
8,
10
] | 1 | 6 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>=` expression are values, the result is obtained by comparing whether the left operand value is greater than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
15,
17,
18,
13
] | 1 | 15 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `/` expression are values and the right operand value is zero, then an error occurs and the program execution stops immediately. | [
"Rule 0 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"... | [
2,
7,
6,
8,
10
] | 1 | 7 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If the predicate `q` in the `while1(q) S` statement is a boolean value, then the statement is transformed into an `if-else` statement that checks the predicate and either executes the body of `while1(q) S` statement followed by a continue marker and re-evaluates the `while1(q) S` statement, or exits through the `else` ... | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> while1 (B) S => if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>\n <whileStack> ListItem(X:Int) S1:List</whileStack>\n }",
"Rule ... | [
23,
28,
25,
33,
32
] | 2 | 25 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `!` expression is a boolean value, the result is obtained by negating that boolean value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
18,
16,
17,
13
] | 1 | 18 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `continue` statement is encountered and the statement following it is not a `continueMarker` and the `<whileStack>` stack is not empty, then the statement following it is dropped and the `continue` remains the head of the computation. | [
"Rule 0 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 2 := {\n rule <k> continue; ~> S:Stmt => continue; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n requires notBool isContmark(S)\n ... | [
29,
23,
30,
32,
31
] | 2 | 30 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the statement `while(B) SL` is executed, the semantics first pushes the entire statement `while(B) SL` onto the `<whileStmtStack>`. It then replaces the statement with the internal form `while1(B) SL`, inserts a `breakMarker`, and schedules `pop` and `popStmt` to run afterward to restore the `<whileStack>` and `<w... | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> (while (B) S ;) => pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>\n }",
"Rule 3 := {\n rule <k> break; ~... | [
23,
28,
24,
33,
32
] | 2 | 24 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `-` expression is a value, the result is obtained by negating the value. | [
"Rule 0 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> - I1 => 0 -Int I1 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 % I2 => ERROR ... </k>\n req... | [
8,
6,
11,
9,
2
] | 2 | 11 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the statement `while(B) SL` is executed, the semantics first pushes the entire statement `while(B) SL` onto the `<whileStmtStack>`. It then replaces the statement with the internal form `while1(B) SL`, inserts a `breakMarker`, and schedules `pop` and `popStmt` to run afterward to restore the `<whileStack>` and `<w... | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> (while (B) S ;) => pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>\n }",
"Rule 3 := {\n rule <k> break; ~... | [
23,
28,
24,
33,
32
] | 2 | 24 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If the predicate `q` in the `if(q) SL1 else SL2` statement is a boolean value and `q = false`, then the execution proceeds with the statements in the statement list `SL2` (else-block). | [
"Rule 0 := {\n rule <k> if (true) S else _ ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> continue; ~> breakMarker => continue; ...</k>\n }",
"Rule 2 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 3 := {\n rule <k> while1 (B) S => if (B) {S continueMarker (while1 (B) S)}... | [
22,
32,
23,
25,
33
] | 2 | 23 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>` expression are values, the result is obtained by comparing whether the left operand value is greater than the right operand value. | [
"Rule 0 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
15,
14,
17,
18,
13
] | 1 | 14 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `!` expression is a boolean value, the result is obtained by negating that boolean value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
18,
16,
17,
13
] | 1 | 18 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `*` expression are values, the result is obtained by multiplying those two values. | [
"Rule 0 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 * I2 => I1 *Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rul... | [
9,
7,
5,
10,
2
] | 2 | 5 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `-` expression is a value, the result is obtained by negating the value. | [
"Rule 0 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> - I1 => 0 -Int I1 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 % I2 => ERROR ... </k>\n req... | [
8,
6,
11,
9,
2
] | 2 | 11 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `break` statement is encountered and the statement following it is a `breakMarker`, then both the `break` and `breakMarker` are removed and execution continues with the statements following the loop. | [
"Rule 0 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n }",
"Rule 1 := {\n rule <k> continue; => ERROR </k>\n <whileStack> .List </whileStack>\n }",
"Rule 2 := {\n rule <k> break; ~> breakMarker => . ... </k>\n }",
"Rule... | [
33,
31,
35,
34,
23
] | 2 | 35 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of an `==` expression are values, the result is obtained by comparing whether the left operand value is equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
16,
17,
18,
13
] | 1 | 16 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `-` expression is a value, the result is obtained by negating the value. | [
"Rule 0 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> - I1 => 0 -Int I1 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 % I2 => ERROR ... </k>\n req... | [
8,
6,
11,
9,
2
] | 2 | 11 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `continue` statement is encountered and the statement following it is not a `continueMarker` and the `<whileStack>` stack is not empty, then the statement following it is dropped and the `continue` remains the head of the computation. | [
"Rule 0 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 2 := {\n rule <k> continue; ~> S:Stmt => continue; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n requires notBool isContmark(S)\n ... | [
29,
23,
30,
32,
31
] | 2 | 30 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | If the predicate `q` in the `while1(q) S` statement is a boolean value, then the statement is transformed into an `if-else` statement that checks the predicate and either executes the body of `while1(q) S` statement followed by a continue marker and re-evaluates the `while1(q) S` statement, or exits through the `else` ... | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> while1 (B) S => if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>\n <whileStack> ListItem(X:Int) S1:List</whileStack>\n }",
"Rule ... | [
23,
28,
25,
33,
32
] | 2 | 25 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `!` expression is a boolean value, the result is obtained by negating that boolean value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
18,
16,
17,
13
] | 1 | 18 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | A declaration of the form `int x` introduces `x` into the program state and assigns it the value `0` before execution continues. | [
"Rule 0 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> int X; => . ... </k>\n <state> Rho:Map (.Map => X|->0) </state>\n }",
"Rule 2 := {\n rule <k> X = I:Int; => . ...</k>\n <state>... X |-> (_ => I) ...</state>\n }",
"Rule 3 := {\n rul... | [
29,
36,
21,
1,
8
] | 1 | 36 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>=` expression are values, the result is obtained by comparing whether the left operand value is greater than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
15,
17,
18,
13
] | 1 | 15 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> X = I:Int; => . ...</k>\n <state>... X |-> (_ => I) ...</state>\n }",
"Rule 2 := {\n rule <k> int X; => . ... </k>\n <state> Rho:Map (.Map => X|->0) </state>\n }",
"Rule 3 := {\n rul... | [
29,
21,
36,
1,
8
] | 1 | 21 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 - I2 => I1 -Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rul... | [
9,
7,
4,
10,
2
] | 2 | 4 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>=` expression are values, the result is obtained by comparing whether the left operand value is greater than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
15,
17,
18,
13
] | 1 | 15 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `+` expression are values, the result is obtained by adding those two values. | [
"Rule 0 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 + I2 => I1 +Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rul... | [
9,
7,
3,
10,
2
] | 2 | 3 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> X = I:Int; => . ...</k>\n <state>... X |-> (_ => I) ...</state>\n }",
"Rule 2 := {\n rule <k> int X; => . ... </k>\n <state> Rho:Map (.Map => X|->0) </state>\n }",
"Rule 3 := {\n rul... | [
29,
21,
36,
1,
8
] | 1 | 21 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `halt` statement is encountered, the program execution stops immediately and all subsequent statements are removed. | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> halt; ~> _ => .</k>\n }",
"Rule 3 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>... | [
23,
28,
26,
33,
32
] | 2 | 26 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `!` expression is a boolean value, the result is obtained by negating that boolean value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
18,
16,
17,
13
] | 1 | 18 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `*` expression are values, the result is obtained by multiplying those two values. | [
"Rule 0 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 * I2 => I1 *Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rul... | [
9,
7,
5,
10,
2
] | 2 | 5 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>` expression are values, the result is obtained by comparing whether the left operand value is greater than the right operand value. | [
"Rule 0 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
15,
14,
17,
18,
13
] | 1 | 14 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | 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 rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> X = I:Int; => . ...</k>\n <state>... X |-> (_ => I) ...</state>\n }",
"Rule 2 := {\n rule <k> int X; => . ... </k>\n <state> Rho:Map (.Map => X|->0) </state>\n }",
"Rule 3 := {\n rul... | [
29,
21,
36,
1,
8
] | 1 | 21 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>` expression are values, the result is obtained by comparing whether the left operand value is greater than the right operand value. | [
"Rule 0 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
15,
14,
17,
18,
13
] | 1 | 14 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `continue` statement is encountered and the statement following it is a `breakMarker`, then the statement following it is dropped and the `continue` remains the head of the computation. | [
"Rule 0 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 2 := {\n rule <k> continue; ~> breakMarker => continue; ...</k>\n }",
"Rule 3 := {\n rule <k> continue; => ERROR </k>\n <whileStack> .List </... | [
29,
23,
32,
31,
30
] | 2 | 32 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `halt` statement is encountered, the program execution stops immediately and all subsequent statements are removed. | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> halt; ~> _ => .</k>\n }",
"Rule 3 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>... | [
23,
28,
26,
33,
32
] | 2 | 26 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `continue` statement is encountered and the statement following it is not a `continueMarker` and the `<whileStack>` stack is not empty, then the statement following it is dropped and the `continue` remains the head of the computation. | [
"Rule 0 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 2 := {\n rule <k> continue; ~> S:Stmt => continue; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n requires notBool isContmark(S)\n ... | [
29,
23,
30,
32,
31
] | 2 | 30 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the operand of a unary `+` expression is a value, the result is obtained by adding zero to that value. | [
"Rule 0 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 1 := {\n rule <k> I1 / I2 => I1 /Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"Rule 2 := {\n rule <k> + I1 => 0 +Int I1 ... </k>\n }",
"Rule 3 := {\n rule <k> I1 % I2 => ERROR ... </k>\n req... | [
8,
6,
10,
9,
2
] | 2 | 10 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `!=` expression are values, the result is obtained by comparing whether the left operand value is not equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
17,
16,
18,
13
] | 1 | 17 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `%` expression are values and the right operand value is zero, then an error occurs and the program execution stops immediately. | [
"Rule 0 := {\n rule <k> X:Id => ERROR </k>\n <state> Rho:Map </state>\n requires notBool (X in_keys(Rho))\n }",
"Rule 1 := {\n rule <k> I1 % I2 => ERROR ... </k>\n requires I2 ==Int 0\n }",
"Rule 2 := {\n rule <k> I1 % I2 => I1 %Int I2 ... </k>\n requires I2 =/=Int 0\n }",
"... | [
2,
9,
8,
6,
10
] | 1 | 9 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of an `==` expression are values, the result is obtained by comparing whether the left operand value is equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
16,
17,
18,
13
] | 1 | 16 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | A declaration of the form `int x` introduces `x` into the program state and assigns it the value `0` before execution continues. | [
"Rule 0 := {\n rule <k> continue; ~> S:ContMark => . ...</k>\n }",
"Rule 1 := {\n rule <k> int X; => . ... </k>\n <state> Rho:Map (.Map => X|->0) </state>\n }",
"Rule 2 := {\n rule <k> X = I:Int; => . ...</k>\n <state>... X |-> (_ => I) ...</state>\n }",
"Rule 3 := {\n rul... | [
29,
36,
21,
1,
8
] | 1 | 36 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `break` statement is encountered and the statement following it is a `breakMarker`, then both the `break` and `breakMarker` are removed and execution continues with the statements following the loop. | [
"Rule 0 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>\n }",
"Rule 1 := {\n rule <k> continue; => ERROR </k>\n <whileStack> .List </whileStack>\n }",
"Rule 2 := {\n rule <k> break; ~> breakMarker => . ... </k>\n }",
"Rule... | [
33,
31,
35,
34,
23
] | 2 | 35 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `!=` expression are values, the result is obtained by comparing whether the left operand value is not equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 == I2 => I1 ==Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
17,
16,
18,
13
] | 1 | 17 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `continueMarker` is encountered, it is removed from the computation and execution continues. | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> breakMarker => . ... </k>\n }",
"Rule 2 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 3 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </while... | [
23,
27,
28,
33,
32
] | 2 | 28 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When a `halt` statement is encountered, the program execution stops immediately and all subsequent statements are removed. | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> halt; ~> _ => .</k>\n }",
"Rule 3 := {\n rule <k> break; ~> S:Stmt => break; ...</k>\n <whileStack> ListItem(_) REST:List </whileStack>... | [
23,
28,
26,
33,
32
] | 2 | 26 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When the statement `while(B) SL` is executed, the semantics first pushes the entire statement `while(B) SL` onto the `<whileStmtStack>`. It then replaces the statement with the internal form `while1(B) SL`, inserts a `breakMarker`, and schedules `pop` and `popStmt` to run afterward to restore the `<whileStack>` and `<w... | [
"Rule 0 := {\n rule <k> if (false) _ else S ; => S ... </k>\n }",
"Rule 1 := {\n rule <k> S:ContMark => . ... </k>\n }",
"Rule 2 := {\n rule <k> (while (B) S ;) => pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>\n }",
"Rule 3 := {\n rule <k> break; ~... | [
23,
28,
24,
33,
32
] | 2 | 24 | near_miss |
C* | module IMP_K-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "+" AExp [strict]
| "-" AExp [strict]
> left:
AExp "/... |
module IMP_K-AUXILIARY
imports IMP_K-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
synta... | false | K | Standard | 5 | nl2rule | uk | false | When both operands of a `>=` expression are values, the result is obtained by comparing whether the left operand value is greater than or equal to the right operand value. | [
"Rule 0 := {\n rule <k> I1 > I2 => I1 >Int I2 ... </k>\n }",
"Rule 1 := {\n rule <k> I1 >= I2 => I1 >=Int I2 ... </k>\n }",
"Rule 2 := {\n rule <k> I1 != I2 => I1 =/=Int I2 ... </k>\n }",
"Rule 3 := {\n rule <k> ! B1 => notBool B1 ... </k>\n }",
"Rule 4 := {\n rule <k> I1 <= I2 =>... | [
14,
15,
17,
18,
13
] | 1 | 15 | near_miss |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.