Function A Key-Value Pair

a key,value entry

Format:

pair (key, value)

Input:

variable key -
number value -

Output:

variable - None

Properties that reference this function:

(pair ("while", x)) describes a loop = True (While is loop)
(pair ("if", x)) describes a loop = False (If is loop)
the first token in (pair (name, some)) = name (Get first token)
value at key in map [ pair (key, value), remaining ] = value (Get Key Value Match)
value at key in map [ pair (bad_key, value), remaining ] = value at key in map remaining (Get Key Value No Match)
output of function delete_entry where input key is key, map is [ pair (key, value), remaining ], and processed is kvs = output of function delete_entry where input key is key, map is remaining, and processed is kvs (Delete Key Property 2)
output of function delete_entry where input key is key, map is [ pair (lkey, lvalue), remaining ], and processed is kvs = output of function delete_entry where input key is key, map is remaining, and processed is [ pair (lkey, lvalue), kvs ] (Delete Key Property 3)
result of pushing nodes [ pair (value, weight), rest ] into tree tree where parent is index and parent distance is distance = result of pushing nodes rest into tree [ node (value, (distance + weight), index), tree ] where parent is index and parent distance is distance (push children node)
output of the separate_nodes function where the input tree is tree, the nodes are [ ], the existing group is exist, and the new group is new = pair (exist, new) (Separate old and new finished)

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 = 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 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:
    • Parameters List at time t = [ ]
    • Expression Stack at time t = [ [ ], [ [ obj_name.method_name(args), ys ], rest ] ]
    • value at obj_name in map (Variables Map at time t) = Python reference index
    • the element at index index of stack (Python Object Store at time t) = Python object: [ entry "__class_name__": class_name, e_rest ]
    • line number of method method_name of class class_name in (Class Map at time t) = line

    then Control Map at time (t + 1) = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", method_name)), [ ] ] ]

    (link)
  • if the following are true:
    • Parameters List at time t = [ ]
    • Expression Stack at time t = [ [ ], [ [ Python constructor with name: class_name and arguments: args, ys ], rest ] ]
    • line number of method "__init__" of class class_name in (Class Map at time t) = line

    then Control Map at time (t + 1) = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", "__init__")), [ ] ] ]

    (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 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

    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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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:
    • expression state at time t = "call_build_args"
    • Parameters List at time t = [ ]
    • the expression at time t = function call with name: name and arguments: args
    • there is a function named name with parameters params at line line

    then Control Map at time (t + 1) = [ entry 0: (pair ("function", name)), [ ] ]

    (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 = 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 = 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"
    • 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 = 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 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 = "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 = 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 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:
    • expression state at time t = "call_build_args"
    • Parameters List at time t = [ ]
    • the expression at time t = obj_name.method_name(args)
    • value at obj_name in map (Variables Map at time t) = Python reference index
    • the element at index index of stack (Python Object Store at time t) = Python object: [ entry "__class_name__": class_name, e_rest ]
    • line number of method method_name of class class_name in (Class Map at time t) = line

    then Control Map at time (t + 1) = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", method_name)), [ ] ] ]

    (link)
  • if the following are true:
    • expression state at time t = "call_build_args"
    • Parameters List at time t = [ ]
    • the expression at time t = Python constructor with name: class_name and arguments: args
    • line number of method "__init__" of class class_name in (Class Map at time t) = line

    then Control Map at time (t + 1) = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", "__init__")), [ ] ] ]

    (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 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

    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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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
    • number of lines = i - 1
    • 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:
    • Parameters List at time t = [ ]
    • Expression Stack at time t = [ [ ], [ [ function call with name: name and arguments: args, ys ], rest ] ]
    • there is a function named name with parameters params at line line

    then Control Map at time (t + 1) = [ entry 0: (pair ("function", name)), [ ] ]

    (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 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 = 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 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 = 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 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" 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 entry_key = key, then output of function delete_entry where input key is key, map is [ pair (entry_key, value), remaining ], and processed is kvs = result of dumping kvs to remaining (link)
  • if not (entry_key = key), then output of function delete_entry where input key is key, map is [ pair (entry_key, value), remaining ], and processed is kvs = output of function delete_entry where input key is key, map is remaining, and processed is [ pair (entry_key, value), kvs ] (link)
  • if the following are true:
    • not (left = value)
    • not (right = value)

    then output of the find_neighbors function where the input graph is [ pair (left, right), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are result

    (link)
  • if left = value, then output of the find_neighbors function where the input graph is [ pair (left, right), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are [ right, result ] (link)
  • if right = value, then output of the find_neighbors function where the input graph is [ pair (left, right), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are [ left, result ] (link)
  • if left = value, then output of the find_neighbors function where the input graph is [ edge (left, right, weight), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are [ pair (right, weight), result ] (link)
  • if right = value, then output of the find_neighbors function where the input graph is [ edge (left, right, weight), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are [ pair (left, weight), result ] (link)
  • if tree tree contains value = False, then output of the separate_nodes function where the input tree is tree, the nodes are [ pair (value, weight), rest ], the existing group is exist, and the new group is new = output of the separate_nodes function where the input tree is tree, the nodes are rest, the existing group is exist, and the new group is [ pair (value, weight), new ] (link)
  • if index of value value in tree = index, then output of the separate_nodes function where the input tree is tree, the nodes are [ pair (value, weight), rest ], the existing group is exist, and the new group is new = output of the separate_nodes function where the input tree is tree, the nodes are rest, the existing group is [ pair (index, weight), exist ], and the new group is new (link)
  • if the following are true:
    • the element at index child_i of stack tree = node (child_value, child_d, child_prev)
    • distance + weight < child_d
    • result of storing (node (child_value, (distance + weight), index)) at index child_i of stack tree = updated

    then result of updating nodes [ pair (child_i, weight), rest ] in tree tree with parent index index and parent distance distance = result of updating nodes rest in tree updated with parent index index and parent distance distance

    (link)
  • if the following are true:
    • the element at index child_i of stack tree = node (child_value, child_d, child_prev)
    • distance + weight > child_d

    then result of updating nodes [ pair (child_i, weight), rest ] in tree tree with parent index index and parent distance distance = result of updating nodes rest in tree tree with parent index index and parent distance distance

    (link)
  • if the following are true:
    • ((length of stack tree) - 1) - index = back_i
    • the element at index back_i of stack tree = node (value, distance, previous)
    • result of splitting pairs into nodes that exist in the tree tree and new nodes = pair (exists, new)
    • result of updating nodes exists in tree tree with parent index index and parent distance distance = updated

    then result of adding or updating children pairs of the node at backwards index index in tree tree = result of pushing nodes new into tree updated where parent is index and parent distance is distance

    (link)


Comments

Please log in to add comments