{"as_of":"2026-08-14T06:26:00Z","caps":{"database_statements":6,"inbound":100,"outbound":100},"context_digest":"sha256:d7cb03bfcf8c0e9918f9aeb75fdfa8c807f1377a9e82441e59171be147b42e51","coverage":[{"denominator":33,"lane":"reference_resolution","note":"Typed states for the displayed outbound observations.","records_observed":33,"source":"paper_references, paper_reference_links","source_observed_at":"2026-08-10T23:17:48.617881Z","state":"measured"},{"denominator":34,"lane":"standing_notices","note":"One-hop event checks from named stored sources.","records_observed":34,"source":"scholarly_work_events, retraction_status_cache","source_observed_at":"2026-08-13T06:32:02.005865+00:00","state":"measured"},{"denominator":1,"lane":"inbound_itemization","note":"Pith citing papers itemized under the disclosed page cap.","records_observed":1,"source":"paper_references, paper_reference_links","source_observed_at":"2026-05-09T20:57:43.802195Z","state":"measured"},{"denominator":1,"lane":"external_citation_measurements","note":"A source-named dated measurement, never combined with another source.","records_observed":1,"source":"arxiv_reference","source_observed_at":"2026-08-05T02:28:24.338817Z","state":"measured"}],"external_citation_measurements":[{"count":0,"observed_at":"2026-08-05T02:28:24.338817Z","source":"arxiv_reference"}],"inbound":[{"citation":{"cited_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"cited_work":{"arxiv_id":"2502.17442","doi":"10.48550/arxiv.2502.17442","metadata_source":"arxiv_reference","pith_arxiv_id":"2502.17442","snapshot_observed_at":"2026-08-05T02:28:24.338817Z","title":"doi:10.48550/arXiv.2502.17442 arXiv:2502.17442 [cs]","venue":"ArXiv.org","work_id":"33c91fe4-a569-4fbd-87ed-db5b40239ae3","year":null},"citing_paper":{"arxiv_id":"2604.21598","last_updated":"2026-04-28T05:10:28Z","snapshot_observed_at":"2026-08-11T04:37:54.634621Z","submitted_at":"2026-04-23T12:21:03Z","title":"You Don't Need Public Tests to Generate Correct Code","version":2},"reference_index":24,"source":"pdf_text","source_observed_at":"2026-05-09T20:57:43.802195Z"},"links":{"cited_paper":"/paper/2502.17442","citing_paper":"/paper/2604.21598"},"observation_digest":"sha256:8b37a5dfbecd7f7398e1866dbd20e0c79952a92facf1c0707a6452b85d1ee3b3","observation_id":"62e98827-1b4c-411a-be75-ea9b2914b20d","resolution":{"observed_at":"2026-05-09T20:58:06.467878Z","resolver_source":"arxiv_id","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+00:00","source":"retraction_watch"}],"state":"measured"}}],"links":{"evidence":"/evidence","html":"/paper/2502.17442/citation-record","integrity":"/paper/2502.17442/integrity","json":"/paper/2502.17442/citation-record.json","paper":"/paper/2502.17442"},"outbound":[{"citation":{"cited_paper":{"arxiv_id":"2108.07732","last_updated":"2021-08-16T03:57:30Z","snapshot_observed_at":"2026-08-02T19:23:53.535075Z","submitted_at":"2021-08-16T03:57:30Z","title":"Program Synthesis with Large Language Models","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2108.07732","snapshot_observed_at":"2026-08-10T23:17:48.473984Z","title":null,"venue":null,"work_id":null,"year":2021},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":1,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.473984Z"},"links":{"cited_paper":"/paper/2108.07732","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:af7cb64e29627c03b4481796752978909eb6c11f2efab037ce22099af1d72c61","observation_id":"e5d3caa3-bf88-4110-beee-fcef74110ac9","resolution":{"observed_at":"2026-08-10T23:17:48.473984Z","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-10T23:17:49.124723Z","title":null,"venue":null,"work_id":"bc128814-ac9b-4538-82f2-2a9efd34b57d","year":1960},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":2,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.479445Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:c68be12999a0c6b8312ec6b322f74115798dcec0d8fac439d7e454c72e57f61c","observation_id":"54d32a8b-7329-4052-b765-284465de6546","resolution":{"observed_at":"2026-08-10T23:17:49.129014Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2309.16609","last_updated":"2023-09-28T17:07:49Z","snapshot_observed_at":"2026-08-09T21:25:20.369782Z","submitted_at":"2023-09-28T17:07:49Z","title":"Qwen Technical Report","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2309.16609","snapshot_observed_at":"2026-08-10T23:17:48.484004Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":3,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.484004Z"},"links":{"cited_paper":"/paper/2309.16609","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:b7db39660942add983e6dc90e0fdc286f7aa482efaf15c0164239d5677ff30ea","observation_id":"e3556d81-e9b9-4a2e-9fd1-6103803ceeaf","resolution":{"observed_at":"2026-08-10T23:17:48.484004Z","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-10T23:17:48.489110Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":4,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.489110Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:eb2129702af28a9708a22e3a1d982a1e09fdc852c69fb5d0c4ddcbbe24bb505c","observation_id":"e7dd3b57-abed-42c3-b5cc-957f58ead7b2","resolution":{"observed_at":"2026-08-10T23:17:48.489110Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2303.16749","last_updated":"2024-02-22T22:30:31Z","snapshot_observed_at":"2026-08-13T12:14:43.786892Z","submitted_at":"2023-03-28T16:15:31Z","title":"Improving Code Generation by Training with Natural Language Feedback","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2303.16749","snapshot_observed_at":"2026-08-10T23:17:48.493851Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":5,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.493851Z"},"links":{"cited_paper":"/paper/2303.16749","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:6839cedb4698aa62b45465640e5ff1d7c8a4fac8d5791a1017d7ebefcd41cb03","observation_id":"401c170f-e5f1-4bea-91b4-84cf1145ed3d","resolution":{"observed_at":"2026-08-10T23:17:48.493851Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2107.03374","last_updated":"2021-07-14T17:16:02Z","snapshot_observed_at":"2026-08-08T11:58:24.516369Z","submitted_at":"2021-07-07T17:41:24Z","title":"Evaluating Large Language Models Trained on Code","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2107.03374","snapshot_observed_at":"2026-08-10T23:17:48.498759Z","title":null,"venue":null,"work_id":null,"year":2021},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":6,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.498759Z"},"links":{"cited_paper":"/paper/2107.03374","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:3d5d68ae731fbf900037cca9701729d3903215e3d369ab6ac8b215c4c42326a7","observation_id":"c1a46184-3c9a-4e1f-bfd6-bbe4785b163a","resolution":{"observed_at":"2026-08-10T23:17:48.498759Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2301.09043","last_updated":"2024-09-05T14:00:11Z","snapshot_observed_at":"2026-08-14T06:08:02.962592Z","submitted_at":"2023-01-22T02:59:59Z","title":"CodeScore: Evaluating Code Generation by Learning Code Execution","version":4},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2301.09043","snapshot_observed_at":"2026-08-10T23:17:48.503962Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":7,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.503962Z"},"links":{"cited_paper":"/paper/2301.09043","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:326a468d98960ab7df9ccd7ded32129dd54e3a7709549b9ac1d0adbb61000325","observation_id":"fab6e0b4-8cdf-42ba-92e0-d797820f6fd0","resolution":{"observed_at":"2026-08-10T23:17:48.503962Z","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-10T23:17:48.508691Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":8,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.508691Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:b465bf6c4ab328cb35fb8d02ef7fd244085d126751cc0c104e572aa63a7a21fa","observation_id":"5f9689d7-7977-4de3-bed8-1a6a7c60387b","resolution":{"observed_at":"2026-08-10T23:17:48.508691Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2308.08998","last_updated":"2023-08-21T10:23:42Z","snapshot_observed_at":"2026-08-13T14:38:32.919809Z","submitted_at":"2023-08-17T14:12:48Z","title":"Reinforced Self-Training (ReST) for Language Modeling","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2308.08998","snapshot_observed_at":"2026-08-10T23:17:48.512842Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":9,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.512842Z"},"links":{"cited_paper":"/paper/2308.08998","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:986d3872c28a910a0a479472880fd2df091f37c05b52340f5e89392c174a7530","observation_id":"dec747df-4f79-4569-b016-fab42a29f75b","resolution":{"observed_at":"2026-08-10T23:17:48.512842Z","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-10T23:17:49.093708Z","title":null,"venue":null,"work_id":"e381f45b-7465-40fe-95e0-dec50744d731","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":10,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.517534Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:9b461a65543f06d476eadde3f808e3bfb48b132546254311c138a080b303dcd3","observation_id":"feca80aa-84df-42ab-aadc-193e65ef4d8d","resolution":{"observed_at":"2026-08-10T23:17:49.098014Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2106.09685","last_updated":"2021-10-16T18:40:34Z","snapshot_observed_at":"2026-08-11T08:20:29.798517Z","submitted_at":"2021-06-17T17:37:18Z","title":"LoRA: Low-Rank Adaptation of Large Language Models","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2106.09685","snapshot_observed_at":"2026-08-10T23:17:48.521708Z","title":null,"venue":null,"work_id":null,"year":2021},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":11,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.521708Z"},"links":{"cited_paper":"/paper/2106.09685","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:4e7c47e2fbed3151a7159b39a78e03cbd555bbffab124a283608022e34f4c18d","observation_id":"04fc2a8b-916d-474e-ac6f-7d2504bfdf5f","resolution":{"observed_at":"2026-08-10T23:17:48.521708Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2308.08784","last_updated":"2024-02-23T04:56:37Z","snapshot_observed_at":"2026-08-13T10:33:15.720855Z","submitted_at":"2023-08-17T04:58:51Z","title":"CodeCoT: Tackling Code Syntax Errors in CoT Reasoning for Code Generation","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2308.08784","snapshot_observed_at":"2026-08-10T23:17:48.526393Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":12,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.526393Z"},"links":{"cited_paper":"/paper/2308.08784","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:06b2118ed66e7af70cc192679fc9a4bd130430215f214d4e98fe38e34d58f112","observation_id":"2fb5f049-3ed6-4abe-9052-cc552b1095a4","resolution":{"observed_at":"2026-08-10T23:17:48.526393Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2312.13010","last_updated":"2024-05-24T11:47:24Z","snapshot_observed_at":"2026-07-06T17:05:56.282078Z","submitted_at":"2023-12-20T13:22:41Z","title":"AgentCoder: Multi-Agent-based Code Generation with Iterative Testing and Optimisation","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2312.13010","snapshot_observed_at":"2026-08-10T23:17:48.530234Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":13,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.530234Z"},"links":{"cited_paper":"/paper/2312.13010","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:7403e982e54066e7b49f33b579bede2f411e7088aa4d8c1262031e7e5e405c07","observation_id":"41c894e7-964d-430b-9d32-9e0b8df86c9f","resolution":{"observed_at":"2026-08-10T23:17:48.530234Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2405.11403","last_updated":"2024-05-18T22:10:15Z","snapshot_observed_at":"2026-08-13T16:18:43.044378Z","submitted_at":"2024-05-18T22:10:15Z","title":"MapCoder: Multi-Agent Code Generation for Competitive Problem Solving","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2405.11403","snapshot_observed_at":"2026-08-10T23:17:48.533949Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":14,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.533949Z"},"links":{"cited_paper":"/paper/2405.11403","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:c120edfd4d30ac47c3a4b77e277c6ade9e08440c2f5c7a4a5e4b2cdcd1bcdf6c","observation_id":"3268fca6-7795-47c3-b845-678e0a490c70","resolution":{"observed_at":"2026-08-10T23:17:48.533949Z","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-10T23:17:49.080536Z","title":null,"venue":null,"work_id":"5b3bf2fc-c798-469a-9f78-fa2823382c03","year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":15,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.537646Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:830d9f9ad7c8c2fbfb62a7ce3c21d0283f7b9b0801224cd8e810882cd060bbd4","observation_id":"601cd8eb-6a9e-431c-9b67-2f0f551e1cba","resolution":{"observed_at":"2026-08-10T23:17:49.084848Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+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-10T23:17:49.066056Z","title":null,"venue":null,"work_id":"5f0d8e30-72b4-45ef-8dcd-967993cff026","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":16,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.541473Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:b0b186ea2879a1aae339f3e46be72977b3dc90d1f6cfa149a3614e465ebbbf1d","observation_id":"58cf11a8-9c49-411b-a07f-c4f901eb526e","resolution":{"observed_at":"2026-08-10T23:17:49.071299Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+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-10T23:17:49.051916Z","title":null,"venue":null,"work_id":"485409af-8384-4bc7-92eb-316c36507450","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":17,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.544983Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:190af9136406ea15dbcf0bffa1e66c9ae0ddf69a765770e020f0d81f36591296","observation_id":"2ef21f99-d3c8-4985-8a30-598479c7566d","resolution":{"observed_at":"2026-08-10T23:17:49.056203Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+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-10T23:17:49.038683Z","title":null,"venue":null,"work_id":"444c3c4d-8d84-476f-be16-8614064bd184","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":18,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.548936Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:ce770e71d695a952451c62ac08f16182f12847e094a4b1b4c8aa2f7515abfd14","observation_id":"87398bf2-48f6-488f-b625-8d5864481984","resolution":{"observed_at":"2026-08-10T23:17:49.042972Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+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-10T23:17:48.553127Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":19,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.553127Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:450e04f952bc10c954c8462badf4bc350018401a1c3201d7139bb4862282a1b9","observation_id":"6a201951-e88c-4b49-a260-49f8fa22a8f7","resolution":{"observed_at":"2026-08-10T23:17:48.553127Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2304.11686","last_updated":"2023-09-09T09:55:18Z","snapshot_observed_at":"2026-08-13T12:57:19.378168Z","submitted_at":"2023-04-23T15:35:39Z","title":"Nuances are the Key: Unlocking ChatGPT to Find Failure-Inducing Tests with Differential Prompting","version":6},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2304.11686","snapshot_observed_at":"2026-08-10T23:17:48.558080Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":20,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.558080Z"},"links":{"cited_paper":"/paper/2304.11686","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:69ff77bb76566433daf4cc5f8b300133d0c361ecee4ed6a7512d2ef463417b0b","observation_id":"b72e6bac-6ac5-4e1a-9159-69cf45c2723e","resolution":{"observed_at":"2026-08-10T23:17:48.558080Z","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-10T23:17:49.024700Z","title":null,"venue":null,"work_id":"a046198a-17bc-4b32-ac55-367c75531342","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":21,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.563191Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:d7ad3c4391ed08edb5c2133b57a9c31f7f81dc8de4f232d017c017bf14c97a65","observation_id":"080036af-5a3d-4f08-ab63-e838e42803c3","resolution":{"observed_at":"2026-08-10T23:17:49.029273Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2308.07124","last_updated":"2024-02-18T09:46:06Z","snapshot_observed_at":"2026-08-13T10:34:55.330090Z","submitted_at":"2023-08-14T13:53:54Z","title":"OctoPack: Instruction Tuning Code Large Language Models","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2308.07124","snapshot_observed_at":"2026-08-10T23:17:48.568165Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":22,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.568165Z"},"links":{"cited_paper":"/paper/2308.07124","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:68bd92421dba53f32c0e9019731a318151eb3166a13d46e7025982eaf6d2779f","observation_id":"2be6b1e7-d69b-4b8d-8728-443a40ec9fbb","resolution":{"observed_at":"2026-08-10T23:17:48.568165Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2202.03286","last_updated":"2022-02-07T15:22:17Z","snapshot_observed_at":"2026-07-06T02:11:23.670680Z","submitted_at":"2022-02-07T15:22:17Z","title":"Red Teaming Language Models with Language Models","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2202.03286","snapshot_observed_at":"2026-08-10T23:17:48.572882Z","title":null,"venue":null,"work_id":null,"year":2022},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":23,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.572882Z"},"links":{"cited_paper":"/paper/2202.03286","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:ce3395dbfd9e662a46a993a1d39add9bdc484a6184523e5f5cfadcdd87781c19","observation_id":"cbe07dbe-945f-42e7-9c16-e16ecb2bab5e","resolution":{"observed_at":"2026-08-10T23:17:48.572882Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2307.16789","last_updated":"2023-10-03T14:45:48Z","snapshot_observed_at":"2026-07-06T16:00:46.542753Z","submitted_at":"2023-07-31T15:56:53Z","title":"ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2307.16789","snapshot_observed_at":"2026-08-10T23:17:48.577983Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":24,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.577983Z"},"links":{"cited_paper":"/paper/2307.16789","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:f76aec026e15e71b5930ace6c097a5762cb614f386435af17f2bc96f8bf0cc34","observation_id":"0c77ee0f-3af4-43d5-ab77-23ee59fb33f6","resolution":{"observed_at":"2026-08-10T23:17:48.577983Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2401.08500","last_updated":"2024-01-16T17:00:36Z","snapshot_observed_at":"2026-08-13T04:41:52.622365Z","submitted_at":"2024-01-16T17:00:36Z","title":"Code Generation with AlphaCodium: From Prompt Engineering to Flow Engineering","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2401.08500","snapshot_observed_at":"2026-08-10T23:17:48.583121Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":25,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.583121Z"},"links":{"cited_paper":"/paper/2401.08500","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:1545c142de39eac3ca0eb8ffb87b7a4dcce2f6865d02ff9b203dc2ac45f5ca3f","observation_id":"ca309695-8f37-4f14-9e4c-508e55086672","resolution":{"observed_at":"2026-08-10T23:17:48.583121Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2308.12950","last_updated":"2024-01-31T19:47:26Z","snapshot_observed_at":"2026-08-13T04:25:38.282910Z","submitted_at":"2023-08-24T17:39:13Z","title":"Code Llama: Open Foundation Models for Code","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2308.12950","snapshot_observed_at":"2026-08-10T23:17:48.587637Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":26,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.587637Z"},"links":{"cited_paper":"/paper/2308.12950","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:a28f03e6df92e197e7965bf284606b2daa945520a290951d3f493f59a1a7148c","observation_id":"97bb41a1-a13b-4ce3-a758-4789a6ff9684","resolution":{"observed_at":"2026-08-10T23:17:48.587637Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2408.03314","last_updated":"2024-08-06T17:35:05Z","snapshot_observed_at":"2026-07-06T02:11:23.670680Z","submitted_at":"2024-08-06T17:35:05Z","title":"Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2408.03314","snapshot_observed_at":"2026-08-10T23:17:48.591987Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":27,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.591987Z"},"links":{"cited_paper":"/paper/2408.03314","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:20422d0bb1f81aaeb35e576608d1b9e20b030ced66bc9d42ddbb0040a9f98d3f","observation_id":"df65e31f-060e-4b0c-9c52-61308abcc822","resolution":{"observed_at":"2026-08-10T23:17:48.591987Z","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-10T23:17:49.011304Z","title":null,"venue":null,"work_id":"2fb3707b-6762-4840-940e-41add2d79753","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":28,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.596552Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:7cac9f12da1eb67fe25b489de2da042badde7897c8484431592b0b2e2c95f046","observation_id":"b98eca70-76db-4cac-bd95-2e25c7267ec0","resolution":{"observed_at":"2026-08-10T23:17:49.015598Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+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-10T23:17:48.996311Z","title":null,"venue":null,"work_id":"b4c83968-e317-4a15-9b71-1607a4a63f27","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":29,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.600619Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:808e23147228882e9d1d91d97cca1dd82cf0fd961d068290d02fe107ca286c4a","observation_id":"3487d7fb-32cb-44fc-aeb6-b602f736ed2a","resolution":{"observed_at":"2026-08-10T23:17:49.001625Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-13T06:32:02.005865+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2402.14658","last_updated":"2025-01-07T05:37:04Z","snapshot_observed_at":"2026-08-13T04:12:47.707151Z","submitted_at":"2024-02-22T16:06:23Z","title":"OpenCodeInterpreter: Integrating Code Generation with Execution and Refinement","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2402.14658","snapshot_observed_at":"2026-08-10T23:17:48.604751Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":30,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.604751Z"},"links":{"cited_paper":"/paper/2402.14658","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:273c4f3706b975886b44cb20df6f08a8a387bb12a262fa2255107ec1e081cc0d","observation_id":"24a9faf0-39d3-4aa7-91c6-79683d2ba8af","resolution":{"observed_at":"2026-08-10T23:17:48.604751Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2311.10372","last_updated":"2024-01-08T05:41:51Z","snapshot_observed_at":"2026-08-13T05:23:21.528872Z","submitted_at":"2023-11-17T07:55:16Z","title":"A Survey of Large Language Models for Code: Evolution, Benchmarking, and Future Trends","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2311.10372","snapshot_observed_at":"2026-08-10T23:17:48.608997Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":31,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.608997Z"},"links":{"cited_paper":"/paper/2311.10372","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:fef3f1e1340e8fb586cf38a76a661af294541034f08b1e68f4d8c855e3c2af17","observation_id":"ffcc50a6-1da7-4085-ab9b-7176051bb317","resolution":{"observed_at":"2026-08-10T23:17:48.608997Z","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-10T23:17:48.613241Z","title":"online\" 'onlinestring :=","venue":null,"work_id":null,"year":null},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":32,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.613241Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:7f48c6a54e6e4349fb57b77d06db40cd74e6a65750d3684ae88cf15fb7e98980","observation_id":"99f1cda2-c20a-4fe5-bf4e-9cb9795f139f","resolution":{"observed_at":"2026-08-10T23:17:48.613241Z","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-10T23:17:48.617881Z","title":"write newline","venue":null,"work_id":null,"year":null},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":33,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.617881Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:77cc86bbcd8160b510040fbe8f7fdd98902770c76454985a4c0fb2e5cc8490a0","observation_id":"eee1c6e5-d647-4565-b6ce-9bf9feaa30d3","resolution":{"observed_at":"2026-08-10T23:17:48.617881Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}}],"paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","latest_version":2,"primary_category":"cs.SE","snapshot_observed_at":"2026-08-13T16:22:56.102189Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement"},"reference_resolution":{"displayed":33,"state_counts":{"malformed_identifier":0,"metadata_mismatch":0,"parse_uncertain":0,"unresolved":33,"verified_exact":0,"verified_fuzzy":0},"total_outbound_references":33},"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-13T06:32:02.005865+00:00","source":"crossref"},{"observed_at":"2026-08-13T06:31:53.387327+00:00","source":"retraction_watch"}],"thesis":"As of 14 August 2026, this Paper Citation Record lists 33 of 33 outbound references and 1 inbound Pith citation observation for arXiv:2502.17442."}