You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v07 --refutes--> v2b
- v2b --supports--> v19
- v19 --refutes--> v12
- v12 --refutes--> v1f
- v1f --refutes--> v1a
- v1a --supports--> v16
- v16 --supports--> v23
- v23 --refutes--> v1c
- v1c --refutes--> v11
- v11 --refutes--> v26
- v26 --supports--> v08
- v08 --supports--> v1b
- v1b --refutes--> v0d
- v0d --refutes--> v28
- v28 --supports--> v1e
- v1e --supports--> v01
- v01 --refutes--> v0c
- v0c --refutes--> v10
- v10 --supports--> v20
- v20 --supports--> v1d
- v1d --refutes--> v00
- v00 --supports--> v0e
- v0e --refutes--> v2f
- v2f --supports--> v18
- v18 --refutes--> v25
- v25 --supports--> v17
- v17 --supports--> v14
- v14 --refutes--> v30
- v30 --refutes--> v03
- v03 --supports--> v09
- v09 --supports--> v0f
- v0f --refutes--> v04

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --refutes--> v0a
- v01 --refutes--> v27
- v0d --supports--> v02
- v11 --refutes--> v2d
- v14 --refutes--> v13
- v14 --supports--> v2e
- v17 --refutes--> v05
- v18 --refutes--> v0b
- v19 --refutes--> v29
- v19 --supports--> v2c
- v1b --supports--> v24
- v1c --supports--> v22
- v1d --supports--> v2a
- v20 --supports--> v21
- v28 --refutes--> v06
- v30 --supports--> v15

[VERIFIED ROOT]
v07 = TRUE

[TARGET]
v04

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v25 --refutes--> v1e
- v1e --supports--> v01
- v01 --refutes--> v02
- v02 --refutes--> v2b
- v2b --refutes--> v2e
- v2e --supports--> v27
- v27 --refutes--> v17
- v17 --supports--> v14
- v14 --supports--> v09
- v09 --refutes--> v05
- v05 --supports--> v12
- v12 --refutes--> v30
- v30 --supports--> v1d
- v1d --supports--> v16
- v16 --supports--> v28
- v28 --refutes--> v15
- v15 --refutes--> v03
- v03 --refutes--> v21
- v21 --supports--> v00
- v00 --refutes--> v07
- v07 --supports--> v0c
- v0c --refutes--> v0d
- v0d --refutes--> v29
- v29 --supports--> v23
- v23 --refutes--> v1a
- v1a --refutes--> v1b
- v1b --refutes--> v0f
- v0f --supports--> v2a
- v2a --refutes--> v2c
- v2c --supports--> v11
- v11 --supports--> v1c
- v1c --refutes--> v1f

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v03 --refutes--> v20
- v03 --supports--> v13
- v05 --supports--> v08
- v07 --refutes--> v26
- v09 --refutes--> v0a
- v0f --refutes--> v2d
- v17 --supports--> v19
- v17 --supports--> v22
- v1b --refutes--> v04
- v1b --refutes--> v0e
- v1c --refutes--> v0b
- v1c --supports--> v24
- v1e --refutes--> v10
- v29 --refutes--> v2f
- v2b --refutes--> v06
- v2e --refutes--> v18

[VERIFIED ROOT]
v25 = TRUE

[TARGET]
v1f

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v25 --supports--> v29
- v29 --refutes--> v07
- v07 --supports--> v1c
- v1c --supports--> v02
- v02 --refutes--> v2d
- v2d --refutes--> v28
- v28 --supports--> v0c
- v0c --supports--> v11
- v11 --supports--> v09
- v09 --refutes--> v04
- v04 --refutes--> v19
- v19 --supports--> v10
- v10 --refutes--> v18
- v18 --supports--> v00
- v00 --refutes--> v13
- v13 --supports--> v23
- v23 --supports--> v2f
- v2f --supports--> v12
- v12 --refutes--> v16
- v16 --refutes--> v0e
- v0e --refutes--> v0a
- v0a --refutes--> v0d
- v0d --supports--> v26
- v26 --supports--> v2e
- v2e --supports--> v05
- v05 --refutes--> v22
- v22 --refutes--> v06
- v06 --refutes--> v1d
- v1d --supports--> v17
- v17 --refutes--> v21
- v21 --supports--> v0f
- v0f --refutes--> v15

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v2a
- v04 --supports--> v03
- v06 --supports--> v01
- v07 --refutes--> v27
- v0e --supports--> v1b
- v0f --refutes--> v14
- v0f --supports--> v24
- v16 --refutes--> v1f
- v19 --supports--> v30
- v1c --refutes--> v1a
- v1d --supports--> v2c
- v23 --refutes--> v08
- v25 --refutes--> v1e
- v29 --refutes--> v20
- v2f --refutes--> v0b
- v2f --supports--> v2b

[VERIFIED ROOT]
v25 = FALSE

[TARGET]
v15

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v19 --refutes--> v26
- v26 --refutes--> v2c
- v2c --refutes--> v2e
- v2e --refutes--> v0f
- v0f --supports--> v20
- v20 --refutes--> v17
- v17 --refutes--> v02
- v02 --refutes--> v11
- v11 --refutes--> v04
- v04 --supports--> v30
- v30 --supports--> v1c
- v1c --refutes--> v00
- v00 --refutes--> v06
- v06 --supports--> v1a
- v1a --refutes--> v23
- v23 --supports--> v1e
- v1e --refutes--> v03
- v03 --refutes--> v25
- v25 --refutes--> v12
- v12 --supports--> v1f
- v1f --supports--> v15
- v15 --supports--> v18
- v18 --refutes--> v0a
- v0a --refutes--> v2d
- v2d --refutes--> v1d
- v1d --refutes--> v21
- v21 --refutes--> v2f
- v2f --refutes--> v1b
- v1b --supports--> v27
- v27 --supports--> v10
- v10 --supports--> v01
- v01 --refutes--> v24

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --supports--> v0b
- v01 --supports--> v0c
- v03 --refutes--> v09
- v10 --refutes--> v13
- v12 --refutes--> v14
- v18 --supports--> v08
- v19 --refutes--> v2a
- v19 --supports--> v0e
- v1a --supports--> v16
- v1e --supports--> v05
- v1e --supports--> v29
- v1f --refutes--> v22
- v1f --supports--> v2b
- v23 --supports--> v28
- v2f --supports--> v0d
- v30 --supports--> v07

[VERIFIED ROOT]
v19 = FALSE

[TARGET]
v24

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v2b --refutes--> v16
- v16 --refutes--> v0e
- v0e --refutes--> v06
- v06 --supports--> v09
- v09 --refutes--> v2d
- v2d --supports--> v23
- v23 --supports--> v18
- v18 --supports--> v2a
- v2a --refutes--> v00
- v00 --supports--> v20
- v20 --supports--> v13
- v13 --supports--> v28
- v28 --supports--> v02
- v02 --supports--> v14
- v14 --supports--> v17
- v17 --refutes--> v1f
- v1f --supports--> v19
- v19 --refutes--> v26
- v26 --refutes--> v15
- v15 --supports--> v22
- v22 --refutes--> v21
- v21 --supports--> v0c
- v0c --refutes--> v05
- v05 --supports--> v11
- v11 --refutes--> v27
- v27 --supports--> v0d
- v0d --refutes--> v01
- v01 --supports--> v03
- v03 --refutes--> v30
- v30 --supports--> v2f
- v2f --refutes--> v1d
- v1d --refutes--> v10

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --supports--> v29
- v05 --refutes--> v24
- v06 --supports--> v07
- v14 --refutes--> v2e
- v17 --refutes--> v1a
- v19 --refutes--> v1e
- v20 --supports--> v08
- v21 --refutes--> v12
- v21 --refutes--> v1b
- v21 --supports--> v0b
- v23 --supports--> v1c
- v27 --refutes--> v2c
- v28 --supports--> v25
- v2f --supports--> v0f
- v30 --refutes--> v0a
- v30 --supports--> v04

[VERIFIED ROOT]
v2b = TRUE

[TARGET]
v10

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v25 --refutes--> v1c
- v1c --refutes--> v22
- v22 --refutes--> v01
- v01 --supports--> v1b
- v1b --supports--> v06
- v06 --supports--> v14
- v14 --refutes--> v2b
- v2b --supports--> v02
- v02 --refutes--> v20
- v20 --supports--> v21
- v21 --supports--> v26
- v26 --refutes--> v0f
- v0f --supports--> v1f
- v1f --supports--> v0c
- v0c --refutes--> v15
- v15 --supports--> v1d
- v1d --refutes--> v2a
- v2a --refutes--> v03
- v03 --refutes--> v1e
- v1e --refutes--> v12
- v12 --supports--> v07
- v07 --refutes--> v30
- v30 --refutes--> v2c
- v2c --refutes--> v08
- v08 --supports--> v24
- v24 --supports--> v09
- v09 --supports--> v04
- v04 --supports--> v10
- v10 --refutes--> v17
- v17 --refutes--> v13
- v13 --supports--> v0b
- v0b --refutes--> v27

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --supports--> v29
- v04 --supports--> v0d
- v09 --refutes--> v0e
- v0c --refutes--> v1a
- v0f --supports--> v23
- v12 --supports--> v19
- v13 --refutes--> v16
- v14 --refutes--> v00
- v1c --refutes--> v2e
- v1d --refutes--> v05
- v1d --supports--> v28
- v21 --refutes--> v11
- v22 --supports--> v0a
- v25 --refutes--> v18
- v25 --refutes--> v2f
- v30 --supports--> v2d

[VERIFIED ROOT]
v25 = FALSE

[TARGET]
v27

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v22 --supports--> v00
- v00 --supports--> v13
- v13 --refutes--> v16
- v16 --refutes--> v04
- v04 --supports--> v0f
- v0f --supports--> v1d
- v1d --refutes--> v05
- v05 --supports--> v2f
- v2f --supports--> v2a
- v2a --supports--> v07
- v07 --supports--> v18
- v18 --supports--> v01
- v01 --refutes--> v25
- v25 --supports--> v1a
- v1a --supports--> v0d
- v0d --refutes--> v1e
- v1e --supports--> v0e
- v0e --refutes--> v2e
- v2e --refutes--> v0a
- v0a --refutes--> v17
- v17 --refutes--> v23
- v23 --supports--> v2c
- v2c --refutes--> v29
- v29 --refutes--> v24
- v24 --supports--> v0c
- v0c --supports--> v21
- v21 --supports--> v30
- v30 --supports--> v06
- v06 --refutes--> v12
- v12 --refutes--> v26
- v26 --supports--> v14
- v14 --supports--> v1c

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v04 --refutes--> v08
- v05 --refutes--> v1f
- v0f --refutes--> v15
- v12 --supports--> v2b
- v14 --supports--> v03
- v14 --supports--> v0b
- v1a --refutes--> v11
- v1d --supports--> v20
- v22 --refutes--> v02
- v22 --supports--> v09
- v24 --refutes--> v19
- v24 --supports--> v28
- v24 --supports--> v2d
- v26 --supports--> v27
- v29 --supports--> v1b
- v2e --supports--> v10

[VERIFIED ROOT]
v22 = TRUE

[TARGET]
v1c

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v22 --supports--> v19
- v19 --supports--> v03
- v03 --refutes--> v1a
- v1a --refutes--> v1f
- v1f --supports--> v29
- v29 --supports--> v06
- v06 --supports--> v07
- v07 --refutes--> v26
- v26 --supports--> v16
- v16 --supports--> v0b
- v0b --supports--> v11
- v11 --supports--> v08
- v08 --refutes--> v18
- v18 --supports--> v2f
- v2f --supports--> v2d
- v2d --supports--> v24
- v24 --refutes--> v1d
- v1d --supports--> v28
- v28 --refutes--> v21
- v21 --supports--> v13
- v13 --refutes--> v0f
- v0f --refutes--> v15
- v15 --supports--> v0c
- v0c --refutes--> v02
- v02 --supports--> v09
- v09 --refutes--> v20
- v20 --refutes--> v25
- v25 --supports--> v1e
- v1e --supports--> v2e
- v2e --refutes--> v30
- v30 --supports--> v2a
- v2a --refutes--> v0a

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v1b
- v03 --supports--> v27
- v08 --supports--> v10
- v0c --refutes--> v0e
- v0f --refutes--> v04
- v1a --refutes--> v14
- v1f --supports--> v01
- v20 --refutes--> v12
- v22 --refutes--> v00
- v22 --refutes--> v1c
- v24 --refutes--> v0d
- v26 --refutes--> v17
- v29 --refutes--> v05
- v2a --refutes--> v2b
- v2a --refutes--> v2c
- v2e --supports--> v23

[VERIFIED ROOT]
v22 = FALSE

