{"as_of":"2026-08-08T18:49:00Z","caps":{"database_statements":6,"inbound":100,"outbound":100},"context_digest":"sha256:235c3d80e2f19ff1c959673ba5a6f17a5e9ed07953a89d42af998d93a63e7365","coverage":[{"denominator":39,"lane":"reference_resolution","note":"Typed states for the displayed outbound observations.","records_observed":39,"source":"paper_references, paper_reference_links","source_observed_at":"2026-08-05T18:51:31.244551Z","state":"measured"},{"denominator":39,"lane":"standing_notices","note":"One-hop event checks from named stored sources.","records_observed":39,"source":"scholarly_work_events, retraction_status_cache","source_observed_at":"2026-08-08T06:32:00.761636+00:00","state":"measured"},{"denominator":0,"lane":"inbound_itemization","note":"Pith citing papers itemized under the disclosed page cap.","records_observed":0,"source":"paper_references, paper_reference_links","source_observed_at":null,"state":"measured"},{"denominator":1,"lane":"external_citation_measurements","note":"A source-named dated measurement, never combined with another source.","records_observed":0,"source":"cited_works","source_observed_at":null,"state":"measured"}],"external_citation_measurements":[],"inbound":[],"links":{"evidence":"/evidence","html":"/paper/2608.03461/citation-record","integrity":"/paper/2608.03461/integrity","json":"/paper/2608.03461/citation-record.json","paper":"/paper/2608.03461"},"outbound":[{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.696437Z","title":"Towards a generic algorithm for identifying high-quality decompositions of optimization problems","venue":null,"work_id":"140a5373-3eb9-48f6-b228-787e1111891b","year":2018},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":1,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:28.884764Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:76c7ab3a1c90a93163b2b2bf977ea3a546380587ef7e4778afd7462b0e0b2e00","observation_id":"af439342-f6fc-43fa-8d35-50fcdd53e03d","resolution":{"observed_at":"2026-08-05T18:51:31.699580Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.688762Z","title":"Syntax- guided synthesis","venue":null,"work_id":"f7439535-81d0-49ab-b47d-c3e14f7f371a","year":2013},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":2,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:28.950169Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:66238755b1032bedda37a0f506d0ad2895529f1fa6ae3bd0bc72d109bf64a4f0","observation_id":"e450b669-dd58-4305-970a-e5a541a48153","resolution":{"observed_at":"2026-08-05T18:51:31.691262Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"1611.01989","last_updated":"2017-03-08T11:50:33Z","snapshot_observed_at":"2026-08-07T04:42:46.236916Z","submitted_at":"2016-11-07T11:09:45Z","title":"DeepCoder: Learning to Write Programs","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"1611.01989","snapshot_observed_at":"2026-08-05T18:51:29.021512Z","title":"Deepcoder: Learning to write programs.arXiv preprint arXiv:1611.01989, 2016","venue":null,"work_id":null,"year":2016},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":3,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.021512Z"},"links":{"cited_paper":"/paper/1611.01989","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:df036ac7eefe2e694cb3a78b14e64ed0d04b75b9ab4a92712e41c5f34b03b837","observation_id":"ad2d51b0-b75c-440f-ac0a-af33e8e21c76","resolution":{"observed_at":"2026-08-05T18:51:29.021512Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.681257Z","title":"Flashfill++: Scaling programming by example by cutting to the chase","venue":null,"work_id":"e9704302-7942-4448-b8f5-b3b554cbcd03","year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":4,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.056904Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:3b9594d4b0d257d64f8fb77191fff3144367bb0ca2885ca926709895dbf5cfb5","observation_id":"2adb7d50-964d-43f1-9b16-b9b143ca2091","resolution":{"observed_at":"2026-08-05T18:51:31.683778Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:29.114010Z","title":"Hipo: Instruction hierarchy via constrained reinforcement learning.arXiv preprint arXiv:2603.16152, 2026","venue":null,"work_id":null,"year":2026},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":5,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.114010Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:07663fc193c56a39732c691222b200a7cafe50b6af8a9c71cc66bd43bccb35ca","observation_id":"095a3986-6726-4781-94d8-7017a26af1fd","resolution":{"observed_at":"2026-08-05T18:51:29.114010Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.672713Z","title":"Compositional generalization via neural-symbolic stack machines.Advances in Neural Information Processing Systems, 33:1690–1701, 2020","venue":null,"work_id":"01e9165b-47e0-4a2c-a6c4-e0f67499ff56","year":2020},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":6,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.185559Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:1bd8e9b54e3dd0d94d2e00c3cf60e8bc5ed91d1865390153724d44fd6e445ccc","observation_id":"31b2c117-e21e-45f8-b345-eea9bed3a9ab","resolution":{"observed_at":"2026-08-05T18:51:31.675729Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2504.08958","last_updated":"2025-04-11T20:26:49Z","snapshot_observed_at":"2026-08-07T16:06:23.985136Z","submitted_at":"2025-04-11T20:26:49Z","title":"Generating Planning Feedback for Open-Ended Programming Exercises with LLMs","version":1},"cited_work":{"arxiv_id":"2504.08958","doi":null,"metadata_source":"pith","pith_arxiv_id":"2504.08958","snapshot_observed_at":"2026-08-05T18:51:31.405708Z","title":"Generating Planning Feedback for Open-Ended Programming Exercises with LLMs","venue":"cs.CL","work_id":"ff99f80c-c74b-4e9d-9f04-70259be63995","year":2025},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":7,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.226264Z"},"links":{"cited_paper":"/paper/2504.08958","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:d859218ea1926d0f873b88a8af08fa1dcc9935ed7aa93caf1a15645d5a2cb64b","observation_id":"8dd688c0-8405-427a-8583-a137d61576e9","resolution":{"observed_at":"2026-08-05T18:51:31.408672Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.664729Z","title":"Robustfill: Neural program learning under noisy i/o","venue":null,"work_id":"a2b1ab84-69f8-4a2e-acb3-01fe6d6bd42d","year":2017},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":8,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.291788Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:eed5969bb54e0b2378d7d8f4a86587c1ad53d00ada00ea3dafa8c92a500cf9f8","observation_id":"f440cb6a-8ee9-4db2-a775-00b24c1f9d93","resolution":{"observed_at":"2026-08-05T18:51:31.667736Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.656998Z","title":"Synthesizing data structure transformations from input-output examples.ACM SIGPLAN Notices, 50(6):229–239, 2015","venue":null,"work_id":"d0c72a4e-53eb-40ff-95a7-3e0b86ea70ab","year":2015},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":9,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.350172Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:26b4e5530caf4576912afde30a478489f36f3ccd755ae2c4a714e97257e4f2f9","observation_id":"5ec0486c-4ab2-4ef9-a4d9-552c3ea7786a","resolution":{"observed_at":"2026-08-05T18:51:31.659737Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.648007Z","title":"Au- tomated curriculum learning for neural networks","venue":null,"work_id":"a47728a6-195d-49dc-8322-169166badac2","year":2017},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":10,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.381034Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:edc502cc87e94b1ad2818edc2994a27b7fef0ac5b8c00f21ee26d9e20ae16d75","observation_id":"139fd342-d5ea-4885-9e74-01fcaaef730d","resolution":{"observed_at":"2026-08-05T18:51:31.650891Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.639830Z","title":"Automating string processing in spreadsheets using input-output examples","venue":null,"work_id":"bf650cfa-ea58-48f3-b2ec-234129b80be9","year":2011},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":11,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.454298Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:ddf97a988f96c208bc6ebaf801f659fa80bd6362822ebc95183e9b27129dc188","observation_id":"f84f4926-0f72-46cc-ac07-81744874c136","resolution":{"observed_at":"2026-08-05T18:51:31.642727Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.631664Z","title":"Latent program- mer: Discrete latent codes for program synthesis","venue":null,"work_id":"caaf65ba-fe7f-471a-9c8f-d888796c2257","year":2021},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":12,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.522326Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:013f04fa65c24c4ad3a8848b9ff87d900b53bf9d2650cae7bb55ee57e8402508","observation_id":"65281f93-a9c2-423e-9d9d-aef2f0331b27","resolution":{"observed_at":"2026-08-05T18:51:31.634449Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2309.16467","last_updated":"2024-01-18T18:25:38Z","snapshot_observed_at":"2026-07-06T16:24:57.565403Z","submitted_at":"2023-09-28T14:33:20Z","title":"Compositional Program Generation for Few-Shot Systematic Generalization","version":2},"cited_work":{"arxiv_id":"2309.16467","doi":null,"metadata_source":"pith","pith_arxiv_id":"2309.16467","snapshot_observed_at":"2026-08-05T18:51:31.394795Z","title":"Compositional Program Generation for Few-Shot Systematic Generalization","venue":"cs.LG","work_id":"343b1cb6-0256-4e27-a679-b76b7351d19d","year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":13,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.570346Z"},"links":{"cited_paper":"/paper/2309.16467","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:eeed94912812e476f3407e997bdeaeed27fb5b73953a07d833c2183954d6e417","observation_id":"9ef69ba3-016e-43d3-ae4c-fbeb343bc51f","resolution":{"observed_at":"2026-08-05T18:51:31.397635Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.623956Z","title":"Addison-Wesley Professional, 1998","venue":null,"work_id":"cbc99ff8-4103-4bd8-b495-9dda7e45b519","year":1998},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":14,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.659054Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:d34be7d1a40b6df51d227491947bb571125a4b1bb2324eb777a36bc3c2aee486","observation_id":"2306de7a-8fa8-4706-938f-3b8db7da364f","resolution":{"observed_at":"2026-08-05T18:51:31.626661Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.615975Z","title":"Coderl: Mastering code generation through pretrained models and deep reinforcement learning","venue":null,"work_id":"c9ce19eb-9df4-4518-8cd8-7e53c07da038","year":2022},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":15,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.711673Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:d134afeb396607e25386fa30a4eb42b663f807fb51a4a1e01ac0f4b0fb735ef3","observation_id":"ad921d69-71b8-43e7-a3b1-308926986366","resolution":{"observed_at":"2026-08-05T18:51:31.618907Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.607915Z","title":"Accelerating search-based program synthesis using learned probabilistic models.ACM SIGPLAN Notices, 53(4):436–449, 2018","venue":null,"work_id":"e7fe4c4c-84e5-4afe-be09-61d8608611e5","year":2018},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":16,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.784178Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:3cdac1bd44968800f6ce79bfdcfd8d3c0170f7db48680fe81fcd820c7cc1e040","observation_id":"6ac28254-5831-4f15-8669-13fd9660a111","resolution":{"observed_at":"2026-08-05T18:51:31.610499Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2406.08316","last_updated":"2024-11-19T17:49:27Z","snapshot_observed_at":"2026-07-06T18:29:39.539339Z","submitted_at":"2024-06-12T15:16:40Z","title":"Is Programming by Example solved by LLMs?","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2406.08316","snapshot_observed_at":"2026-08-05T18:51:29.830507Z","title":"Is programming by example solved by llms?arXiv preprint arXiv:2406.08316, 2024","venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":17,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.830507Z"},"links":{"cited_paper":"/paper/2406.08316","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:9e86419309f78bcc1847b60686272b687cc49398be28f0bd2f690cf02c43a8d1","observation_id":"235982fa-b2bd-4f42-9d0f-0c91eca8843f","resolution":{"observed_at":"2026-08-05T18:51:29.830507Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:29.904675Z","title":"Hierarchical programmatic reinforcement learning via learning to compose programs","venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":18,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.904675Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:2d8bbf0e9acb51143acf5c0c0678fbbdccb17d730b68b05fb4cbb9ab708b6fd2","observation_id":"30226096-acc3-484f-a07f-5363a4927d17","resolution":{"observed_at":"2026-08-05T18:51:29.904675Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.594718Z","title":"Self-refine: Iterative refinement with self-feedback.Advances in neural information processing systems, pages 46534–46594, 2023","venue":null,"work_id":"18579cdb-71bb-4432-b1bd-927a26247b0e","year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":19,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:29.965892Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:57abc63f59b88a7361922467b860740ca96dbcef58f583a81912e87bb4a7bf66","observation_id":"fcec38c6-ebf0-41b8-9b39-c2fa97d3348a","resolution":{"observed_at":"2026-08-05T18:51:31.597504Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.586746Z","title":"Teacher–student curriculum learning.IEEE transactions on neural networks and learning systems, 31(9):3732–3740, 2019","venue":null,"work_id":"7f01356c-809c-475a-be76-84b3a0daf3bd","year":2019},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":20,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.026156Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:8b4d903c0f0ea6a6e1dbde7ba3506486502d15f2c0a9f4af18cc2f0933a52398","observation_id":"63f0922d-824e-4e1a-92cb-07d86f038901","resolution":{"observed_at":"2026-08-05T18:51:31.589657Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"1703.05698","last_updated":"2018-04-12T19:09:05Z","snapshot_observed_at":"2026-08-05T23:57:54.961796Z","submitted_at":"2017-03-16T16:23:30Z","title":"Neural Sketch Learning for Conditional Program Generation","version":5},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"1703.05698","snapshot_observed_at":"2026-08-05T18:51:30.115219Z","title":"Neural sketch learning for conditional program generation.arXiv preprint arXiv:1703.05698, 2017","venue":null,"work_id":null,"year":2017},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":21,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.115219Z"},"links":{"cited_paper":"/paper/1703.05698","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:f2d03de1d188f5f07ae5186506b8a03c40c134db431abd3c9f909b1bd1f293db","observation_id":"dda985b0-42f4-47ad-bcef-5fce053f399d","resolution":{"observed_at":"2026-08-05T18:51:30.115219Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.578638Z","title":"Learning to infer program sketches","venue":null,"work_id":"fbab59c9-813d-4108-a891-d2f2005cf19c","year":2019},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":22,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.151276Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:d000da1ed79345304688a4da7129e1a36c50bbbe91996aea0043fc5760ad1094","observation_id":"4170095d-49f4-4602-93ba-84c0ea097b82","resolution":{"observed_at":"2026-08-05T18:51:31.581879Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2306.09896","last_updated":"2024-02-02T18:31:34Z","snapshot_observed_at":"2026-08-06T10:06:10.773161Z","submitted_at":"2023-06-16T15:13:17Z","title":"Is Self-Repair a Silver Bullet for Code Generation?","version":5},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2306.09896","snapshot_observed_at":"2026-08-05T18:51:30.162658Z","title":"Is self-repair a silver bullet for code generation?arXiv preprint arXiv:2306.09896, 2023","venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":23,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.162658Z"},"links":{"cited_paper":"/paper/2306.09896","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:8c57b26861d080d092d538f26bb9375433d15bf6ecaf97d661fcf845bbbfd07a","observation_id":"74643d82-c2ea-49c6-8c8b-460ce83edb48","resolution":{"observed_at":"2026-08-05T18:51:30.162658Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.570410Z","title":"Doing experiments and revising rules with natural language and probabilistic reasoning.Advances in Neural Information Processing Systems, 37:53102–53137, 2024","venue":null,"work_id":"940add17-5976-4098-836b-0372b48cc5e8","year":2024},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":24,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.323671Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:d1e4de4639065ae31bccd2c94d7c6a10b6889b36ba0947e98822d75ce2233ea3","observation_id":"0a8a5977-0b94-4b52-9048-8bdf7e68eae8","resolution":{"observed_at":"2026-08-05T18:51:31.573393Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2003.04664","last_updated":"2020-05-28T20:51:40Z","snapshot_observed_at":"2026-07-06T09:03:37.435861Z","submitted_at":"2020-03-10T12:38:31Z","title":"Automatic Curriculum Learning For Deep RL: A Short Survey","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2003.04664","snapshot_observed_at":"2026-08-05T18:51:30.449280Z","title":"Au- tomatic curriculum learning for deep rl: A short survey.arXiv preprint arXiv:2003.04664, 2020","venue":null,"work_id":null,"year":2003},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":25,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.449280Z"},"links":{"cited_paper":"/paper/2003.04664","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:e726910517a482c09e31f97a8c7be2e6da8501bf3716eab09b4131429bc3509e","observation_id":"923ed18c-373b-422f-9132-77c2d3eb5ae9","resolution":{"observed_at":"2026-08-05T18:51:30.449280Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2311.05772","last_updated":"2024-04-08T20:42:17Z","snapshot_observed_at":"2026-07-06T16:45:32.248661Z","submitted_at":"2023-11-08T17:59:15Z","title":"ADaPT: As-Needed Decomposition and Planning with Language Models","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2311.05772","snapshot_observed_at":"2026-08-05T18:51:30.565648Z","title":"Adapt: As-needed decomposition and planning with language models","venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":26,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.565648Z"},"links":{"cited_paper":"/paper/2311.05772","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:76c5e97174eae847a8567fe2945485ae3edbd925ae00123c82059df9f2f80135","observation_id":"3711e986-a8a8-4db6-bd90-561e9bb6f0a4","resolution":{"observed_at":"2026-08-05T18:51:30.565648Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2310.08559","last_updated":"2024-05-22T14:35:15Z","snapshot_observed_at":"2026-08-08T15:26:27.022867Z","submitted_at":"2023-10-12T17:51:10Z","title":"Phenomenal Yet Puzzling: Testing Inductive Reasoning Capabilities of Language Models with Hypothesis Refinement","version":4},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2310.08559","snapshot_observed_at":"2026-08-05T18:51:30.714339Z","title":"Phenomenal yet puzzling: Testing inductive reasoning capabilities of language models with hypothesis refinement.arXiv preprint arXiv:2310.08559, 2023","venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":27,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.714339Z"},"links":{"cited_paper":"/paper/2310.08559","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:d577cd47e0017190395bc4c1dd3b69e25331419ab3e5582b2c56b44990745f9e","observation_id":"1e451f00-9172-4bea-94f2-4e38dc7074c0","resolution":{"observed_at":"2026-08-05T18:51:30.714339Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"1511.06732","last_updated":"2016-05-06T21:18:46Z","snapshot_observed_at":"2026-07-31T03:58:50.695173Z","submitted_at":"2015-11-20T19:25:54Z","title":"Sequence Level Training with Recurrent Neural Networks","version":7},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"1511.06732","snapshot_observed_at":"2026-08-05T18:51:30.831063Z","title":"Sequence level training with recurrent neural networks.arXiv preprint arXiv:1511.06732, 2015","venue":null,"work_id":null,"year":2015},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":28,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.831063Z"},"links":{"cited_paper":"/paper/1511.06732","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:11d0e91d96eef62447947f38d6512c6abe49889f9853dfad8de085636a78fae5","observation_id":"cc13da93-6b69-489f-a87d-c246661b235a","resolution":{"observed_at":"2026-08-05T18:51:30.831063Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.562017Z","title":"Self- critical sequence training for image captioning","venue":null,"work_id":"b94bde9e-f6fd-44d1-a9c3-f34672098a57","year":2017},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":29,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:30.978983Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:6897eec0a1ce8d0c769b9aa7ead0bc700d4ca5f7bdea3f05b382462bd6fecaa7","observation_id":"44632b90-f252-4267-9861-3af626e8a71b","resolution":{"observed_at":"2026-08-05T18:51:31.564615Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.553681Z","title":"Lambdabeam: Neural program search with higher-order functions and lambdas.Advances in Neural Information Processing Systems, pages 51327–51346, 2023","venue":null,"work_id":"d1b89b07-ce47-4a60-ac8d-801c01ae1d74","year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":30,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.103554Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:d26ceecec86442482c5e0a2a429d9d0978024ae73a04bad7392944292acb6446","observation_id":"0ea1d8ef-a77f-4df9-a968-8b1255fc20b7","resolution":{"observed_at":"2026-08-05T18:51:31.556721Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2307.13883","last_updated":"2024-05-06T11:01:36Z","snapshot_observed_at":"2026-07-06T15:58:35.684552Z","submitted_at":"2023-07-26T01:07:52Z","title":"ExeDec: Execution Decomposition for Compositional Generalization in Neural Program Synthesis","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2307.13883","snapshot_observed_at":"2026-08-05T18:51:31.217308Z","title":"Exedec: Execution decomposition for compositional generalization in neural program synthesis","venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":31,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.217308Z"},"links":{"cited_paper":"/paper/2307.13883","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:79e78bfad519cfadabe739d52a24da7f32a94ba3e0a172dcc4526201c7722761","observation_id":"36da0d9a-39af-4cf7-9209-3a5af2c7053f","resolution":{"observed_at":"2026-08-05T18:51:31.217308Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"1912.12345","last_updated":"2019-12-27T21:28:10Z","snapshot_observed_at":"2026-07-06T08:47:20.061371Z","submitted_at":"2019-12-27T21:28:10Z","title":"Synthetic Datasets for Neural Program Synthesis","version":1},"cited_work":{"arxiv_id":"1912.12345","doi":null,"metadata_source":"pith","pith_arxiv_id":"1912.12345","snapshot_observed_at":"2026-08-05T18:51:31.321516Z","title":"Synthetic Datasets for Neural Program Synthesis","venue":"cs.LG","work_id":"d578ac92-3a94-42d5-97f5-776d512c897a","year":2019},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":32,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.221425Z"},"links":{"cited_paper":"/paper/1912.12345","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:f94f27b57fb5db9deb7de91a5b8e5ae48e43d8eac9abc7509af42eebbbfeaae2","observation_id":"5ac6f732-a317-47f8-a2e0-9685a297554b","resolution":{"observed_at":"2026-08-05T18:51:31.324462Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.545682Z","title":"University of California, Berkeley, 2008","venue":null,"work_id":"ecea3f43-8e89-4340-b3ee-b288bf457162","year":2008},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":33,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.224272Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:38135d1852d687a3add58fd479779f226e0bf9f1d67e60f4185718ae2d597d10","observation_id":"cf187b88-0e45-4278-bc5a-689778af4f39","resolution":{"observed_at":"2026-08-05T18:51:31.548258Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.537504Z","title":"Learning to synthesize programs as interpretable and generalizable policies.Advances in neural information processing systems, 34:25146–25163, 2021","venue":null,"work_id":"eefe67d0-4f78-480e-a253-0f8f5cae9d73","year":2021},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":34,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.227604Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:ea4f641ae91a5865b1995b9b6bc9a10ff38838f3f29cced6738f3a01b6c81e9c","observation_id":"2fad472a-e13c-4d14-9c87-7d2dfb9cb840","resolution":{"observed_at":"2026-08-05T18:51:31.540292Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2301.03094","last_updated":"2024-12-24T10:00:23Z","snapshot_observed_at":"2026-08-06T02:46:43.789053Z","submitted_at":"2023-01-08T19:10:55Z","title":"A Divide-Align-Conquer Strategy for Program Synthesis","version":2},"cited_work":{"arxiv_id":"2301.03094","doi":null,"metadata_source":"pith","pith_arxiv_id":"2301.03094","snapshot_observed_at":"2026-08-05T18:51:31.309467Z","title":"A Divide-Align-Conquer Strategy for Program Synthesis","venue":"cs.AI","work_id":"013b63b8-1fd7-46e1-86ad-c96f3799ac0a","year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":35,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.230367Z"},"links":{"cited_paper":"/paper/2301.03094","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:fe246e96dd7294c2926d7f63805b529afc98166a2d30da2ebeec1e63fef0ac25","observation_id":"6a881051-4e9f-4ee4-bfc2-f677d019a542","resolution":{"observed_at":"2026-08-05T18:51:31.312954Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"1704.01696","last_updated":"2017-04-06T03:13:46Z","snapshot_observed_at":"2026-07-31T18:14:24.576743Z","submitted_at":"2017-04-06T03:13:46Z","title":"A Syntactic Neural Model for General-Purpose Code Generation","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"1704.01696","snapshot_observed_at":"2026-08-05T18:51:31.233876Z","title":"A syntactic neural model for general-purpose code generation.arXiv preprint arXiv:1704.01696, 2017","venue":null,"work_id":null,"year":2017},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":36,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.233876Z"},"links":{"cited_paper":"/paper/1704.01696","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:97d1d8b72cdc319a87008f881586e900118fb4c1b12118eede357d3699711911","observation_id":"8e9dc693-bfd6-4a2a-8fc1-c1c47bc021fe","resolution":{"observed_at":"2026-08-05T18:51:31.233876Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2505.14744","last_updated":"2026-08-04T11:01:52Z","snapshot_observed_at":"2026-08-07T23:11:14.657778Z","submitted_at":"2025-05-20T08:23:46Z","title":"Beyond Either-Or Reasoning: Transduction and Induction as Cooperative Problem-Solving Paradigms","version":3},"cited_work":{"arxiv_id":"2505.14744","doi":null,"metadata_source":"pith","pith_arxiv_id":"2505.14744","snapshot_observed_at":"2026-08-05T18:51:31.283498Z","title":"Beyond Either-Or Reasoning: Transduction and Induction as Cooperative Problem-Solving Paradigms","venue":"cs.PL","work_id":"fef574fb-9b13-4426-ba82-d777aa2a0e12","year":2025},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":37,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.237583Z"},"links":{"cited_paper":"/paper/2505.14744","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:513e6a2ffc85c275dd105cefccefbecbc93d871624b858944297f2914efdafd2","observation_id":"8bccfc85-65ff-47b5-a0fb-3e9641fc88d6","resolution":{"observed_at":"2026-08-05T18:51:31.288534Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2303.05510","last_updated":"2023-03-09T18:59:47Z","snapshot_observed_at":"2026-07-06T15:00:58.804337Z","submitted_at":"2023-03-09T18:59:47Z","title":"Planning with Large Language Models for Code Generation","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2303.05510","snapshot_observed_at":"2026-08-05T18:51:31.240272Z","title":"Limitations","venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":38,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.240272Z"},"links":{"cited_paper":"/paper/2303.05510","citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:79ccdd305f9d6e29ff32bc599fc49266a0b97f62dc0f43c9af5748dd63edffcb","observation_id":"34c9818c-a02b-4a85-975d-a0df969a136d","resolution":{"observed_at":"2026-08-05T18:51:31.240272Z","resolver_source":null,"status":"malformed_identifier"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T18:51:31.529238Z","title":"Guidelines: 30 • The answer [N/A] means that the paper does not involve crowdsourcing nor research with human subjects","venue":null,"work_id":"848b39b4-d387-4579-aabc-9580d7e1601d","year":null},"citing_paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer","version":1},"reference_index":39,"source":"pdf_text","source_observed_at":"2026-08-05T18:51:31.244551Z"},"links":{"citing_paper":"/paper/2608.03461"},"observation_digest":"sha256:1ae73121bc36891e064740d06c2dbae9c6fa3a55271644b12b0514abcb876c3f","observation_id":"232d7d57-5563-4e7e-a9bd-b7a1bbe60c05","resolution":{"observed_at":"2026-08-05T18:51:31.532343Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-08T06:32:00.761636+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"state":"measured"}}],"paper":{"arxiv_id":"2608.03461","last_updated":"2026-08-04T10:57:31Z","latest_version":1,"primary_category":"cs.AI","snapshot_observed_at":"2026-08-08T00:17:17.781560Z","submitted_at":"2026-08-04T10:57:31Z","title":"Solver-Aware Decompositions for Programming-by-Example: When Dividing Requires Knowing how to Conquer"},"reference_resolution":{"displayed":39,"state_counts":{"malformed_identifier":1,"metadata_mismatch":0,"parse_uncertain":0,"unresolved":12,"verified_exact":5,"verified_fuzzy":21},"total_outbound_references":39},"refusal":"A citation records a reference. It does not transfer a finding from one paper to another.","schema":"pith.paper-citation-record.v1","standing_sources":[{"observed_at":"2026-08-08T06:32:00.761636+00:00","source":"crossref"},{"observed_at":"2026-08-08T06:31:55.24221+00:00","source":"retraction_watch"}],"thesis":"As of 8 August 2026, this Paper Citation Record lists 39 of 39 outbound references and 0 inbound Pith citation observations for arXiv:2608.03461."}