(116.72, 638.24) (123.26, 638.24) (123.26, 644.23) (116.72, 644.23)        /F1 15	<|special_separator|>
(150.01, 638.24) (159.83, 638.24) (159.83, 644.23) (150.01, 644.23)        /F1 300	<|special_separator|>
(183.31, 638.24) (196.39, 638.24) (196.39, 644.23) (183.31, 644.23)        /F1 6000	<|special_separator|>
(123.60, 629.76) (185.15, 629.76) (185.15, 638.58) (123.60, 638.58)        /F1 Solution Length	<|special_separator|>
(105.76, 644.98) (113.94, 644.98) (113.94, 650.97) (105.76, 650.97)        /F1 0.0	<|special_separator|>
(105.76, 673.86) (113.94, 673.86) (113.94, 679.85) (105.76, 679.85)        /F1 0.5	<|special_separator|>
(105.76, 702.73) (113.94, 702.73) (113.94, 708.73) (105.76, 708.73)        /F1 1.0	<|special_separator|>
(104.89, 651.44) (104.89, 702.60) (096.06, 702.60) (096.06, 651.44)        /F1 Success Rate	<|special_separator|>
(142.75, 710.19) (166.00, 710.19) (166.00, 719.33) (142.75, 719.33)        /F1 Rubik	<|special_separator|>
(199.63, 638.36) (206.16, 638.36) (206.16, 644.33) (199.63, 644.33)        /F1 10	<|special_separator|>
(232.81, 638.36) (242.60, 638.36) (242.60, 644.33) (232.81, 644.33)        /F1 200	<|special_separator|>
(265.98, 638.36) (279.04, 638.36) (279.04, 644.33) (265.98, 644.33)        /F1 4000	<|special_separator|>
(206.44, 629.88) (267.88, 629.88) (267.88, 638.70) (206.44, 638.70)        /F1 Solution Length	<|special_separator|>
(216.13, 710.07) (258.18, 710.07) (258.18, 719.20) (216.13, 719.20)        /F1 Lights Out	<|special_separator|>
(281.48, 638.41) (287.99, 638.41) (287.99, 644.38) (281.48, 644.38)        /F1 10	<|special_separator|>
(316.35, 638.41) (322.86, 638.41) (322.86, 644.38) (316.35, 644.38)        /F1 30	<|special_separator|>
(351.23, 638.41) (357.74, 638.41) (357.74, 644.38) (351.23, 644.38)        /F1 90	<|special_separator|>
(288.83, 629.97) (350.08, 629.97) (350.08, 638.75) (288.83, 638.75)        /F1 Solution Length	<|special_separator|>
(302.36, 710.01) (336.53, 710.01) (336.53, 719.11) (302.36, 719.11)        /F1 Sokoban	<|special_separator|>
(365.60, 638.40) (368.87, 638.40) (368.87, 644.38) (365.60, 644.38)        /F1 9	<|special_separator|>
(396.94, 638.40) (403.48, 638.40) (403.48, 644.38) (396.94, 644.38)        /F1 27	<|special_separator|>
(429.92, 638.40) (436.45, 638.40) (436.45, 644.38) (429.92, 644.38)        /F1 81	<|special_separator|>
(369.33, 629.93) (430.79, 629.93) (430.79, 638.74) (369.33, 638.74)        /F1 Solution Length	<|special_separator|>
(374.58, 710.14) (425.55, 710.14) (425.55, 719.27) (374.58, 719.27)        /F1 Digit Jumper	<|special_separator|>
(442.70, 638.20) (449.25, 638.20) (449.25, 644.20) (442.70, 644.20)        /F1 40	<|special_separator|>
(474.19, 638.20) (484.01, 638.20) (484.01, 644.20) (474.19, 644.20)        /F1 120	<|special_separator|>
(507.32, 638.20) (517.14, 638.20) (517.14, 644.20) (507.32, 644.20)        /F1 360	<|special_separator|>
(448.14, 629.71) (509.77, 629.71) (509.77, 638.54) (448.14, 638.54)        /F1 Solution Length	<|special_separator|>
(459.73, 710.23) (498.18, 710.23) (498.18, 719.38) (459.73, 719.38)        /F1 15-Puzzle	<|special_separator|>
(215.87, 612.72) (304.33, 612.72) (304.33, 622.10) (215.87, 622.10)        /F1 CRTR without Search	<|special_separator|>
(342.98, 612.72) (418.69, 612.72) (418.69, 622.10) (342.98, 622.10)        /F1 CRTR with BestFS	<|special_separator|>
(108.00, 591.62) (145.50, 591.62) (145.50, 600.17) (108.00, 600.17)      /F116 Figure 4:	<|special_separator|>
(149.73, 591.81) (364.62, 591.81) (364.62, 599.87) (149.73, 599.87)      /F107 CRTR solves most tasks without requiring any search.	<|special_separator|>
(369.41, 591.62) (504.17, 591.62) (504.17, 600.17) (369.41, 600.17)      /F116 Adding BestFS results in shorter	<|special_separator|>
(108.00, 580.71) (467.83, 580.71) (467.83, 589.26) (108.00, 589.26)      /F116 solutions. We plot the fraction of configurations solved with a solution length of at most	<|special_separator|>
(470.49, 580.87) (476.18, 580.87) (476.18, 589.58) (470.49, 589.58)       /F27 x	<|special_separator|>
(476.18, 580.71) (504.00, 580.71) (504.00, 589.26) (476.18, 589.26)      /F116 , while	<|special_separator|>
(108.00, 569.80) (503.99, 569.80) (503.99, 578.35) (108.00, 578.35)      /F116 limiting the number of nodes created to 6000. Surprisingly, on the Rubik's cube CRTR achieves a	<|special_separator|>
(108.00, 558.89) (183.73, 558.89) (183.73, 567.44) (108.00, 567.44)      /F116 higher success rate	<|special_separator|>
(186.23, 559.03) (216.33, 559.03) (216.33, 567.62) (186.23, 567.62)      /F134 without	<|special_separator|>
(219.00, 558.89) (504.00, 558.89) (504.00, 567.44) (219.00, 567.44)      /F116 search, solving all board configurations within the budget. Figure 11 in	<|special_separator|>
(108.00, 547.98) (504.00, 547.98) (504.00, 556.53) (108.00, 556.53)      /F116 the Appendix E presents the same results, but for CRTR, as well as the Contrastive and Supervised	<|special_separator|>
(108.00, 537.07) (147.01, 537.07) (147.01, 545.62) (108.00, 545.62)      /F116 baselines.	<|special_separator|>
(108.00, 500.30) (120.45, 500.30) (120.45, 509.26) (108.00, 509.26)      /F107 5.3	<|special_separator|>
(130.42, 500.30) (216.56, 500.30) (216.56, 509.26) (130.42, 509.26)      /F107 Is search necessary?	<|special_separator|>
(108.00, 478.95) (504.00, 478.95) (504.00, 487.50) (108.00, 487.50)      /F116 Do good representations allow us to solve combinatorial problems without search, or at least reduce	<|special_separator|>
(108.00, 468.04) (504.00, 468.04) (504.00, 476.59) (108.00, 476.59)      /F116 the amount of search required to get high success rates? We study this question by using the learned	<|special_separator|>
(108.00, 457.13) (448.31, 457.13) (448.31, 465.68) (108.00, 465.68)      /F116 representations to perform greedy planning (see Sec. 5.1) for up to 6000 search steps.	<|special_separator|>
(107.53, 440.74) (504.00, 440.74) (504.00, 449.30) (107.53, 449.30)      /F116 We present the results from this experiment in Figure 4, showing the fraction of problems solved with	<|special_separator|>
(108.00, 429.84) (504.00, 429.84) (504.00, 438.39) (108.00, 438.39)      /F116 fewer than a certain number of steps. We compare to the variant of CRTR used in Sec. 5.2 that uses	<|special_separator|>
(108.00, 418.93) (504.00, 418.93) (504.00, 427.48) (108.00, 427.48)      /F116 the representations to perform search. As an example of how to interpret this plot, the red line in the	<|special_separator|>
(108.00, 408.02) (504.00, 408.02) (504.00, 416.57) (108.00, 416.57)      /F116 leftmost plot shows that CRTR (without search) can solve about 50% of Rubik's cube configurations	<|special_separator|>
(108.00, 397.11) (466.39, 397.11) (466.39, 405.66) (108.00, 405.66)      /F116 in less than 300 moves. We compare to the CRL and Supervised baselines in Appendix E.	<|special_separator|>
(108.00, 380.72) (504.00, 380.72) (504.00, 389.27) (108.00, 389.27)      /F116 On 4 / 5 tasks (Rubik's Cube, Lights Out, 15-Puzzle, and Digit Jumper), CRTR solves nearly all	<|special_separator|>
(108.00, 369.81) (291.32, 369.81) (291.32, 378.36) (108.00, 378.36)      /F116 problem instances. The key takeaway is thus:	<|special_separator|>
(294.41, 369.95) (504.00, 369.95) (504.00, 378.54) (294.41, 378.54)      /F134 for most problems, CRTR can find solutions without	<|special_separator|>
(108.00, 359.05) (209.55, 359.05) (209.55, 367.63) (108.00, 367.63)      /F134 needing any search at all	<|special_separator|>
(209.55, 358.90) (504.00, 358.90) (504.00, 367.45) (209.55, 367.45)      /F116 . Perhaps the most interesting result is the Rubik's cube, where we found	<|special_separator|>
(108.00, 347.99) (504.00, 347.99) (504.00, 356.54) (108.00, 356.54)      /F116 that our representations can solve all problem instances in less than 6000 moves. Surprisingly, using	<|special_separator|>
(108.00, 337.08) (504.00, 337.08) (504.00, 345.64) (108.00, 345.64)      /F116 search decreases the total fraction of Cube configurations that are solved. The main failure mode is	<|special_separator|>
(108.00, 326.17) (468.74, 326.17) (468.74, 334.73) (108.00, 334.73)      /F116 Sokoban, where success rates are low, likely due to the presence of dead-ends in the game.	<|special_separator|>
(108.00, 309.79) (504.17, 309.79) (504.17, 318.34) (108.00, 318.34)      /F116 However, avoiding search comes at a cost: the solutions found without search are typically longer	<|special_separator|>
(108.00, 298.88) (504.00, 298.88) (504.00, 307.43) (108.00, 307.43)      /F116 than those found with search. For example, on the Rubik's Cube the average solution length is around	<|special_separator|>
(107.65, 287.97) (504.00, 287.97) (504.00, 296.52) (107.65, 296.52)      /F116 400 moves (see Appendix E) - much higher than the optimal of 26 moves and even higher than the	<|special_separator|>
(107.25, 277.06) (327.62, 277.06) (327.62, 285.61) (107.25, 285.61)      /F116 100 moves that beginner cube solving methods require.	<|special_separator|>
(107.69, 260.67) (504.00, 260.67) (504.00, 269.22) (107.69, 269.22)      /F116 This simple greedy approach - just picking the neighbor closest to the goal - starts to show hints of	<|special_separator|>
(108.00, 249.76) (504.35, 249.76) (504.35, 258.31) (108.00, 258.31)      /F116 algorithmic behavior. On Rubik's Cube, for example, it learns something that looks like a rudimentary	<|special_separator|>
(108.00, 238.85) (504.00, 238.85) (504.00, 247.40) (108.00, 247.40)      /F116 form of block-building (See Fig. 5, a common strategy used by humans for solving the cube. This	<|special_separator|>
(455.59, 136.80) (480.56, 136.80) (480.56, 148.37) (455.59, 148.37)        /F1 Step 86	<|special_separator|>
(456.37, 128.58) (479.88, 128.58) (479.88, 138.54) (456.37, 138.54)        /F2 Solved!	<|special_separator|>
(143.19, 136.80) (164.03, 136.80) (164.03, 148.37) (143.19, 148.37)        /F1 Step 1	<|special_separator|>
(127.25, 128.58) (179.89, 128.58) (179.89, 138.54) (127.25, 138.54)        /F2 Fully scrambled.	<|special_separator|>
(211.41, 136.80) (236.38, 136.80) (236.38, 148.37) (211.41, 148.37)        /F1 Step 16	<|special_separator|>
(196.38, 128.58) (253.22, 128.58) (253.22, 138.54) (196.38, 138.54)        /F2 Assembled lower 	<|special_separator|>
(204.52, 119.99) (243.22, 119.99) (243.22, 129.95) (204.52, 129.95)        /F2 2x2x2 block.	<|special_separator|>
(289.27, 136.80) (314.24, 136.80) (314.24, 148.37) (289.27, 148.37)        /F1 Step 38	<|special_separator|>
(264.78, 128.58) (340.35, 128.58) (340.35, 138.54) (264.78, 138.54)        /F2 Assembled 2x2x3 block 	<|special_separator|>
(270.42, 119.99) (334.76, 119.99) (334.76, 129.95) (270.42, 129.95)        /F2 and aligned smaller 	<|special_separator|>
(282.83, 111.27) (324.54, 111.27) (324.54, 121.23) (282.83, 121.23)        /F2 1x1x3 blocks.	<|special_separator|>
(372.43, 136.80) (397.40, 136.80) (397.40, 148.37) (372.43, 148.37)        /F1 Step 66	<|special_separator|>
(353.93, 128.58) (417.59, 128.58) (417.59, 138.54) (353.93, 138.54)        /F2 Almost all pieces in 	<|special_separator|>
(350.95, 119.99) (418.77, 119.99) (418.77, 129.95) (350.95, 129.95)        /F2 correct configuration.	<|special_separator|>
(108.00, 095.02) (143.38, 095.02) (143.38, 103.58) (108.00, 103.58)      /F116 Figure 5:	<|special_separator|>
(146.37, 095.22) (375.33, 095.22) (375.33, 103.28) (146.37, 103.28)      /F107 CRTR without search exhibits a block-building-like behavior.	<|special_separator|>
(378.35, 095.02) (504.00, 095.02) (504.00, 103.58) (378.35, 103.58)      /F116 Intermediate states from solving	<|special_separator|>
(108.00, 084.12) (504.00, 084.12) (504.00, 092.67) (108.00, 092.67)      /F116 a randomly scrambled cube, illustrating how the algorithm gradually builds partial structure. The	<|special_separator|>
(108.00, 073.21) (474.66, 073.21) (474.66, 081.76) (108.00, 081.76)      /F116 average solve is about 400 moves, and we see similar block building behavior across solves.	<|special_separator|>
(303.51, 040.05) (308.49, 040.05) (308.49, 048.60) (303.51, 048.60)      /F116 9