[TARGET]
v0a

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v2a --supports--> v2f
- v2f --refutes--> v05
- v05 --refutes--> v19
- v19 --refutes--> v14
- v14 --supports--> v04
- v04 --refutes--> v27
- v27 --refutes--> v07
- v07 --supports--> v2e
- v2e --refutes--> v00
- v00 --refutes--> v30
- v30 --supports--> v0c
- v0c --refutes--> v16
- v16 --supports--> v24
- v24 --supports--> v22
- v22 --refutes--> v2b
- v2b --refutes--> v18
- v18 --supports--> v03
- v03 --refutes--> v08
- v08 --supports--> v1b
- v1b --refutes--> v26
- v26 --supports--> v17
- v17 --supports--> v09
- v09 --supports--> v1f
- v1f --refutes--> v01
- v01 --refutes--> v1e
- v1e --supports--> v2d
- v2d --refutes--> v1d
- v1d --refutes--> v29
- v29 --refutes--> v10
- v10 --refutes--> v21
- v21 --refutes--> v1c
- v1c --supports--> v06

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --supports--> v15
- v03 --refutes--> v0b
- v04 --supports--> v0e
- v05 --refutes--> v0d
- v0c --supports--> v28
- v16 --refutes--> v2c
- v1b --refutes--> v20
- v1b --supports--> v11
- v1b --supports--> v1a
- v1b --supports--> v25
- v1e --supports--> v02
- v1f --refutes--> v23
- v21 --supports--> v12
- v2f --supports--> v0a
- v30 --refutes--> v0f
- v30 --supports--> v13

[VERIFIED ROOT]
v2a = TRUE

[TARGET]
v06

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v15 --supports--> v1d
- v1d --supports--> v2b
- v2b --supports--> v1e
- v1e --refutes--> v16
- v16 --supports--> v1b
- v1b --refutes--> v12
- v12 --supports--> v22
- v22 --refutes--> v30
- v30 --refutes--> v01
- v01 --supports--> v11
- v11 --supports--> v0e
- v0e --supports--> v29
- v29 --supports--> v02
- v02 --refutes--> v0b
- v0b --refutes--> v0d
- v0d --refutes--> v28
- v28 --supports--> v17
- v17 --supports--> v18
- v18 --supports--> v24
- v24 --supports--> v13
- v13 --supports--> v23
- v23 --supports--> v07
- v07 --refutes--> v10
- v10 --supports--> v03
- v03 --refutes--> v20
- v20 --supports--> v14
- v14 --refutes--> v2c
- v2c --refutes--> v08
- v08 --refutes--> v25
- v25 --supports--> v09
- v09 --supports--> v21
- v21 --supports--> v1a

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v08 --supports--> v1f
- v0d --refutes--> v2d
- v10 --supports--> v06
- v12 --refutes--> v27
- v12 --supports--> v2f
- v13 --refutes--> v0c
- v17 --refutes--> v00
- v17 --supports--> v0a
- v18 --supports--> v05
- v1d --refutes--> v2e
- v1e --supports--> v0f
- v22 --refutes--> v2a
- v23 --supports--> v04
- v24 --supports--> v19
- v2b --refutes--> v1c
- v30 --supports--> v26

[VERIFIED ROOT]
v15 = TRUE

[TARGET]
v1a

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v26 --refutes--> v16
- v16 --refutes--> v2a
- v2a --supports--> v30
- v30 --supports--> v09
- v09 --refutes--> v20
- v20 --refutes--> v0c
- v0c --refutes--> v00
- v00 --supports--> v2e
- v2e --supports--> v04
- v04 --refutes--> v1c
- v1c --supports--> v07
- v07 --refutes--> v06
- v06 --refutes--> v14
- v14 --supports--> v02
- v02 --supports--> v27
- v27 --refutes--> v2d
- v2d --supports--> v12
- v12 --supports--> v0a
- v0a --refutes--> v18
- v18 --refutes--> v11
- v11 --refutes--> v10
- v10 --refutes--> v15
- v15 --refutes--> v05
- v05 --refutes--> v2f
- v2f --refutes--> v13
- v13 --supports--> v23
- v23 --supports--> v1d
- v1d --supports--> v0e
- v0e --supports--> v08
- v08 --refutes--> v24
- v24 --supports--> v0b
- v0b --refutes--> v03

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --refutes--> v1b
- v06 --supports--> v25
- v07 --supports--> v17
- v0b --supports--> v19
- v13 --supports--> v0d
- v13 --supports--> v2b
- v14 --supports--> v21
- v14 --supports--> v28
- v16 --supports--> v22
- v18 --refutes--> v2c
- v1c --refutes--> v1a
- v1c --supports--> v0f
- v1c --supports--> v1e
- v1d --refutes--> v01
- v1d --refutes--> v1f
- v23 --supports--> v29

[VERIFIED ROOT]
v26 = FALSE

[TARGET]
v03

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v08 --supports--> v0b
- v0b --refutes--> v13
- v13 --supports--> v26
- v26 --refutes--> v06
- v06 --refutes--> v10
- v10 --supports--> v17
- v17 --supports--> v22
- v22 --supports--> v07
- v07 --supports--> v21
- v21 --refutes--> v0e
- v0e --refutes--> v30
- v30 --refutes--> v24
- v24 --refutes--> v1d
- v1d --supports--> v1a
- v1a --supports--> v1f
- v1f --supports--> v28
- v28 --supports--> v1c
- v1c --refutes--> v18
- v18 --refutes--> v25
- v25 --refutes--> v0c
- v0c --refutes--> v2a
- v2a --supports--> v01
- v01 --supports--> v04
- v04 --supports--> v2d
- v2d --refutes--> v0a
- v0a --supports--> v0f
- v0f --supports--> v2f
- v2f --refutes--> v15
- v15 --refutes--> v1e
- v1e --supports--> v00
- v00 --supports--> v27
- v27 --supports--> v2e

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --supports--> v14
- v06 --refutes--> v16
- v06 --supports--> v11
- v07 --refutes--> v2c
- v0e --refutes--> v2b
- v15 --refutes--> v09
- v17 --refutes--> v0d
- v1a --supports--> v20
- v1f --supports--> v05
- v21 --supports--> v19
- v24 --supports--> v03
- v25 --supports--> v12
- v26 --supports--> v1b
- v28 --refutes--> v02
- v30 --refutes--> v23
- v30 --refutes--> v29

[VERIFIED ROOT]
v08 = TRUE

[TARGET]
v2e

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v1b --refutes--> v22
- v22 --refutes--> v15
- v15 --supports--> v03
- v03 --refutes--> v21
- v21 --refutes--> v14
- v14 --refutes--> v26
- v26 --refutes--> v06
- v06 --supports--> v0b
- v0b --refutes--> v2b
- v2b --refutes--> v09
- v09 --supports--> v2f
- v2f --supports--> v19
- v19 --supports--> v0e
- v0e --refutes--> v25
- v25 --supports--> v11
- v11 --refutes--> v16
- v16 --supports--> v0d
- v0d --supports--> v18
- v18 --supports--> v28
- v28 --supports--> v04
- v04 --refutes--> v1e
- v1e --supports--> v13
- v13 --supports--> v17
- v17 --refutes--> v0c
- v0c --refutes--> v12
- v12 --refutes--> v0a
- v0a --supports--> v00
- v00 --supports--> v2d
- v2d --refutes--> v30
- v30 --refutes--> v1c
- v1c --refutes--> v10
- v10 --refutes--> v27

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v04 --refutes--> v1f
- v06 --supports--> v2a
- v0c --supports--> v29
- v11 --refutes--> v2c
- v12 --refutes--> v1a
- v12 --refutes--> v23
- v12 --supports--> v01
- v13 --supports--> v08
- v15 --refutes--> v24
- v15 --supports--> v05
- v1e --refutes--> v1d
- v21 --refutes--> v02
- v21 --supports--> v20
- v22 --supports--> v2e
- v28 --supports--> v07
- v30 --refutes--> v0f

[VERIFIED ROOT]
v1b = FALSE

[TARGET]
v27

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v11 --refutes--> v24
- v24 --supports--> v25
- v25 --refutes--> v2c
- v2c --supports--> v0c
- v0c --supports--> v2d
- v2d --refutes--> v04
- v04 --refutes--> v0f
- v0f --supports--> v13
- v13 --refutes--> v28
- v28 --supports--> v15
- v15 --supports--> v18
- v18 --supports--> v19
- v19 --refutes--> v01
- v01 --supports--> v02
- v02 --refutes--> v07
- v07 --refutes--> v0b
- v0b --refutes--> v30
- v30 --supports--> v09
- v09 --supports--> v1b
- v1b --refutes--> v0e
- v0e --supports--> v12
- v12 --refutes--> v1f
- v1f --supports--> v00
- v00 --supports--> v2b
- v2b --refutes--> v16
- v16 --supports--> v20
- v20 --refutes--> v0a
- v0a --refutes--> v2f
- v2f --refutes--> v23
- v23 --refutes--> v06
- v06 --refutes--> v1e
- v1e --supports--> v2e

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v14
- v02 --supports--> v17
- v02 --supports--> v22
- v09 --refutes--> v1d
- v0a --supports--> v1a
- v0b --refutes--> v1c
- v0e --supports--> v26
- v0f --supports--> v29
- v18 --refutes--> v10
- v19 --supports--> v05
- v1f --refutes--> v27
- v28 --supports--> v2a
- v2b --refutes--> v0d
- v2b --supports--> v08
- v2c --refutes--> v03
- v2f --supports--> v21

[VERIFIED ROOT]
v11 = FALSE

[TARGET]
v2e

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v26 --supports--> v10
- v10 --supports--> v2c
- v2c --supports--> v0d
- v0d --supports--> v23
- v23 --supports--> v16
- v16 --refutes--> v1a
- v1a --supports--> v27
- v27 --supports--> v05
- v05 --refutes--> v04
- v04 --refutes--> v21
- v21 --supports--> v29
- v29 --refutes--> v0e
- v0e --refutes--> v0b
- v0b --refutes--> v1d
- v1d --supports--> v01
- v01 --refutes--> v08
- v08 --supports--> v25
- v25 --refutes--> v06
- v06 --refutes--> v2a
- v2a --supports--> v00
- v00 --refutes--> v1c
- v1c --supports--> v13
- v13 --refutes--> v07
- v07 --refutes--> v0a
- v0a --refutes--> v11
- v11 --supports--> v2b
- v2b --refutes--> v1f
- v1f --refutes--> v17
- v17 --refutes--> v1e
- v1e --refutes--> v03
- v03 --refutes--> v0c
- v0c --supports--> v2f

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v0b --supports--> v0f
- v0b --supports--> v18
- v0c --refutes--> v22
- v0c --supports--> v09
- v0e --supports--> v15
- v10 --refutes--> v02
- v11 --refutes--> v20
- v13 --supports--> v1b
- v13 --supports--> v2d
- v17 --refutes--> v19
- v17 --refutes--> v28
- v1f --refutes--> v14
- v26 --refutes--> v24
- v27 --refutes--> v30
- v27 --supports--> v2e
- v2a --refutes--> v12

[VERIFIED ROOT]
v26 = FALSE

[TARGET]
v2f

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v2d --refutes--> v22
- v22 --supports--> v0f
- v0f --supports--> v11
- v11 --refutes--> v26
- v26 --refutes--> v16
- v16 --supports--> v1b
- v1b --refutes--> v2e
- v2e --supports--> v2c
- v2c --refutes--> v1c
- v1c --refutes--> v10
- v10 --refutes--> v13
- v13 --refutes--> v04
- v04 --supports--> v12
- v12 --refutes--> v21
- v21 --supports--> v1a
- v1a --refutes--> v1e
- v1e --refutes--> v2b
- v2b --supports--> v08
- v08 --supports--> v00
- v00 --supports--> v0d
- v0d --refutes--> v09
- v09 --refutes--> v18
- v18 --refutes--> v07
- v07 --supports--> v17
- v17 --supports--> v1f
- v1f --refutes--> v0a
- v0a --supports--> v05
- v05 --supports--> v30
- v30 --refutes--> v2f
- v2f --refutes--> v2a
- v2a --refutes--> v0c
- v0c --refutes--> v0e

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v08 --supports--> v1d
- v09 --supports--> v06
- v0a --refutes--> v19
- v0f --supports--> v01
- v13 --supports--> v20
- v17 --refutes--> v0b
- v17 --refutes--> v23
- v1a --supports--> v02
- v1b --supports--> v28
- v21 --supports--> v14
- v26 --supports--> v27
- v2a --refutes--> v03
- v2b --refutes--> v24
- v2b --supports--> v29
- v2f --refutes--> v25
- v2f --supports--> v15

[VERIFIED ROOT]
v2d = FALSE

