Function statement at line l, tab s

the program statement at line l and tab s

Format:

statement at line l, tab s

Input:

Output:

Conditional properties that reference this function:

• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ Python list elements, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ Python list elements, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ obj_name.method_name(args), [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ obj_name.method_name(args), [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.name(el)
  • Expression Stack at time t = [ [ ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.name(el)
  • Expression Stack at time t = [ [ ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.name(el)
  • Expression Stack at time t = [ [ ], [ ] ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.name(el)
  • Expression Stack at time t = [ [ ], [ ] ]

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.name(el)
  • Expression Stack at time t = [ [ ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.name(el)
  • Expression Stack at time t = [ [ ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: "__getitem__" and arguments: args
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: "len" and arguments: args
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: "__contains__" and arguments: args
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ Python dictionary entries, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ Python dictionary elements, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: "__setitem__" and arguments: args
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Class Map at time (t + 1) = result of storing [ entry "bases": bases, [ entry "methods": [ ], [ entry "line": i, [ ] ] ] ] at key: name in map: (Class Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Control Map at time (t + 1) = result of storing (pair ("class", name)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then the line at time (t + 1) = the line at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then the tab at time (t + 1) = j - 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Expression Stack at time t = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Expression Stack at time (t + 1) = Expression Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params
  • value at class_name in map (Class Map at time t) = class_map
  • value at "methods" in map class_map = methods_map

  then Class Map at time (t + 1) = result of storing (result of storing (result of storing [ entry "params": params, [ entry "line": i, [ ] ] ] at key: method_name in map: methods_map) at key: "methods" in map: class_map) at key: class_name in map: (Class Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • Expression Stack at time t = [ [ ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • Expression Stack at time t = [ [ ], [ ] ]

  then Expression Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • Expression Stack at time t = [ [ ], [ ] ]

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • Expression Stack at time t = [ [ ], [ ] ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • Expression Stack at time t = [ [ ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • Expression Stack at time t = [ [ ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • Expression Stack at time t = [ [ ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Variables Map at time (t + 1) = result of storing value at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ Python constructor with name: name and arguments: args, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Variables Map at time (t + 1) = result of storing value at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ obj.attr, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Variables Map at time (t + 1) = result of storing value at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ obj.key = value, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • Expression Stack at time t = [ [ ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • Expression Stack at time t = [ [ ], [ ] ]

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • Expression Stack at time t = [ [ ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • Expression Stack at time t = [ [ ], [ ] ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • Expression Stack at time t = [ [ ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • Expression Stack at time t = [ [ ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • Expression Stack at time t = [ [ ], [ ] ]

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Variables Map at time (t + 1) = varis

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then the line at time (t + 1) = line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then the tab at time (t + 1) = tab

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Expression Stack at time (t + 1) = expr_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Context Stack at time (t + 1) = rest

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Value Stack at time (t + 1) = value_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Control Map at time (t + 1) = control_map

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", "__init__")

  then Return Value at time (t + 1) = [ value at self in map (Variables Map at time t), [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)
  • not (method_name = "__init__")

  then Return Value at time (t + 1) = [ None, [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ iterable, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • iterable is a variable

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • Expression Stack at time t = [ [ ], [ ] ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • Expression Stack at time t = [ [ ], [ ] ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • Expression Stack at time t = [ [ ], [ ] ]

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • Expression Stack at time t = [ [ ], [ ] ]

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ Python reference index, [ ] ], v_stack ]
  • the element at index index of stack (Python Object Store at time t) = Python list elements

  then Control Map at time (t + 1) = result of storing (trio ("for", i, elements)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then Variables Map at time (t + 1) = result of storing elem at key: target in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then Control Map at time (t + 1) = result of storing (trio ("for", i, rest)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then Expression Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then Control Map at time (t + 1) = result of deleting the entry with key j from map (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then Expression Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then the line at time (t + 1) = for_line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then the tab at time (t + 1) = j - 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Expression Stack at time (t + 1) = Expression Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then expression state at time (t + 1) = "not_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the line at time (t + 1) = while_line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the tab at time (t + 1) = j - 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then expression state at time (t + 1) = expression state at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j

  then expression state at time (t + 1) = "not_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = function call with name: name and arguments: args

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "end_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • expression state at time t = "end_expr"

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • expression state at time t = "not_expr"
  • c is constant

  then the expression at time (t + 1) = c

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • expression state at time t = "not_expr"
  • c is constant

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • expression state at time t = "not_expr"
  • c is constant

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • expression state at time t = "not_expr"
  • c is constant

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • expression state at time t = "not_expr"
  • c is constant

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • expression state at time t = "not_expr"
  • c is constant

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • expression state at time t = "not_expr"
  • c is constant

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • expression state at time t = "not_expr"
  • x is a variable

  then the expression at time (t + 1) = x

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • expression state at time t = "not_expr"
  • x is a variable

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • expression state at time t = "not_expr"
  • x is a variable

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • expression state at time t = "not_expr"
  • x is a variable

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • expression state at time t = "not_expr"
  • x is a variable

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • expression state at time t = "not_expr"
  • x is a variable

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • expression state at time t = "not_expr"
  • x is a variable

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • expression state at time t = "not_expr"
  • x is a variable

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is constant

  then Variables Map at time (t + 1) = result of storing c at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is constant

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is constant

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is constant

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is constant

  then expression state at time (t + 1) = "not_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is constant

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is a variable

  then Variables Map at time (t + 1) = result of storing (value at c in map (Variables Map at time t)) at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is a variable

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is a variable

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is a variable

  then expression state at time (t + 1) = "not_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is a variable

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x = c
  • c is a variable

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = function call with name: name and arguments: args

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = result of storing (Return Value at time t) at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = test

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then Control Map at time (t + 1) = result of storing (pair ("if", True)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then Control Map at time (t + 1) = result of storing (pair ("if", False)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = test

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then Control Map at time (t + 1) = result of storing (pair ("if", True)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", False)

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", False)

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", True)

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", True)

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then expression state at time (t + 1) = expression state at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the tab at time (t + 1) = j - 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = function call with name: name and arguments: args

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then Control Map at time (t + 1) = result of storing (pair ("while", i)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then "break" state at (t + 1) = "breaking"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then "continue" state at (t + 1) = "continuing"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then expression state at time (t + 1) = "not_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then there is a function named name with parameters params at line line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return v

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return v

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return v

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return c
  • c is constant

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return c
  • c is a variable

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = rex

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = varis

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = tab

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then expression state at time (t + 1) = "call_returned"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then parent stack at time (t + 1) = parent_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then Control Map at time (t + 1) = control_map

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = rest

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then Value Stack at time (t + 1) = value_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then arguments stack at time (t + 1) = arg_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • expression state at time t = "end_expr"

  then Return Value at time (t + 1) = Return Value at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = Python list elements

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python list elements

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = Python list elements

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = result of storing (Return Value at time t) at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python list elements)
  • expression state at time t = "end_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = obj_name.method_name(args)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)
  • expression state at time t = "not_expr"

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj_name.method_name(args)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = obj_name.method_name(args)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target target and expression (obj_name.method_name(args))
  • expression state at time t = "not_expr"

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj."append"(el)

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj."append"(el)

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj."append"(el)

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj."append"(el)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: "__getitem__" and arguments: args
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: "len" and arguments: args
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: "__contains__" and arguments: args
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = Python dictionary entries

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = Python dictionary entries
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = Python dictionary elements

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = result of storing (Return Value at time t) at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python dictionary elements)
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: "__setitem__" and arguments: args
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Class Map at time (t + 1) = result of storing [ entry "bases": bases, [ entry "methods": [ ], [ entry "line": i, [ ] ] ] ] at key: name in map: (Class Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Control Map at time (t + 1) = result of storing (pair ("class", name)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then the line at time (t + 1) = the line at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then the tab at time (t + 1) = j - 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then expression state at time t = "not_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then expression state at time (t + 1) = expression state at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a method named method_name with parameters params
  • value at class_name in map (Class Map at time t) = class_map
  • value at "methods" in map class_map = methods_map

  then Class Map at time (t + 1) = result of storing (result of storing (result of storing [ entry "params": params, [ entry "line": i, [ ] ] ] at key: method_name in map: methods_map) at key: "methods" in map: class_map) at key: class_name in map: (Class Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • expression state at time t = "end_expr"

  then expression state at time (t + 1) = "not_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • expression state at time t = "end_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.mn(args)
  • expression state at time t = "end_expr"

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = result of storing (Return Value at time t) at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj_name.method_name(args))
  • expression state at time t = "end_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = Python constructor with name: name and arguments: args

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: name and arguments: args)
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = result of storing (Return Value at time t) at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (Python constructor with name: class_name and arguments: args)
  • expression state at time t = "end_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = obj.attr

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = result of storing (Return Value at time t) at key: x in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = assign statement with target x and expression (obj.attr)
  • expression state at time t = "end_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = obj.key = value

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = obj.key = value

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • expression state at time t = "end_expr"

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • expression state at time t = "end_expr"

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • expression state at time t = "end_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x.y = z
  • expression state at time t = "end_expr"

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Variables Map at time (t + 1) = varis

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then the line at time (t + 1) = line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then the tab at time (t + 1) = tab

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then expression state at time (t + 1) = "call_returned"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then parent stack at time (t + 1) = parent_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then stack at time (t + 1) = rest

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Value Stack at time (t + 1) = value_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then arguments stack at time (t + 1) = arg_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Control Map at time (t + 1) = control_map

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", "__init__")

  then Return Value at time (t + 1) = value at self in map (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)
  • not (method_name = "__init__")

  then Return Value at time (t + 1) = None

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = iterable

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • map (Control Map at time t) does not contain a for loop entry at line: i and tab: j
  • expression state at time t = "not_expr"

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • iterable is a variable

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • iterable is a variable

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • iterable is a variable

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • iterable is a variable

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • expression state at time t = "end_expr"

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • expression state at time t = "end_expr"

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • expression state at time t = "end_expr"

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • expression state at time t = "end_expr"

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • expression state at time t = "end_expr"

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • expression state at time t = "end_expr"

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • expression state at time t = "end_expr"

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable:
  • expression state at time t = "end_expr"

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • expression state at time t = "end_expr"
  • Return Value at time t = Python reference index
  • the element at index index of stack (Python Object Store at time t) = Python list elements

  then Control Map at time (t + 1) = result of storing (trio ("for", i, elements)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then Variables Map at time (t + 1) = result of storing elem at key: target in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then Control Map at time (t + 1) = result of storing (trio ("for", i, rest)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then expression state at time (t + 1) = "not_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ elem, rest ])

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then expression state at time (t + 1) = "not_expr"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = for target in iterable_ex:
  • value at j in map (Control Map at time t) = trio ("for", i, [ ])

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then the line at time (t + 1) = for_line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then the tab at time (t + 1) = j - 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then stack at time (t + 1) = stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then "if" map at time (t + 1) = "if" map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then expression state at time (t + 1) = expression state at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = trio ("for", for_line, iterable)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Expression Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k > j

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the line at time (t + 1) = while_line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the tab at time (t + 1) = j - 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Expression Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j

  then Expression Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ c, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = c
  • c is constant
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • x is a variable

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • c is a variable
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ x, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • c is a variable
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • c is a variable
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = x
  • c is a variable
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ function call with name: name and arguments: args, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function call with name: name and arguments: args
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ expr, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Variables Map at time (t + 1) = result of storing value at key: target in map: (Variables Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then the tab at time (t + 1) = the tab at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = target = expr

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ expr, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then Control Map at time (t + 1) = result of storing (pair ("if", True)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ False, [ ] ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ False, [ ] ], [ ] ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ False, [ ] ], [ ] ]

  then Control Map at time (t + 1) = result of storing (pair ("if", False)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ expr, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then Control Map at time (t + 1) = result of storing (pair ("if", True)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ False, [ ] ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ False, [ ] ], [ ] ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ False, [ ] ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", False)

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", False)

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", True)

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", True)

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:

  then Expression Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the tab at time (t + 1) = j - 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ test, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ [ ], [ ] ]

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = while test:
  • Expression Stack at time t = [ [ ], [ ] ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then the tab at time (t + 1) = j + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then Control Map at time (t + 1) = result of storing (pair ("while", i)) at key: j in map: (Control Map at time t)

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ False, [ ] ], [ ] ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ False, [ ] ], [ ] ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then "break" state at (t + 1) = "breaking"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = break

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then "continue" state at (t + 1) = "continuing"

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Expression Stack at time (t + 1) = [ ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = continue

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then there is a function named name with parameters params at line line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then the line at time (t + 1) = i + 1

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = function definition where name: name and parameters: params

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return v

  then Class Map at time (t + 1) = Class Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return c
  • c is constant

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return c
  • c is a variable

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ rex, [ ] ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Context Stack at time t = [ program context with variables: vars and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • Expression Stack at time t = [ [ ], [ ] ]

  then Variables Map at time (t + 1) = vars

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Context Stack at time t = [ program context with variables: vars and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • Expression Stack at time t = [ [ ], [ ] ]

  then the line at time (t + 1) = line

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Context Stack at time t = [ program context with variables: vars and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • Expression Stack at time t = [ [ ], [ ] ]

  then the tab at time (t + 1) = tab

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Context Stack at time t = [ program context with variables: vars and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • Expression Stack at time t = [ [ ], [ ] ]

  then Control Map at time (t + 1) = control_map

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Context Stack at time t = [ program context with variables: vars and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • Expression Stack at time t = [ [ ], [ ] ]

  then Context Stack at time (t + 1) = rest

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Context Stack at time t = [ program context with variables: vars and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • Expression Stack at time t = [ [ ], [ ] ]

  then Expression Stack at time (t + 1) = expr_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Context Stack at time t = [ program context with variables: vars and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]
  • Expression Stack at time t = [ [ ], [ ] ]

  then Value Stack at time (t + 1) = value_stack

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ value, [ ] ], [ ] ]

  then Return Value at time (t + 1) = [ value, [ ] ]

  (link)
• if the following are true:
  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = return rex
  • Expression Stack at time t = [ [ ], [ ] ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

Comments

Please log in to add comments