[TARGET]
v0e

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v1e --supports--> v28
- v28 --refutes--> v13
- v13 --supports--> v1c
- v1c --refutes--> v0c
- v0c --refutes--> v06
- v06 --refutes--> v1f
- v1f --refutes--> v1b
- v1b --supports--> v10
- v10 --supports--> v29
- v29 --supports--> v2a
- v2a --supports--> v02
- v02 --refutes--> v0e
- v0e --refutes--> v16
- v16 --supports--> v21
- v21 --refutes--> v2b
- v2b --refutes--> v00
- v00 --supports--> v0b
- v0b --supports--> v14
- v14 --supports--> v26
- v26 --supports--> v19
- v19 --refutes--> v20
- v20 --refutes--> v17
- v17 --refutes--> v1a
- v1a --supports--> v0a
- v0a --supports--> v03
- v03 --supports--> v1d
- v1d --refutes--> v09
- v09 --refutes--> v24
- v24 --refutes--> v08
- v08 --supports--> v22
- v22 --refutes--> v25
- v25 --refutes--> v18

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v06 --refutes--> v05
- v08 --refutes--> v27
- v09 --refutes--> v2f
- v0a --refutes--> v11
- v0b --supports--> v0f
- v0c --refutes--> v12
- v10 --refutes--> v01
- v10 --supports--> v2d
- v10 --supports--> v2e
- v13 --supports--> v0d
- v1a --refutes--> v07
- v21 --supports--> v04
- v21 --supports--> v23
- v24 --refutes--> v30
- v28 --supports--> v2c
- v29 --refutes--> v15

[VERIFIED ROOT]
v1e = TRUE

[TARGET]
v18

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v15 --refutes--> v25
- v25 --refutes--> v07
- v07 --refutes--> v18
- v18 --refutes--> v23
- v23 --supports--> v0e
- v0e --refutes--> v27
- v27 --refutes--> v1f
- v1f --refutes--> v0c
- v0c --supports--> v2f
- v2f --supports--> v29
- v29 --supports--> v1a
- v1a --supports--> v01
- v01 --refutes--> v10
- v10 --supports--> v26
- v26 --refutes--> v05
- v05 --supports--> v2d
- v2d --refutes--> v17
- v17 --supports--> v08
- v08 --refutes--> v12
- v12 --supports--> v2a
- v2a --supports--> v30
- v30 --refutes--> v0a
- v0a --refutes--> v19
- v19 --refutes--> v00
- v00 --refutes--> v2b
- v2b --supports--> v02
- v02 --refutes--> v24
- v24 --supports--> v2e
- v2e --refutes--> v03
- v03 --supports--> v21
- v21 --refutes--> v20
- v20 --refutes--> v13

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --supports--> v04
- v03 --refutes--> v06
- v05 --supports--> v16
- v05 --supports--> v22
- v08 --refutes--> v1e
- v08 --supports--> v11
- v0e --refutes--> v09
- v10 --refutes--> v14
- v15 --refutes--> v1b
- v19 --supports--> v0d
- v20 --refutes--> v1c
- v26 --supports--> v28
- v27 --refutes--> v0b
- v2a --refutes--> v1d
- v2a --refutes--> v2c
- v2b --supports--> v0f

[VERIFIED ROOT]
v15 = FALSE

[TARGET]
v13

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v08 --refutes--> v22
- v22 --supports--> v0e
- v0e --refutes--> v15
- v15 --supports--> v25
- v25 --refutes--> v2a
- v2a --supports--> v28
- v28 --refutes--> v2d
- v2d --supports--> v04
- v04 --supports--> v21
- v21 --refutes--> v16
- v16 --supports--> v00
- v00 --supports--> v05
- v05 --supports--> v0c
- v0c --refutes--> v14
- v14 --refutes--> v13
- v13 --supports--> v06
- v06 --supports--> v1a
- v1a --supports--> v2b
- v2b --refutes--> v2c
- v2c --refutes--> v2f
- v2f --supports--> v18
- v18 --supports--> v12
- v12 --supports--> v01
- v01 --refutes--> v07
- v07 --refutes--> v26
- v26 --supports--> v03
- v03 --supports--> v0f
- v0f --supports--> v29
- v29 --supports--> v10
- v10 --supports--> v24
- v24 --refutes--> v1c
- v1c --supports--> v0b

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --supports--> v2e
- v01 --refutes--> v20
- v01 --refutes--> v27
- v08 --refutes--> v1d
- v0e --refutes--> v30
- v12 --supports--> v11
- v13 --refutes--> v1b
- v14 --supports--> v17
- v1a --supports--> v0a
- v2a --refutes--> v1f
- v2c --refutes--> v09
- v2c --supports--> v0d
- v2d --supports--> v02
- v2d --supports--> v23
- v2f --supports--> v19
- v2f --supports--> v1e

[VERIFIED ROOT]
v08 = FALSE

[TARGET]
v0b

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v00 --supports--> v08
- v08 --supports--> v22
- v22 --supports--> v2e
- v2e --refutes--> v0b
- v0b --refutes--> v24
- v24 --supports--> v26
- v26 --refutes--> v01
- v01 --refutes--> v1c
- v1c --supports--> v06
- v06 --refutes--> v29
- v29 --supports--> v13
- v13 --refutes--> v11
- v11 --refutes--> v02
- v02 --refutes--> v15
- v15 --supports--> v16
- v16 --refutes--> v2f
- v2f --refutes--> v28
- v28 --supports--> v0f
- v0f --supports--> v1d
- v1d --refutes--> v21
- v21 --refutes--> v10
- v10 --refutes--> v1b
- v1b --supports--> v30
- v30 --supports--> v0c
- v0c --supports--> v04
- v04 --supports--> v07
- v07 --refutes--> v0e
- v0e --supports--> v12
- v12 --supports--> v09
- v09 --refutes--> v1f
- v1f --supports--> v2d
- v2d --refutes--> v20

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --supports--> v03
- v04 --refutes--> v25
- v07 --supports--> v17
- v09 --supports--> v0a
- v0c --supports--> v18
- v0e --supports--> v19
- v0f --refutes--> v14
- v0f --refutes--> v23
- v0f --supports--> v2a
- v12 --supports--> v1a
- v1b --supports--> v0d
- v21 --refutes--> v27
- v28 --supports--> v2c
- v2f --refutes--> v1e
- v2f --refutes--> v2b
- v30 --refutes--> v05

[VERIFIED ROOT]
v00 = TRUE

[TARGET]
v20

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v2d --supports--> v24
- v24 --refutes--> v1e
- v1e --refutes--> v25
- v25 --refutes--> v30
- v30 --refutes--> v05
- v05 --refutes--> v08
- v08 --supports--> v0d
- v0d --refutes--> v27
- v27 --supports--> v28
- v28 --refutes--> v19
- v19 --supports--> v2e
- v2e --refutes--> v1f
- v1f --supports--> v20
- v20 --supports--> v0a
- v0a --refutes--> v26
- v26 --refutes--> v0c
- v0c --refutes--> v2a
- v2a --supports--> v00
- v00 --refutes--> v1b
- v1b --refutes--> v14
- v14 --supports--> v12
- v12 --refutes--> v09
- v09 --refutes--> v13
- v13 --supports--> v01
- v01 --supports--> v04
- v04 --refutes--> v02
- v02 --supports--> v1c
- v1c --supports--> v22
- v22 --refutes--> v06
- v06 --supports--> v10
- v10 --supports--> v2c
- v2c --refutes--> v07

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v04 --refutes--> v15
- v06 --supports--> v21
- v0a --refutes--> v03
- v12 --supports--> v0f
- v12 --supports--> v2f
- v19 --refutes--> v29
- v1f --supports--> v11
- v22 --refutes--> v18
- v25 --supports--> v2b
- v28 --supports--> v0b
- v28 --supports--> v0e
- v2a --refutes--> v1a
- v2a --supports--> v23
- v2c --supports--> v17
- v30 --supports--> v16
- v30 --supports--> v1d

[VERIFIED ROOT]
v2d = FALSE

[TARGET]
v07

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v13 --supports--> v1d
- v1d --supports--> v0f
- v0f --refutes--> v0e
- v0e --refutes--> v19
- v19 --refutes--> v11
- v11 --supports--> v2e
- v2e --supports--> v1c
- v1c --refutes--> v08
- v08 --supports--> v23
- v23 --refutes--> v1f
- v1f --supports--> v04
- v04 --supports--> v0c
- v0c --supports--> v0b
- v0b --refutes--> v20
- v20 --refutes--> v07
- v07 --supports--> v10
- v10 --refutes--> v02
- v02 --supports--> v21
- v21 --supports--> v05
- v05 --refutes--> v26
- v26 --refutes--> v24
- v24 --refutes--> v09
- v09 --refutes--> v28
- v28 --supports--> v2c
- v2c --refutes--> v2d
- v2d --refutes--> v1a
- v1a --refutes--> v06
- v06 --refutes--> v30
- v30 --refutes--> v1b
- v1b --refutes--> v2b
- v2b --refutes--> v01
- v01 --supports--> v14

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --refutes--> v1e
- v0c --refutes--> v25
- v0c --supports--> v2a
- v0f --supports--> v22
- v13 --supports--> v03
- v1a --supports--> v29
- v1c --refutes--> v0a
- v1c --supports--> v0d
- v1c --supports--> v12
- v1d --supports--> v16
- v1f --refutes--> v15
- v1f --supports--> v18
- v24 --refutes--> v00
- v24 --supports--> v17
- v2d --supports--> v2f
- v30 --refutes--> v27

[VERIFIED ROOT]
v13 = FALSE

[TARGET]
v14

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v05 --supports--> v04
- v04 --refutes--> v1c
- v1c --supports--> v16
- v16 --supports--> v11
- v11 --refutes--> v0b
- v0b --supports--> v22
- v22 --refutes--> v10
- v10 --refutes--> v03
- v03 --refutes--> v15
- v15 --refutes--> v1e
- v1e --supports--> v24
- v24 --refutes--> v2d
- v2d --refutes--> v18
- v18 --supports--> v26
- v26 --supports--> v21
- v21 --refutes--> v20
- v20 --supports--> v01
- v01 --supports--> v27
- v27 --refutes--> v2b
- v2b --supports--> v0e
- v0e --supports--> v12
- v12 --supports--> v1d
- v1d --supports--> v25
- v25 --supports--> v07
- v07 --refutes--> v02
- v02 --supports--> v2f
- v2f --supports--> v2c
- v2c --refutes--> v2a
- v2a --refutes--> v23
- v23 --supports--> v28
- v28 --supports--> v19
- v19 --refutes--> v1f

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --refutes--> v0d
- v02 --refutes--> v17
- v02 --refutes--> v29
- v07 --refutes--> v08
- v07 --supports--> v2e
- v0b --refutes--> v00
- v0b --refutes--> v14
- v18 --refutes--> v0a
- v19 --refutes--> v0f
- v22 --refutes--> v13
- v22 --supports--> v06
- v26 --refutes--> v0c
- v28 --refutes--> v1a
- v28 --supports--> v09
- v28 --supports--> v30
- v2c --refutes--> v1b

[VERIFIED ROOT]
v05 = FALSE

[TARGET]
v1f

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v0e --supports--> v05
- v05 --supports--> v2e
- v2e --supports--> v0c
- v0c --supports--> v2a
- v2a --refutes--> v11
- v11 --supports--> v0f
- v0f --supports--> v1e
- v1e --refutes--> v0a
- v0a --supports--> v2d
- v2d --refutes--> v08
- v08 --refutes--> v06
- v06 --supports--> v26
- v26 --refutes--> v20
- v20 --supports--> v01
- v01 --supports--> v0b
- v0b --refutes--> v24
- v24 --supports--> v22
- v22 --supports--> v17
- v17 --refutes--> v25
- v25 --supports--> v23
- v23 --supports--> v30
- v30 --refutes--> v0d
- v0d --supports--> v28
- v28 --refutes--> v21
- v21 --supports--> v10
- v10 --refutes--> v1b
- v1b --supports--> v1a
- v1a --refutes--> v12
- v12 --refutes--> v16
- v16 --refutes--> v09
- v09 --refutes--> v1c
- v1c --refutes--> v2f

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v0e --refutes--> v00
- v16 --supports--> v1f
- v17 --supports--> v29
- v1b --refutes--> v07
- v1b --supports--> v27
- v20 --refutes--> v03
- v20 --supports--> v2c
- v21 --refutes--> v19
- v21 --supports--> v13
- v22 --refutes--> v1d
- v24 --supports--> v02
- v28 --refutes--> v2b
- v28 --supports--> v18
- v2a --refutes--> v15
- v2e --refutes--> v04
- v2e --supports--> v14

[VERIFIED ROOT]
v0e = FALSE

[TARGET]
v2f

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v07 --supports--> v24
- v24 --refutes--> v04
- v04 --refutes--> v1a
- v1a --supports--> v17
- v17 --supports--> v1c
- v1c --refutes--> v0e
- v0e --supports--> v12
- v12 --refutes--> v1d
- v1d --supports--> v30
- v30 --supports--> v2b
- v2b --refutes--> v0d
- v0d --supports--> v01
- v01 --supports--> v0f
- v0f --refutes--> v25
- v25 --refutes--> v2a
- v2a --supports--> v23
- v23 --refutes--> v02
- v02 --supports--> v21
- v21 --supports--> v20
- v20 --supports--> v18
- v18 --supports--> v06
- v06 --supports--> v03
- v03 --refutes--> v22
- v22 --supports--> v2e
- v2e --refutes--> v2f
- v2f --refutes--> v10
- v10 --refutes--> v05
- v05 --supports--> v19
- v19 --supports--> v0b
- v0b --supports--> v15
- v15 --refutes--> v09
- v09 --refutes--> v00

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v0a
- v03 --refutes--> v2d
- v03 --supports--> v26
- v09 --supports--> v16
- v0b --refutes--> v0c
- v12 --supports--> v08
- v15 --supports--> v29
- v15 --supports--> v2c
- v19 --supports--> v28
- v1a --refutes--> v1f
- v1d --supports--> v14
- v22 --refutes--> v13
- v2b --supports--> v11
- v2b --supports--> v27
- v2e --supports--> v1e
- v2f --supports--> v1b

[VERIFIED ROOT]
v07 = FALSE

[TARGET]
v00

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v13 --refutes--> v2c
- v2c --refutes--> v20
- v20 --refutes--> v05
- v05 --supports--> v08
- v08 --refutes--> v02
- v02 --refutes--> v1e
- v1e --refutes--> v03
- v03 --supports--> v2b
- v2b --refutes--> v07
- v07 --refutes--> v15
- v15 --supports--> v00
- v00 --refutes--> v0f
- v0f --refutes--> v18
- v18 --supports--> v16
- v16 --supports--> v2f
- v2f --refutes--> v06
- v06 --refutes--> v24
- v24 --supports--> v12
- v12 --refutes--> v04
- v04 --supports--> v0a
- v0a --refutes--> v1a
- v1a --supports--> v0e
- v0e --supports--> v29
- v29 --supports--> v1b
- v1b --refutes--> v23
- v23 --refutes--> v10
- v10 --refutes--> v1c
- v1c --refutes--> v25
- v25 --supports--> v11
- v11 --supports--> v30
- v30 --supports--> v27
- v27 --refutes--> v01

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v05 --supports--> v17
- v06 --supports--> v0d
- v0e --refutes--> v2d
- v0e --supports--> v28
- v11 --refutes--> v09
- v12 --supports--> v14
- v15 --refutes--> v2e
- v1a --supports--> v22
- v1b --refutes--> v26
- v1b --supports--> v19
- v20 --refutes--> v0c
- v23 --refutes--> v2a
- v25 --refutes--> v0b
- v2b --supports--> v1d
- v2b --supports--> v1f
- v30 --refutes--> v21

[VERIFIED ROOT]
v13 = FALSE

[TARGET]
v01

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v29 --refutes--> v13
- v13 --supports--> v1f
- v1f --refutes--> v23
- v23 --refutes--> v01
- v01 --refutes--> v0d
- v0d --refutes--> v02
- v02 --refutes--> v30
- v30 --refutes--> v2f
- v2f --supports--> v2b
- v2b --refutes--> v15
- v15 --supports--> v19
- v19 --supports--> v25
- v25 --supports--> v20
- v20 --refutes--> v17
- v17 --supports--> v24
- v24 --supports--> v11
- v11 --supports--> v26
- v26 --refutes--> v00
- v00 --refutes--> v1c
- v1c --refutes--> v28
- v28 --refutes--> v0a
- v0a --supports--> v2c
- v2c --refutes--> v07
- v07 --supports--> v12
- v12 --refutes--> v1a
- v1a --supports--> v0b
- v0b --refutes--> v0c
- v0c --refutes--> v10
- v10 --refutes--> v2a
- v2a --refutes--> v0f
- v0f --supports--> v2e
- v2e --supports--> v09

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --supports--> v1b
- v07 --refutes--> v1e
- v0a --refutes--> v1d
- v0c --supports--> v0e
- v0c --supports--> v22
- v0d --refutes--> v04
- v12 --supports--> v16
- v15 --refutes--> v27
- v1f --refutes--> v18
- v23 --refutes--> v06
- v24 --refutes--> v21
- v25 --refutes--> v05
- v25 --supports--> v14
- v29 --refutes--> v03
- v2e --refutes--> v2d
- v30 --supports--> v08

[VERIFIED ROOT]
v29 = TRUE

[TARGET]
v09

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v15 --refutes--> v02
- v02 --supports--> v26
- v26 --refutes--> v19
- v19 --refutes--> v1f
- v1f --refutes--> v2a
- v2a --refutes--> v25
- v25 --supports--> v00
- v00 --refutes--> v23
- v23 --refutes--> v1c
- v1c --refutes--> v0c
- v0c --refutes--> v0b
- v0b --supports--> v03
- v03 --refutes--> v22
- v22 --refutes--> v17
- v17 --refutes--> v28
- v28 --supports--> v2c
- v2c --refutes--> v1a
- v1a --supports--> v16
- v16 --refutes--> v2f
- v2f --supports--> v27
- v27 --supports--> v13
- v13 --supports--> v0a
- v0a --refutes--> v10
- v10 --refutes--> v04
- v04 --refutes--> v20
- v20 --supports--> v2e
- v2e --refutes--> v1b
- v1b --refutes--> v2d
- v2d --supports--> v24
- v24 --refutes--> v29
- v29 --supports--> v1d
- v1d --refutes--> v21

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v05
- v03 --supports--> v0f
- v0c --refutes--> v14
- v0c --refutes--> v18
- v0c --supports--> v2b
- v10 --refutes--> v0e
- v1b --supports--> v1e
- v1c --refutes--> v08
- v20 --refutes--> v11
- v20 --refutes--> v30
- v20 --supports--> v09
- v22 --refutes--> v0d
- v25 --supports--> v01
- v28 --supports--> v06
- v29 --supports--> v12
- v2a --supports--> v07

[VERIFIED ROOT]
v15 = FALSE

[TARGET]
v21

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v2b --refutes--> v07
- v07 --refutes--> v10
- v10 --supports--> v22
- v22 --refutes--> v28
- v28 --supports--> v21
- v21 --refutes--> v2c
- v2c --refutes--> v2e
- v2e --refutes--> v2f
- v2f --supports--> v12
- v12 --refutes--> v30
- v30 --refutes--> v08
- v08 --refutes--> v18
- v18 --supports--> v00
- v00 --supports--> v0f
- v0f --supports--> v25
- v25 --refutes--> v01
- v01 --refutes--> v17
- v17 --refutes--> v0d
- v0d --refutes--> v1b
- v1b --supports--> v0e
- v0e --supports--> v1d
- v1d --supports--> v11
- v11 --supports--> v02
- v02 --refutes--> v0a
- v0a --supports--> v16
- v16 --refutes--> v1e
- v1e --supports--> v2a
- v2a --supports--> v27
- v27 --supports--> v26
- v26 --refutes--> v0c
- v0c --supports--> v29
- v29 --supports--> v05

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --supports--> v20
- v07 --supports--> v1f
- v07 --supports--> v24
- v0e --supports--> v15
- v10 --supports--> v06
- v12 --refutes--> v1a
- v17 --refutes--> v03
- v1e --supports--> v19
- v22 --refutes--> v13
- v25 --supports--> v1c
- v27 --refutes--> v2d
- v28 --supports--> v14
- v2b --refutes--> v09
- v2c --refutes--> v0b
- v2f --refutes--> v23
- v30 --supports--> v04

[VERIFIED ROOT]
v2b = FALSE

[TARGET]
v05

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v30 --refutes--> v12
- v12 --supports--> v16
- v16 --refutes--> v25
- v25 --supports--> v2b
- v2b --refutes--> v2f
- v2f --supports--> v1c
- v1c --supports--> v05
- v05 --supports--> v15
- v15 --refutes--> v2d
- v2d --refutes--> v17
- v17 --supports--> v0b
- v0b --refutes--> v00
- v00 --refutes--> v1d
- v1d --supports--> v0a
- v0a --supports--> v19
- v19 --supports--> v07
- v07 --supports--> v13
- v13 --supports--> v27
- v27 --supports--> v29
- v29 --refutes--> v0d
- v0d --supports--> v10
- v10 --refutes--> v2c
- v2c --supports--> v1f
- v1f --refutes--> v28
- v28 --refutes--> v2a
- v2a --supports--> v03
- v03 --refutes--> v02
- v02 --supports--> v20
- v20 --refutes--> v0e
- v0e --refutes--> v0c
- v0c --supports--> v0f
- v0f --supports--> v22

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v1a
- v05 --refutes--> v14
- v07 --supports--> v21
- v0a --supports--> v01
- v0b --refutes--> v23
- v0c --refutes--> v2e
- v0c --supports--> v24
- v0e --refutes--> v11
- v0e --supports--> v1e
- v12 --refutes--> v26
- v13 --refutes--> v08
- v1d --supports--> v06
- v29 --supports--> v1b
- v2b --supports--> v09
- v2c --supports--> v04
- v2f --supports--> v18

[VERIFIED ROOT]
v30 = TRUE

[TARGET]
v22

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v0d --supports--> v27
- v27 --supports--> v2f
- v2f --refutes--> v2b
- v2b --supports--> v01
- v01 --refutes--> v0b
- v0b --refutes--> v20
- v20 --refutes--> v22
- v22 --supports--> v08
- v08 --supports--> v07
- v07 --supports--> v1f
- v1f --supports--> v0c
- v0c --supports--> v00
- v00 --refutes--> v1c
- v1c --refutes--> v11
- v11 --supports--> v24
- v24 --refutes--> v21
- v21 --supports--> v04
- v04 --refutes--> v1a
- v1a --supports--> v28
- v28 --supports--> v0e
- v0e --supports--> v0a
- v0a --refutes--> v2d
- v2d --refutes--> v29
- v29 --supports--> v2a
- v2a --refutes--> v15
- v15 --refutes--> v25
- v25 --supports--> v1e
- v1e --supports--> v1d
- v1d --supports--> v18
- v18 --supports--> v03
- v03 --refutes--> v12
- v12 --supports--> v2e

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --refutes--> v10
- v00 --refutes--> v1b
- v01 --supports--> v26
- v04 --refutes--> v0f
- v0d --supports--> v16
- v0e --supports--> v17
- v0e --supports--> v30
- v12 --supports--> v2c
- v1e --refutes--> v05
- v1f --refutes--> v02
- v21 --refutes--> v14
- v25 --refutes--> v19
- v27 --supports--> v13
- v29 --refutes--> v09
- v2b --refutes--> v23
- v2f --supports--> v06

[VERIFIED ROOT]
v0d = TRUE

[TARGET]
v2e

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v16 --supports--> v04
- v04 --supports--> v2b
- v2b --supports--> v23
- v23 --supports--> v1b
- v1b --refutes--> v13
- v13 --refutes--> v07
- v07 --refutes--> v25
- v25 --refutes--> v1a
- v1a --refutes--> v02
- v02 --refutes--> v30
- v30 --supports--> v11
- v11 --supports--> v15
- v15 --refutes--> v0e
- v0e --supports--> v10
- v10 --supports--> v00
- v00 --refutes--> v2a
- v2a --refutes--> v17
- v17 --refutes--> v1c
- v1c --refutes--> v0b
- v0b --supports--> v2e
- v2e --refutes--> v08
- v08 --refutes--> v24
- v24 --supports--> v01
- v01 --refutes--> v18
- v18 --supports--> v19
- v19 --refutes--> v1e
- v1e --supports--> v2c
- v2c --supports--> v2f
- v2f --refutes--> v12
- v12 --supports--> v29
- v29 --refutes--> v0c
- v0c --supports--> v06

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --refutes--> v14
- v11 --refutes--> v0a
- v13 --refutes--> v28
- v13 --supports--> v09
- v15 --refutes--> v27
- v1b --refutes--> v20
- v1b --supports--> v2d
- v1e --refutes--> v03
- v1e --refutes--> v0d
- v1e --supports--> v05
- v25 --refutes--> v26
- v25 --supports--> v1f
- v29 --refutes--> v21
- v2a --refutes--> v22
- v2e --refutes--> v0f
- v2e --supports--> v1d

[VERIFIED ROOT]
v16 = FALSE

[TARGET]
v06

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v12 --supports--> v23
- v23 --supports--> v2a
- v2a --refutes--> v2d
- v2d --refutes--> v26
- v26 --refutes--> v04
- v04 --refutes--> v27
- v27 --supports--> v2f
- v2f --refutes--> v18
- v18 --refutes--> v19
- v19 --supports--> v0f
- v0f --refutes--> v16
- v16 --refutes--> v20
- v20 --supports--> v2b
- v2b --refutes--> v15
- v15 --supports--> v1b
- v1b --refutes--> v21
- v21 --refutes--> v08
- v08 --supports--> v03
- v03 --supports--> v01
- v01 --supports--> v0c
- v0c --refutes--> v14
- v14 --refutes--> v13
- v13 --supports--> v1c
- v1c --supports--> v11
- v11 --supports--> v1f
- v1f --refutes--> v00
- v00 --supports--> v09
- v09 --supports--> v05
- v05 --supports--> v0d
- v0d --supports--> v24
- v24 --refutes--> v1e
- v1e --refutes--> v2e

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --supports--> v07
- v04 --supports--> v06
- v09 --supports--> v0a
- v0c --supports--> v17
- v0d --refutes--> v1d
- v0d --supports--> v2c
- v0f --refutes--> v30
- v18 --supports--> v10
- v19 --supports--> v0e
- v1c --refutes--> v28
- v1e --supports--> v22
- v23 --refutes--> v0b
- v24 --refutes--> v29
- v27 --supports--> v02
- v2a --refutes--> v25
- v2a --supports--> v1a

[VERIFIED ROOT]
v12 = FALSE

[TARGET]
v2e

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v0c --supports--> v28
- v28 --supports--> v0f
- v0f --refutes--> v05
- v05 --supports--> v07
- v07 --refutes--> v14
- v14 --refutes--> v10
- v10 --supports--> v0b
- v0b --refutes--> v1c
- v1c --supports--> v03
- v03 --refutes--> v11
- v11 --supports--> v09
- v09 --refutes--> v22
- v22 --refutes--> v1e
- v1e --supports--> v2e
- v2e --refutes--> v02
- v02 --refutes--> v2c
- v2c --supports--> v30
- v30 --supports--> v1a
- v1a --refutes--> v1d
- v1d --supports--> v2f
- v2f --supports--> v21
- v21 --supports--> v16
- v16 --refutes--> v17
- v17 --refutes--> v13
- v13 --refutes--> v00
- v00 --refutes--> v26
- v26 --supports--> v06
- v06 --refutes--> v1b
- v1b --refutes--> v20
- v20 --refutes--> v18
- v18 --supports--> v25
- v25 --refutes--> v27

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v0a
- v03 --refutes--> v01
- v03 --refutes--> v2a
- v05 --refutes--> v23
- v07 --refutes--> v2d
- v09 --supports--> v24
- v10 --refutes--> v1f
- v13 --supports--> v0e
- v17 --refutes--> v04
- v1d --refutes--> v15
- v1d --supports--> v12
- v1d --supports--> v29
- v1e --refutes--> v08
- v2e --refutes--> v2b
- v2e --supports--> v0d
- v2e --supports--> v19

[VERIFIED ROOT]
v0c = TRUE

[TARGET]
v27

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v25 --refutes--> v07
- v07 --supports--> v0c
- v0c --supports--> v15
- v15 --refutes--> v2d
- v2d --refutes--> v26
- v26 --refutes--> v1a
- v1a --refutes--> v06
- v06 --refutes--> v28
- v28 --supports--> v02
- v02 --supports--> v0a
- v0a --refutes--> v12
- v12 --refutes--> v27
- v27 --refutes--> v20
- v20 --supports--> v03
- v03 --supports--> v04
- v04 --supports--> v21
- v21 --refutes--> v0b
- v0b --supports--> v17
- v17 --refutes--> v2e
- v2e --supports--> v18
- v18 --supports--> v2b
- v2b --supports--> v13
- v13 --refutes--> v01
- v01 --supports--> v16
- v16 --refutes--> v1c
- v1c --supports--> v24
- v24 --supports--> v1e
- v1e --refutes--> v30
- v30 --supports--> v09
- v09 --supports--> v05
- v05 --refutes--> v14
- v14 --supports--> v2a

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --supports--> v11
- v05 --refutes--> v08
- v05 --refutes--> v2f
- v09 --refutes--> v2c
- v0c --refutes--> v0f
- v0c --refutes--> v10
- v12 --refutes--> v1b
- v13 --refutes--> v0e
- v13 --supports--> v29
- v15 --refutes--> v23
- v18 --supports--> v19
- v27 --refutes--> v1f
- v2e --refutes--> v00
- v2e --refutes--> v22
- v2e --supports--> v0d
- v2e --supports--> v1d

[VERIFIED ROOT]
v25 = TRUE

[TARGET]
v2a

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v00 --supports--> v16
- v16 --refutes--> v22
- v22 --refutes--> v0e
- v0e --supports--> v1d
- v1d --supports--> v0a
- v0a --supports--> v2e
- v2e --supports--> v21
- v21 --supports--> v1c
- v1c --refutes--> v11
- v11 --refutes--> v1b
- v1b --supports--> v09
- v09 --supports--> v06
- v06 --refutes--> v03
- v03 --supports--> v2c
- v2c --refutes--> v0c
- v0c --supports--> v27
- v27 --refutes--> v28
- v28 --refutes--> v13
- v13 --refutes--> v2d
- v2d --refutes--> v02
- v02 --refutes--> v25
- v25 --supports--> v2f
- v2f --refutes--> v24
- v24 --supports--> v1f
- v1f --refutes--> v23
- v23 --refutes--> v12
- v12 --supports--> v01
- v01 --supports--> v18
- v18 --supports--> v05
- v05 --refutes--> v2b
- v2b --supports--> v17
- v17 --refutes--> v19

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --supports--> v15
- v02 --refutes--> v0d
- v02 --refutes--> v30
- v06 --supports--> v10
- v09 --supports--> v20
- v12 --supports--> v0b
- v17 --refutes--> v0f
- v1d --supports--> v08
- v21 --refutes--> v1a
- v22 --refutes--> v14
- v22 --refutes--> v26
- v24 --supports--> v29
- v27 --refutes--> v07
- v2d --supports--> v04
- v2e --refutes--> v1e
- v2e --refutes--> v2a

[VERIFIED ROOT]
v00 = TRUE

[TARGET]
v19

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v07 --refutes--> v23
- v23 --supports--> v2e
- v2e --supports--> v10
- v10 --supports--> v06
- v06 --supports--> v00
- v00 --refutes--> v30
- v30 --supports--> v0d
- v0d --supports--> v01
- v01 --refutes--> v12
- v12 --supports--> v0c
- v0c --supports--> v16
- v16 --supports--> v13
- v13 --supports--> v05
- v05 --supports--> v14
- v14 --refutes--> v1d
- v1d --refutes--> v03
- v03 --supports--> v02
- v02 --refutes--> v1c
- v1c --refutes--> v26
- v26 --refutes--> v27
- v27 --refutes--> v0a
- v0a --refutes--> v0e
- v0e --supports--> v2a
- v2a --refutes--> v25
- v25 --supports--> v19
- v19 --refutes--> v17
- v17 --supports--> v2d
- v2d --supports--> v2c
- v2c --refutes--> v04
- v04 --supports--> v1f
- v1f --refutes--> v20
- v20 --supports--> v0f

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --refutes--> v11
- v01 --supports--> v1a
- v02 --supports--> v21
- v03 --supports--> v1b
- v05 --refutes--> v29
- v06 --supports--> v09
- v0c --refutes--> v18
- v13 --refutes--> v2f
- v13 --supports--> v2b
- v1c --refutes--> v15
- v1c --supports--> v28
- v1d --supports--> v08
- v26 --refutes--> v22
- v2a --supports--> v24
- v2d --refutes--> v0b
- v30 --supports--> v1e

[VERIFIED ROOT]
v07 = FALSE

[TARGET]
v0f

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v0c --refutes--> v25
- v25 --refutes--> v29
- v29 --refutes--> v30
- v30 --refutes--> v07
- v07 --refutes--> v1c
- v1c --supports--> v1b
- v1b --supports--> v08
- v08 --refutes--> v1f
- v1f --refutes--> v2f
- v2f --supports--> v2d
- v2d --supports--> v06
- v06 --refutes--> v0d
- v0d --supports--> v1d
- v1d --supports--> v17
- v17 --refutes--> v20
- v20 --refutes--> v21
- v21 --refutes--> v04
- v04 --refutes--> v23
- v23 --supports--> v19
- v19 --refutes--> v27
- v27 --supports--> v18
- v18 --refutes--> v28
- v28 --supports--> v16
- v16 --supports--> v14
- v14 --supports--> v2a
- v2a --refutes--> v13
- v13 --refutes--> v0e
- v0e --supports--> v24
- v24 --refutes--> v02
- v02 --supports--> v0f
- v0f --supports--> v2c
- v2c --supports--> v1e

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v06 --refutes--> v11
- v06 --refutes--> v2e
- v08 --supports--> v15
- v0e --refutes--> v26
- v0e --refutes--> v2b
- v13 --refutes--> v10
- v19 --refutes--> v05
- v1d --refutes--> v01
- v21 --supports--> v1a
- v24 --supports--> v00
- v25 --refutes--> v03
- v27 --refutes--> v0a
- v29 --supports--> v22
- v2a --refutes--> v0b
- v2d --supports--> v09
- v2f --supports--> v12

[VERIFIED ROOT]
v0c = FALSE

[TARGET]
v1e

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v27 --refutes--> v1a
- v1a --supports--> v04
- v04 --refutes--> v00
- v00 --supports--> v07
- v07 --supports--> v23
- v23 --supports--> v2e
- v2e --supports--> v0f
- v0f --supports--> v2b
- v2b --supports--> v0b
- v0b --supports--> v26
- v26 --refutes--> v19
- v19 --refutes--> v1b
- v1b --refutes--> v12
- v12 --supports--> v2d
- v2d --supports--> v20
- v20 --supports--> v16
- v16 --refutes--> v0c
- v0c --supports--> v10
- v10 --supports--> v24
- v24 --supports--> v30
- v30 --refutes--> v2a
- v2a --supports--> v09
- v09 --supports--> v2c
- v2c --supports--> v28
- v28 --supports--> v14
- v14 --refutes--> v08
- v08 --refutes--> v29
- v29 --supports--> v13
- v13 --refutes--> v01
- v01 --supports--> v06
- v06 --supports--> v17
- v17 --refutes--> v11

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v07 --refutes--> v1c
- v08 --supports--> v0a
- v09 --refutes--> v0e
- v12 --supports--> v1f
- v16 --refutes--> v02
- v16 --refutes--> v15
- v17 --refutes--> v0d
- v17 --refutes--> v21
- v20 --refutes--> v18
- v26 --refutes--> v05
- v26 --supports--> v25
- v27 --refutes--> v22
- v28 --refutes--> v2f
- v29 --refutes--> v1d
- v2d --refutes--> v03
- v2e --supports--> v1e

[VERIFIED ROOT]
v27 = TRUE

[TARGET]
v11

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v0d --refutes--> v27
- v27 --supports--> v0a
- v0a --supports--> v12
- v12 --supports--> v24
- v24 --refutes--> v2e
- v2e --refutes--> v1c
- v1c --refutes--> v08
- v08 --supports--> v29
- v29 --supports--> v03
- v03 --supports--> v13
- v13 --refutes--> v26
- v26 --refutes--> v0f
- v0f --supports--> v10
- v10 --refutes--> v1a
- v1a --refutes--> v05
- v05 --supports--> v04
- v04 --refutes--> v1b
- v1b --refutes--> v1f
- v1f --supports--> v17
- v17 --supports--> v02
- v02 --supports--> v2f
- v2f --supports--> v25
- v25 --refutes--> v22
- v22 --supports--> v1d
- v1d --refutes--> v2a
- v2a --refutes--> v0c
- v0c --supports--> v15
- v15 --supports--> v14
- v14 --supports--> v01
- v01 --refutes--> v16
- v16 --supports--> v28
- v28 --refutes--> v2b

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v11
- v02 --refutes--> v2c
- v05 --supports--> v21
- v0c --supports--> v09
- v0f --supports--> v20
- v12 --supports--> v0e
- v1c --supports--> v00
- v1c --supports--> v19
- v1d --refutes--> v18
- v24 --supports--> v1e
- v28 --supports--> v2d
- v29 --refutes--> v06
- v29 --refutes--> v07
- v2a --refutes--> v30
- v2a --supports--> v23
- v2e --supports--> v0b

[VERIFIED ROOT]
v0d = FALSE

[TARGET]
v2b

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v14 --supports--> v12
- v12 --refutes--> v1e
- v1e --supports--> v2b
- v2b --supports--> v2a
- v2a --refutes--> v18
- v18 --refutes--> v25
- v25 --refutes--> v29
- v29 --refutes--> v30
- v30 --refutes--> v0b
- v0b --refutes--> v0a
- v0a --refutes--> v26
- v26 --supports--> v0d
- v0d --supports--> v1a
- v1a --refutes--> v13
- v13 --refutes--> v01
- v01 --refutes--> v00
- v00 --refutes--> v09
- v09 --supports--> v19
- v19 --refutes--> v16
- v16 --refutes--> v10
- v10 --refutes--> v1b
- v1b --refutes--> v28
- v28 --supports--> v23
- v23 --refutes--> v24
- v24 --supports--> v2d
- v2d --refutes--> v0e
- v0e --refutes--> v1c
- v1c --supports--> v02
- v02 --supports--> v1d
- v1d --refutes--> v07
- v07 --supports--> v27
- v27 --supports--> v03

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v0f
- v0a --refutes--> v0c
- v0e --supports--> v17
- v14 --refutes--> v11
- v18 --supports--> v21
- v18 --supports--> v22
- v1a --refutes--> v04
- v1b --supports--> v06
- v26 --refutes--> v08
- v26 --refutes--> v15
- v29 --refutes--> v1f
- v29 --supports--> v2f
- v2a --refutes--> v2e
- v2b --refutes--> v05
- v2b --refutes--> v2c
- v2d --refutes--> v20

[VERIFIED ROOT]
v14 = FALSE

[TARGET]
v03

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v20 --supports--> v1c
- v1c --refutes--> v05
- v05 --refutes--> v1e
- v1e --supports--> v1b
- v1b --refutes--> v25
- v25 --supports--> v12
- v12 --refutes--> v04
- v04 --refutes--> v2c
- v2c --supports--> v2a
- v2a --supports--> v21
- v21 --supports--> v0e
- v0e --refutes--> v01
- v01 --refutes--> v14
- v14 --supports--> v29
- v29 --supports--> v0b
- v0b --supports--> v0f
- v0f --supports--> v10
- v10 --supports--> v08
- v08 --refutes--> v11
- v11 --supports--> v2d
- v2d --refutes--> v09
- v09 --supports--> v2b
- v2b --supports--> v15
- v15 --refutes--> v1a
- v1a --refutes--> v0d
- v0d --supports--> v0a
- v0a --supports--> v16
- v16 --supports--> v06
- v06 --refutes--> v23
- v23 --supports--> v17
- v17 --refutes--> v19
- v19 --refutes--> v2e

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --supports--> v1d
- v04 --refutes--> v22
- v05 --supports--> v2f
- v06 --supports--> v0c
- v0e --supports--> v03
- v14 --refutes--> v24
- v16 --refutes--> v27
- v1b --refutes--> v1f
- v1c --refutes--> v18
- v1e --refutes--> v30
- v20 --supports--> v28
- v23 --supports--> v13
- v23 --supports--> v26
- v29 --supports--> v00
- v2d --refutes--> v02
- v2d --refutes--> v07

[VERIFIED ROOT]
v20 = TRUE

[TARGET]
v2e

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v09 --supports--> v30
- v30 --refutes--> v20
- v20 --supports--> v24
- v24 --supports--> v2f
- v2f --refutes--> v26
- v26 --refutes--> v1c
- v1c --supports--> v0d
- v0d --supports--> v22
- v22 --refutes--> v27
- v27 --refutes--> v08
- v08 --refutes--> v0e
- v0e --supports--> v2a
- v2a --refutes--> v04
- v04 --supports--> v0a
- v0a --refutes--> v13
- v13 --supports--> v11
- v11 --refutes--> v0b
- v0b --supports--> v14
- v14 --supports--> v03
- v03 --refutes--> v2b
- v2b --refutes--> v00
- v00 --supports--> v05
- v05 --refutes--> v2e
- v2e --refutes--> v2d
- v2d --refutes--> v19
- v19 --refutes--> v06
- v06 --refutes--> v1a
- v1a --supports--> v07
- v07 --supports--> v17
- v17 --supports--> v18
- v18 --refutes--> v21
- v21 --refutes--> v1b

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v04 --refutes--> v28
- v04 --supports--> v0c
- v08 --refutes--> v23
- v08 --supports--> v1e
- v0b --refutes--> v10
- v13 --refutes--> v29
- v17 --refutes--> v25
- v18 --supports--> v12
- v18 --supports--> v1d
- v18 --supports--> v2c
- v1a --supports--> v16
- v24 --refutes--> v15
- v2a --refutes--> v0f
- v2b --supports--> v01
- v2f --refutes--> v02
- v2f --refutes--> v1f

[VERIFIED ROOT]
v09 = FALSE

[TARGET]
v1b

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v08 --refutes--> v14
- v14 --supports--> v12
- v12 --supports--> v25
- v25 --supports--> v02
- v02 --supports--> v24
- v24 --supports--> v20
- v20 --refutes--> v0d
- v0d --refutes--> v1b
- v1b --refutes--> v17
- v17 --refutes--> v10
- v10 --refutes--> v09
- v09 --supports--> v0c
- v0c --supports--> v1e
- v1e --refutes--> v30
- v30 --supports--> v1c
- v1c --refutes--> v1a
- v1a --supports--> v2a
- v2a --supports--> v11
- v11 --refutes--> v18
- v18 --supports--> v2e
- v2e --supports--> v29
- v29 --refutes--> v0a
- v0a --supports--> v0b
- v0b --supports--> v03
- v03 --refutes--> v2c
- v2c --supports--> v21
- v21 --supports--> v00
- v00 --supports--> v2f
- v2f --refutes--> v2d
- v2d --refutes--> v1d
- v1d --supports--> v23
- v23 --supports--> v16

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --refutes--> v15
- v02 --refutes--> v0f
- v03 --supports--> v05
- v0b --supports--> v1f
- v0d --refutes--> v07
- v11 --refutes--> v26
- v1e --supports--> v04
- v20 --refutes--> v01
- v20 --supports--> v2b
- v21 --supports--> v28
- v25 --refutes--> v27
- v2d --supports--> v13
- v2e --refutes--> v19
- v2e --supports--> v0e
- v2f --refutes--> v22
- v30 --refutes--> v06

[VERIFIED ROOT]
v08 = FALSE

[TARGET]
v16

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v24 --supports--> v0f
- v0f --refutes--> v05
- v05 --supports--> v2a
- v2a --supports--> v1d
- v1d --supports--> v13
- v13 --supports--> v16
- v16 --supports--> v1e
- v1e --supports--> v27
- v27 --supports--> v09
- v09 --supports--> v1b
- v1b --supports--> v28
- v28 --refutes--> v19
- v19 --refutes--> v2d
- v2d --refutes--> v0b
- v0b --refutes--> v15
- v15 --refutes--> v0e
- v0e --refutes--> v21
- v21 --supports--> v1f
- v1f --refutes--> v14
- v14 --supports--> v04
- v04 --supports--> v02
- v02 --refutes--> v1a
- v1a --supports--> v25
- v25 --refutes--> v12
- v12 --refutes--> v0a
- v0a --refutes--> v11
- v11 --supports--> v07
- v07 --supports--> v03
- v03 --supports--> v26
- v26 --refutes--> v06
- v06 --supports--> v08
- v08 --refutes--> v18

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --refutes--> v2c
- v02 --supports--> v30
- v0b --refutes--> v2f
- v0e --supports--> v1c
- v13 --supports--> v22
- v16 --refutes--> v23
- v16 --refutes--> v2e
- v19 --supports--> v10
- v1d --supports--> v0c
- v1e --refutes--> v20
- v1e --supports--> v00
- v21 --refutes--> v17
- v24 --refutes--> v01
- v24 --refutes--> v0d
- v27 --refutes--> v29
- v2d --supports--> v2b

[VERIFIED ROOT]
v24 = FALSE

[TARGET]
v18

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v23 --supports--> v1d
- v1d --refutes--> v06
- v06 --refutes--> v20
- v20 --refutes--> v2a
- v2a --refutes--> v2e
- v2e --supports--> v1e
- v1e --supports--> v27
- v27 --refutes--> v0e
- v0e --supports--> v15
- v15 --supports--> v17
- v17 --refutes--> v04
- v04 --refutes--> v30
- v30 --supports--> v1a
- v1a --refutes--> v29
- v29 --refutes--> v22
- v22 --supports--> v14
- v14 --refutes--> v1c
- v1c --refutes--> v1f
- v1f --refutes--> v0a
- v0a --refutes--> v28
- v28 --supports--> v11
- v11 --refutes--> v2f
- v2f --supports--> v26
- v26 --refutes--> v18
- v18 --supports--> v10
- v10 --refutes--> v0f
- v0f --refutes--> v1b
- v1b --supports--> v09
- v09 --refutes--> v03
- v03 --refutes--> v21
- v21 --refutes--> v07
- v07 --refutes--> v16

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v03 --refutes--> v2d
- v09 --supports--> v05
- v0f --refutes--> v0c
- v11 --supports--> v00
- v11 --supports--> v08
- v15 --supports--> v2c
- v1a --supports--> v02
- v1c --refutes--> v13
- v1d --refutes--> v12
- v1d --supports--> v01
- v22 --supports--> v0d
- v23 --supports--> v19
- v2e --refutes--> v0b
- v2e --refutes--> v24
- v2e --supports--> v25
- v2f --supports--> v2b

[VERIFIED ROOT]
v23 = FALSE

[TARGET]
v16

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v1f --refutes--> v08
- v08 --supports--> v2f
- v2f --supports--> v28
- v28 --supports--> v30
- v30 --supports--> v1d
- v1d --refutes--> v0e
- v0e --refutes--> v18
- v18 --supports--> v0a
- v0a --refutes--> v1a
- v1a --refutes--> v06
- v06 --refutes--> v16
- v16 --supports--> v0d
- v0d --refutes--> v26
- v26 --refutes--> v1e
- v1e --supports--> v11
- v11 --refutes--> v23
- v23 --refutes--> v21
- v21 --refutes--> v17
- v17 --refutes--> v2d
- v2d --supports--> v12
- v12 --refutes--> v09
- v09 --refutes--> v0b
- v0b --supports--> v19
- v19 --supports--> v0c
- v0c --supports--> v2e
- v2e --supports--> v02
- v02 --refutes--> v20
- v20 --refutes--> v2a
- v2a --refutes--> v13
- v13 --refutes--> v14
- v14 --refutes--> v2c
- v2c --refutes--> v22

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --supports--> v05
- v0c --supports--> v1c
- v13 --refutes--> v07
- v17 --supports--> v2b
- v18 --refutes--> v15
- v19 --supports--> v03
- v1d --supports--> v25
- v1e --refutes--> v0f
- v1e --refutes--> v24
- v1e --supports--> v1b
- v20 --supports--> v00
- v21 --refutes--> v01
- v26 --refutes--> v04
- v26 --refutes--> v27
- v2c --refutes--> v29
- v30 --supports--> v10

[VERIFIED ROOT]
v1f = FALSE

[TARGET]
v22

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v17 --refutes--> v09
- v09 --refutes--> v11
- v11 --refutes--> v04
- v04 --refutes--> v0b
- v0b --supports--> v23
- v23 --supports--> v2f
- v2f --supports--> v07
- v07 --refutes--> v0d
- v0d --refutes--> v20
- v20 --supports--> v05
- v05 --refutes--> v16
- v16 --supports--> v10
- v10 --refutes--> v13
- v13 --supports--> v14
- v14 --supports--> v22
- v22 --supports--> v1a
- v1a --refutes--> v0e
- v0e --refutes--> v01
- v01 --supports--> v08
- v08 --supports--> v28
- v28 --supports--> v1b
- v1b --refutes--> v18
- v18 --refutes--> v03
- v03 --refutes--> v1f
- v1f --supports--> v06
- v06 --refutes--> v02
- v02 --supports--> v2d
- v2d --supports--> v29
- v29 --refutes--> v30
- v30 --refutes--> v26
- v26 --supports--> v25
- v25 --supports--> v12

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --supports--> v27
- v06 --refutes--> v0a
- v07 --refutes--> v0c
- v10 --supports--> v2e
- v13 --supports--> v15
- v14 --refutes--> v1e
- v16 --supports--> v0f
- v17 --refutes--> v2a
- v1a --refutes--> v19
- v23 --refutes--> v1d
- v23 --supports--> v21
- v25 --refutes--> v2b
- v28 --supports--> v00
- v29 --refutes--> v24
- v30 --refutes--> v1c
- v30 --refutes--> v2c

[VERIFIED ROOT]
v17 = TRUE

[TARGET]
v12

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v05 --supports--> v2d
- v2d --refutes--> v09
- v09 --refutes--> v1b
- v1b --refutes--> v2c
- v2c --refutes--> v00
- v00 --supports--> v12
- v12 --supports--> v18
- v18 --refutes--> v01
- v01 --supports--> v0c
- v0c --refutes--> v19
- v19 --supports--> v1e
- v1e --refutes--> v1f
- v1f --refutes--> v0a
- v0a --refutes--> v21
- v21 --refutes--> v1c
- v1c --refutes--> v2f
- v2f --supports--> v07
- v07 --refutes--> v26
- v26 --supports--> v1a
- v1a --refutes--> v08
- v08 --supports--> v24
- v24 --supports--> v1d
- v1d --supports--> v02
- v02 --refutes--> v14
- v14 --refutes--> v0e
- v0e --supports--> v06
- v06 --refutes--> v2e
- v2e --refutes--> v04
- v04 --refutes--> v13
- v13 --refutes--> v0b
- v0b --refutes--> v29
- v29 --supports--> v20

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --supports--> v0f
- v02 --supports--> v23
- v02 --supports--> v2b
- v05 --refutes--> v0d
- v06 --supports--> v2a
- v07 --refutes--> v15
- v07 --supports--> v10
- v08 --supports--> v16
- v0e --supports--> v22
- v0e --supports--> v28
- v1d --refutes--> v30
- v1d --supports--> v03
- v24 --refutes--> v11
- v24 --supports--> v17
- v29 --supports--> v27
- v2f --refutes--> v25

[VERIFIED ROOT]
v05 = FALSE

[TARGET]
v20

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v23 --supports--> v0a
- v0a --refutes--> v28
- v28 --refutes--> v1f
- v1f --refutes--> v0d
- v0d --refutes--> v0e
- v0e --supports--> v14
- v14 --supports--> v1d
- v1d --supports--> v2c
- v2c --refutes--> v07
- v07 --supports--> v0c
- v0c --refutes--> v06
- v06 --refutes--> v15
- v15 --supports--> v26
- v26 --refutes--> v2e
- v2e --refutes--> v13
- v13 --refutes--> v25
- v25 --supports--> v03
- v03 --supports--> v20
- v20 --refutes--> v19
- v19 --supports--> v05
- v05 --supports--> v18
- v18 --supports--> v21
- v21 --supports--> v1b
- v1b --refutes--> v27
- v27 --refutes--> v30
- v30 --supports--> v1e
- v1e --supports--> v17
- v17 --refutes--> v0b
- v0b --refutes--> v2b
- v2b --refutes--> v08
- v08 --refutes--> v02
- v02 --refutes--> v09

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v05 --refutes--> v29
- v06 --supports--> v24
- v0a --refutes--> v11
- v0b --refutes--> v01
- v0c --supports--> v12
- v0e --supports--> v1c
- v0e --supports--> v2d
- v17 --supports--> v1a
- v17 --supports--> v22
- v20 --supports--> v00
- v21 --refutes--> v2a
- v23 --refutes--> v16
- v23 --supports--> v10
- v25 --supports--> v2f
- v2c --refutes--> v04
- v2c --supports--> v0f

[VERIFIED ROOT]
v23 = TRUE

[TARGET]
v09

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v2f --supports--> v1b
- v1b --supports--> v23
- v23 --refutes--> v09
- v09 --refutes--> v01
- v01 --supports--> v0d
- v0d --refutes--> v1c
- v1c --supports--> v18
- v18 --supports--> v04
- v04 --refutes--> v1a
- v1a --supports--> v1f
- v1f --refutes--> v2d
- v2d --refutes--> v22
- v22 --refutes--> v12
- v12 --supports--> v17
- v17 --refutes--> v19
- v19 --refutes--> v2a
- v2a --refutes--> v25
- v25 --supports--> v0e
- v0e --supports--> v30
- v30 --supports--> v2e
- v2e --supports--> v00
- v00 --refutes--> v06
- v06 --refutes--> v1e
- v1e --supports--> v16
- v16 --supports--> v2b
- v2b --supports--> v03
- v03 --supports--> v15
- v15 --refutes--> v28
- v28 --refutes--> v1d
- v1d --refutes--> v07
- v07 --refutes--> v02
- v02 --supports--> v21

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --refutes--> v20
- v02 --refutes--> v05
- v02 --supports--> v24
- v04 --supports--> v27
- v06 --refutes--> v0b
- v0d --supports--> v13
- v15 --refutes--> v0f
- v15 --supports--> v2c
- v17 --refutes--> v26
- v18 --refutes--> v08
- v1d --supports--> v14
- v1e --refutes--> v0a
- v22 --refutes--> v29
- v25 --refutes--> v11
- v2b --refutes--> v0c
- v2d --supports--> v10

[VERIFIED ROOT]
v2f = FALSE

[TARGET]
v21

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v18 --refutes--> v20
- v20 --refutes--> v11
- v11 --supports--> v1b
- v1b --supports--> v2a
- v2a --supports--> v0d
- v0d --refutes--> v25
- v25 --supports--> v08
- v08 --supports--> v06
- v06 --supports--> v2f
- v2f --refutes--> v03
- v03 --supports--> v1f
- v1f --refutes--> v14
- v14 --supports--> v29
- v29 --supports--> v2e
- v2e --refutes--> v1e
- v1e --refutes--> v16
- v16 --supports--> v07
- v07 --supports--> v1c
- v1c --supports--> v0a
- v0a --refutes--> v0c
- v0c --refutes--> v01
- v01 --refutes--> v21
- v21 --refutes--> v1a
- v1a --supports--> v2c
- v2c --refutes--> v12
- v12 --refutes--> v10
- v10 --supports--> v28
- v28 --refutes--> v05
- v05 --supports--> v26
- v26 --supports--> v0b
- v0b --supports--> v13
- v13 --refutes--> v2b

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v0a --refutes--> v24
- v10 --supports--> v04
- v10 --supports--> v27
- v11 --supports--> v22
- v16 --refutes--> v15
- v16 --supports--> v19
- v1a --refutes--> v09
- v1c --supports--> v17
- v1e --refutes--> v0f
- v1e --refutes--> v23
- v21 --supports--> v0e
- v25 --refutes--> v00
- v28 --supports--> v30
- v2a --refutes--> v02
- v2a --refutes--> v1d
- v2f --supports--> v2d

[VERIFIED ROOT]
v18 = FALSE

[TARGET]
v2b

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v12 --supports--> v2c
- v2c --refutes--> v23
- v23 --refutes--> v17
- v17 --refutes--> v1f
- v1f --supports--> v20
- v20 --supports--> v27
- v27 --supports--> v19
- v19 --refutes--> v02
- v02 --supports--> v28
- v28 --refutes--> v0d
- v0d --supports--> v2b
- v2b --refutes--> v03
- v03 --supports--> v15
- v15 --refutes--> v1d
- v1d --refutes--> v30
- v30 --supports--> v16
- v16 --supports--> v29
- v29 --supports--> v1b
- v1b --refutes--> v0f
- v0f --supports--> v2f
- v2f --supports--> v13
- v13 --refutes--> v05
- v05 --supports--> v11
- v11 --supports--> v25
- v25 --refutes--> v14
- v14 --supports--> v10
- v10 --refutes--> v18
- v18 --refutes--> v04
- v04 --refutes--> v00
- v00 --refutes--> v07
- v07 --supports--> v1a
- v1a --supports--> v01

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --supports--> v2d
- v04 --refutes--> v0a
- v07 --refutes--> v2a
- v10 --supports--> v06
- v11 --refutes--> v1e
- v14 --supports--> v0e
- v16 --supports--> v0c
- v18 --refutes--> v2e
- v19 --refutes--> v08
- v19 --refutes--> v1c
- v20 --supports--> v22
- v23 --supports--> v0b
- v2b --supports--> v24
- v2c --supports--> v09
- v30 --refutes--> v26
- v30 --supports--> v21

[VERIFIED ROOT]
v12 = TRUE

[TARGET]
v01

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v2c --refutes--> v2b
- v2b --refutes--> v05
- v05 --supports--> v10
- v10 --refutes--> v2f
- v2f --supports--> v04
- v04 --supports--> v0b
- v0b --refutes--> v0d
- v0d --refutes--> v30
- v30 --supports--> v1d
- v1d --supports--> v20
- v20 --supports--> v0f
- v0f --refutes--> v0c
- v0c --supports--> v17
- v17 --refutes--> v24
- v24 --refutes--> v23
- v23 --supports--> v00
- v00 --refutes--> v15
- v15 --supports--> v01
- v01 --refutes--> v27
- v27 --refutes--> v1b
- v1b --supports--> v11
- v11 --supports--> v1a
- v1a --refutes--> v12
- v12 --supports--> v1c
- v1c --refutes--> v21
- v21 --refutes--> v28
- v28 --supports--> v13
- v13 --supports--> v29
- v29 --refutes--> v02
- v02 --refutes--> v14
- v14 --supports--> v22
- v22 --refutes--> v08

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --refutes--> v2d
- v01 --refutes--> v16
- v01 --refutes--> v18
- v05 --refutes--> v1f
- v0b --refutes--> v07
- v0b --refutes--> v25
- v0d --refutes--> v09
- v0f --supports--> v1e
- v13 --supports--> v03
- v15 --refutes--> v0e
- v17 --supports--> v06
- v1b --refutes--> v0a
- v1b --supports--> v2a
- v1c --refutes--> v26
- v30 --refutes--> v19
- v30 --supports--> v2e

[VERIFIED ROOT]
v2c = FALSE

[TARGET]
v08

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v09 --refutes--> v2e
- v2e --refutes--> v02
- v02 --refutes--> v27
- v27 --supports--> v30
- v30 --refutes--> v2d
- v2d --refutes--> v1c
- v1c --supports--> v26
- v26 --refutes--> v0e
- v0e --refutes--> v0f
- v0f --supports--> v06
- v06 --supports--> v17
- v17 --supports--> v03
- v03 --supports--> v21
- v21 --refutes--> v24
- v24 --refutes--> v22
- v22 --refutes--> v28
- v28 --refutes--> v11
- v11 --refutes--> v2c
- v2c --supports--> v2b
- v2b --refutes--> v18
- v18 --supports--> v0b
- v0b --refutes--> v29
- v29 --supports--> v1f
- v1f --supports--> v12
- v12 --refutes--> v14
- v14 --refutes--> v04
- v04 --supports--> v0a
- v0a --refutes--> v19
- v19 --supports--> v00
- v00 --supports--> v1d
- v1d --supports--> v13
- v13 --supports--> v16

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v03 --refutes--> v0d
- v04 --supports--> v25
- v09 --refutes--> v10
- v0a --refutes--> v08
- v0b --supports--> v23
- v0e --supports--> v15
- v17 --refutes--> v01
- v19 --refutes--> v20
- v1c --supports--> v05
- v21 --refutes--> v07
- v22 --refutes--> v1a
- v24 --refutes--> v1b
- v24 --refutes--> v2a
- v26 --supports--> v1e
- v2b --refutes--> v0c
- v2d --supports--> v2f

[VERIFIED ROOT]
v09 = TRUE

[TARGET]
v16

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v1e --supports--> v2f
- v2f --supports--> v11
- v11 --supports--> v2e
- v2e --refutes--> v17
- v17 --refutes--> v27
- v27 --refutes--> v2a
- v2a --supports--> v22
- v22 --refutes--> v02
- v02 --supports--> v26
- v26 --refutes--> v04
- v04 --refutes--> v1f
- v1f --supports--> v24
- v24 --refutes--> v15
- v15 --refutes--> v28
- v28 --refutes--> v16
- v16 --refutes--> v21
- v21 --supports--> v08
- v08 --supports--> v0b
- v0b --refutes--> v05
- v05 --refutes--> v29
- v29 --refutes--> v20
- v20 --supports--> v12
- v12 --supports--> v2c
- v2c --supports--> v06
- v06 --supports--> v2d
- v2d --refutes--> v14
- v14 --supports--> v09
- v09 --supports--> v00
- v00 --supports--> v03
- v03 --supports--> v10
- v10 --supports--> v0f
- v0f --supports--> v0d

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v06 --refutes--> v0e
- v09 --supports--> v25
- v0b --supports--> v0a
- v0f --refutes--> v23
- v11 --refutes--> v1b
- v12 --refutes--> v19
- v12 --supports--> v1d
- v16 --refutes--> v18
- v16 --supports--> v01
- v16 --supports--> v07
- v20 --refutes--> v13
- v20 --supports--> v1a
- v26 --refutes--> v2b
- v26 --supports--> v0c
- v28 --refutes--> v30
- v2c --refutes--> v1c

[VERIFIED ROOT]
v1e = TRUE

[TARGET]
v0d

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v09 --refutes--> v0a
- v0a --supports--> v24
- v24 --refutes--> v05
- v05 --supports--> v10
- v10 --supports--> v20
- v20 --supports--> v18
- v18 --supports--> v2a
- v2a --supports--> v01
- v01 --supports--> v28
- v28 --supports--> v0f
- v0f --refutes--> v2d
- v2d --refutes--> v23
- v23 --supports--> v29
- v29 --refutes--> v1c
- v1c --supports--> v0d
- v0d --supports--> v22
- v22 --supports--> v17
- v17 --supports--> v0c
- v0c --refutes--> v12
- v12 --supports--> v19
- v19 --refutes--> v2e
- v2e --supports--> v27
- v27 --supports--> v00
- v00 --refutes--> v30
- v30 --refutes--> v14
- v14 --refutes--> v1a
- v1a --refutes--> v07
- v07 --refutes--> v2b
- v2b --refutes--> v08
- v08 --supports--> v16
- v16 --supports--> v26
- v26 --supports--> v0e

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --refutes--> v04
- v00 --refutes--> v25
- v01 --supports--> v21
- v07 --supports--> v02
- v09 --supports--> v2f
- v0f --supports--> v2c
- v10 --refutes--> v13
- v17 --supports--> v0b
- v18 --refutes--> v03
- v18 --refutes--> v06
- v18 --refutes--> v1f
- v18 --supports--> v1b
- v22 --supports--> v15
- v26 --supports--> v1e
- v28 --refutes--> v11
- v2b --supports--> v1d

[VERIFIED ROOT]
v09 = TRUE

[TARGET]
v0e

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v06 --refutes--> v12
- v12 --refutes--> v24
- v24 --refutes--> v26
- v26 --supports--> v25
- v25 --supports--> v09
- v09 --supports--> v0f
- v0f --refutes--> v02
- v02 --refutes--> v16
- v16 --refutes--> v13
- v13 --supports--> v15
- v15 --supports--> v28
- v28 --refutes--> v2f
- v2f --supports--> v17
- v17 --refutes--> v0c
- v0c --supports--> v08
- v08 --refutes--> v23
- v23 --refutes--> v03
- v03 --supports--> v05
- v05 --refutes--> v11
- v11 --refutes--> v1d
- v1d --refutes--> v0d
- v0d --supports--> v19
- v19 --supports--> v30
- v30 --refutes--> v27
- v27 --refutes--> v1f
- v1f --refutes--> v29
- v29 --refutes--> v22
- v22 --refutes--> v2b
- v2b --supports--> v0a
- v0a --supports--> v1b
- v1b --refutes--> v1a
- v1a --supports--> v2a

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v03 --supports--> v10
- v05 --supports--> v0e
- v0d --supports--> v20
- v0f --supports--> v21
- v0f --supports--> v2d
- v13 --refutes--> v01
- v16 --supports--> v1c
- v19 --refutes--> v1e
- v1a --supports--> v07
- v1b --refutes--> v14
- v1f --supports--> v2c
- v26 --supports--> v04
- v28 --supports--> v0b
- v29 --refutes--> v2e
- v2f --refutes--> v00
- v2f --refutes--> v18

[VERIFIED ROOT]
v06 = FALSE

[TARGET]
v2a

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v06 --refutes--> v2a
- v2a --supports--> v0f
- v0f --supports--> v12
- v12 --supports--> v0a
- v0a --refutes--> v2d
- v2d --supports--> v17
- v17 --supports--> v03
- v03 --refutes--> v13
- v13 --supports--> v2e
- v2e --supports--> v23
- v23 --supports--> v0e
- v0e --supports--> v15
- v15 --refutes--> v10
- v10 --refutes--> v04
- v04 --refutes--> v2b
- v2b --refutes--> v2f
- v2f --refutes--> v2c
- v2c --refutes--> v24
- v24 --refutes--> v0c
- v0c --refutes--> v05
- v05 --supports--> v01
- v01 --refutes--> v16
- v16 --supports--> v27
- v27 --supports--> v11
- v11 --refutes--> v1e
- v1e --supports--> v21
- v21 --supports--> v00
- v00 --supports--> v07
- v07 --supports--> v18
- v18 --refutes--> v19
- v19 --refutes--> v20
- v20 --supports--> v26

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v0a --supports--> v30
- v10 --supports--> v1c
- v12 --refutes--> v22
- v15 --refutes--> v1d
- v15 --supports--> v09
- v17 --supports--> v1f
- v18 --refutes--> v1a
- v18 --supports--> v02
- v20 --refutes--> v28
- v20 --supports--> v14
- v21 --refutes--> v0d
- v21 --refutes--> v1b
- v27 --supports--> v0b
- v2a --supports--> v25
- v2c --refutes--> v29
- v2f --refutes--> v08

[VERIFIED ROOT]
v06 = TRUE

[TARGET]
v26

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v19 --refutes--> v07
- v07 --refutes--> v16
- v16 --supports--> v27
- v27 --supports--> v17
- v17 --refutes--> v0a
- v0a --refutes--> v0b
- v0b --refutes--> v0d
- v0d --refutes--> v1b
- v1b --refutes--> v00
- v00 --refutes--> v2c
- v2c --refutes--> v18
- v18 --supports--> v2f
- v2f --supports--> v02
- v02 --supports--> v2a
- v2a --supports--> v1f
- v1f --supports--> v20
- v20 --supports--> v1c
- v1c --refutes--> v2e
- v2e --refutes--> v2d
- v2d --refutes--> v03
- v03 --refutes--> v04
- v04 --refutes--> v26
- v26 --supports--> v25
- v25 --supports--> v14
- v14 --supports--> v05
- v05 --supports--> v01
- v01 --supports--> v0f
- v0f --refutes--> v23
- v23 --supports--> v1a
- v1a --supports--> v09
- v09 --refutes--> v08
- v08 --supports--> v1e

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --refutes--> v11
- v02 --refutes--> v29
- v03 --refutes--> v12
- v05 --supports--> v06
- v08 --refutes--> v0e
- v0a --supports--> v28
- v0b --supports--> v1d
- v0f --supports--> v2b
- v14 --refutes--> v22
- v17 --refutes--> v10
- v1a --supports--> v13
- v20 --refutes--> v24
- v23 --supports--> v15
- v25 --supports--> v30
- v26 --supports--> v21
- v2f --refutes--> v0c

[VERIFIED ROOT]
v19 = TRUE

[TARGET]
v1e

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v20 --refutes--> v01
- v01 --refutes--> v06
- v06 --refutes--> v0c
- v0c --refutes--> v2e
- v2e --supports--> v21
- v21 --supports--> v2a
- v2a --supports--> v13
- v13 --supports--> v2d
- v2d --refutes--> v26
- v26 --refutes--> v05
- v05 --supports--> v10
- v10 --refutes--> v1e
- v1e --refutes--> v28
- v28 --supports--> v2f
- v2f --refutes--> v18
- v18 --supports--> v0a
- v0a --supports--> v15
- v15 --supports--> v1d
- v1d --refutes--> v1c
- v1c --supports--> v11
- v11 --supports--> v09
- v09 --refutes--> v0e
- v0e --supports--> v00
- v00 --supports--> v27
- v27 --refutes--> v02
- v02 --supports--> v07
- v07 --supports--> v30
- v30 --refutes--> v0b
- v0b --refutes--> v17
- v17 --supports--> v0f
- v0f --refutes--> v2b
- v2b --supports--> v2c

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --supports--> v0d
- v05 --refutes--> v03
- v05 --supports--> v23
- v06 --refutes--> v08
- v0a --refutes--> v29
- v1c --refutes--> v25
- v1e --supports--> v22
- v20 --refutes--> v1b
- v26 --supports--> v16
- v28 --refutes--> v14
- v28 --refutes--> v1a
- v2b --refutes--> v1f
- v2b --refutes--> v24
- v2d --refutes--> v12
- v2e --supports--> v19
- v30 --refutes--> v04

[VERIFIED ROOT]
v20 = TRUE

[TARGET]
v2c

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v0e --refutes--> v1a
- v1a --supports--> v13
- v13 --refutes--> v2b
- v2b --refutes--> v1d
- v1d --refutes--> v2d
- v2d --refutes--> v07
- v07 --supports--> v23
- v23 --supports--> v00
- v00 --refutes--> v24
- v24 --refutes--> v1b
- v1b --refutes--> v01
- v01 --refutes--> v20
- v20 --refutes--> v2e
- v2e --supports--> v12
- v12 --supports--> v2f
- v2f --supports--> v25
- v25 --supports--> v11
- v11 --refutes--> v28
- v28 --refutes--> v2a
- v2a --refutes--> v2c
- v2c --refutes--> v15
- v15 --refutes--> v10
- v10 --refutes--> v1e
- v1e --supports--> v08
- v08 --supports--> v14
- v14 --supports--> v02
- v02 --refutes--> v27
- v27 --supports--> v22
- v22 --refutes--> v05
- v05 --supports--> v03
- v03 --supports--> v06
- v06 --supports--> v09

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v02 --supports--> v18
- v03 --refutes--> v04
- v03 --refutes--> v26
- v03 --supports--> v21
- v07 --supports--> v1f
- v10 --refutes--> v29
- v11 --supports--> v16
- v15 --supports--> v0b
- v1b --supports--> v17
- v1e --supports--> v0a
- v23 --refutes--> v0f
- v25 --refutes--> v30
- v27 --refutes--> v0d
- v27 --supports--> v1c
- v28 --supports--> v19
- v2c --supports--> v0c

[VERIFIED ROOT]
v0e = TRUE

[TARGET]
v09

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v0a --supports--> v14
- v14 --refutes--> v17
- v17 --supports--> v26
- v26 --refutes--> v03
- v03 --supports--> v07
- v07 --refutes--> v11
- v11 --supports--> v06
- v06 --supports--> v21
- v21 --supports--> v25
- v25 --supports--> v16
- v16 --supports--> v2b
- v2b --refutes--> v19
- v19 --supports--> v18
- v18 --supports--> v1f
- v1f --refutes--> v01
- v01 --refutes--> v0c
- v0c --refutes--> v00
- v00 --refutes--> v05
- v05 --supports--> v1b
- v1b --supports--> v2f
- v2f --supports--> v0b
- v0b --refutes--> v1a
- v1a --refutes--> v2a
- v2a --refutes--> v30
- v30 --refutes--> v2e
- v2e --supports--> v0e
- v0e --supports--> v0d
- v0d --supports--> v15
- v15 --refutes--> v10
- v10 --refutes--> v0f
- v0f --supports--> v1c
- v1c --supports--> v27

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v01 --supports--> v2c
- v0d --supports--> v09
- v0e --supports--> v2d
- v0f --supports--> v1d
- v10 --supports--> v22
- v11 --supports--> v04
- v15 --refutes--> v13
- v16 --supports--> v23
- v18 --refutes--> v08
- v18 --supports--> v1e
- v19 --supports--> v29
- v1f --refutes--> v02
- v25 --refutes--> v28
- v26 --refutes--> v20
- v2a --refutes--> v24
- v2b --supports--> v12

[VERIFIED ROOT]
v0a = FALSE

[TARGET]
v27

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v29 --supports--> v14
- v14 --refutes--> v0a
- v0a --refutes--> v09
- v09 --refutes--> v21
- v21 --supports--> v2b
- v2b --supports--> v0e
- v0e --supports--> v01
- v01 --supports--> v03
- v03 --refutes--> v00
- v00 --refutes--> v0f
- v0f --supports--> v06
- v06 --refutes--> v04
- v04 --supports--> v2c
- v2c --refutes--> v30
- v30 --supports--> v0d
- v0d --refutes--> v05
- v05 --refutes--> v11
- v11 --refutes--> v27
- v27 --supports--> v07
- v07 --refutes--> v17
- v17 --supports--> v1f
- v1f --supports--> v20
- v20 --refutes--> v28
- v28 --refutes--> v15
- v15 --supports--> v2a
- v2a --refutes--> v0b
- v0b --refutes--> v1a
- v1a --refutes--> v25
- v25 --supports--> v08
- v08 --refutes--> v1c
- v1c --refutes--> v13
- v13 --refutes--> v18

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v03 --refutes--> v26
- v09 --supports--> v1b
- v0d --supports--> v12
- v11 --supports--> v2e
- v14 --refutes--> v19
- v14 --refutes--> v2f
- v15 --supports--> v1d
- v17 --supports--> v2d
- v1a --supports--> v1e
- v21 --refutes--> v24
- v21 --supports--> v23
- v25 --supports--> v16
- v2b --refutes--> v02
- v2b --refutes--> v0c
- v2b --refutes--> v10
- v30 --supports--> v22

[VERIFIED ROOT]
v29 = FALSE

[TARGET]
v18

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.


You are LiveGraph. Follow directed graph edges. The relation 'supports' preserves a Boolean truth value and 'refutes' negates it. Output exactly one token: TRUE or FALSE.

[VERIFIED PATH EDGES; ROOT-TO-TARGET ORDER]
- v1e --refutes--> v29
- v29 --supports--> v11
- v11 --refutes--> v19
- v19 --refutes--> v18
- v18 --supports--> v25
- v25 --refutes--> v1d
- v1d --refutes--> v07
- v07 --supports--> v16
- v16 --supports--> v28
- v28 --supports--> v09
- v09 --supports--> v20
- v20 --refutes--> v1b
- v1b --refutes--> v10
- v10 --supports--> v26
- v26 --supports--> v24
- v24 --supports--> v2e
- v2e --supports--> v0b
- v0b --refutes--> v00
- v00 --refutes--> v0c
- v0c --refutes--> v1c
- v1c --refutes--> v2f
- v2f --refutes--> v0f
- v0f --refutes--> v13
- v13 --supports--> v05
- v05 --refutes--> v12
- v12 --refutes--> v08
- v08 --refutes--> v0e
- v0e --supports--> v2d
- v2d --refutes--> v1f
- v1f --refutes--> v06
- v06 --refutes--> v30
- v30 --refutes--> v1a

[OTHER GRAPH EDGES; NOT ON THE TARGET PATH]
- v00 --refutes--> v0a
- v05 --supports--> v15
- v06 --refutes--> v2c
- v09 --refutes--> v2b
- v0c --supports--> v22
- v0c --supports--> v2a
- v0e --refutes--> v01
- v0e --refutes--> v17
- v1b --refutes--> v03
- v1d --supports--> v0d
- v1f --refutes--> v27
- v1f --supports--> v21
- v25 --supports--> v02
- v26 --refutes--> v23
- v28 --refutes--> v04
- v28 --supports--> v14

[VERIFIED ROOT]
v1e = FALSE

[TARGET]
v1a

[QUERY]
Propagate truth from the verified root to the target. Output exactly TRUE or FALSE.