{
  "schema_version": 1,
  "builder_plan": {
    "scenario": "Your self-hosted model spends too long generating answers token by token.",
    "change": "Check whether a compatible draft model and serving integration exist before renting compute.",
    "baseline": "The same target with speculation off, then your existing drafter if you have one.",
    "steps": [
      "Locate the paper's implementation and check its license, model support, data needs, and hardware requirements. Stop here if you cannot obtain the required artifacts.",
      "Save a small set of representative product tasks and expected outcomes. Keep evaluation tasks out of any training or tuning, and choose quality and cost limits before running.",
      "Run the baseline and the proposed change on identical inputs. Keep other settings fixed and repeat paired runs to expose variation.",
      "Save per-task outputs, failures, timings, and all usage costs. Review regressions before expanding the test."
    ],
    "measure": "Accepted draft length, tokens per second, tail latency, output quality, and total GPU cost.",
    "decision": "Keep the change only if it meets your preselected quality and latency limits and improves the metric you care about after setup and operating costs. Otherwise retain the baseline. This is an exploration plan, not a validated recommendation."
  },
  "builder_review": null,
  "arxiv_id": "2608.20530",
  "title": "LiLiCorr: Lightweight Likelihood Correlation of Parallel Drafts for Speculative Decoding",
  "summary": "LiLiCorr replaces raw block-parallel drafting (e.g., DFlash), whose per-position marginals produce jointly incoherent token blocks, with a lightweight head that scores adjacent candidate pairs via in/out vector cosine similarity and a greedy walk to select a coherent draft path. Costs include an extra network pass and batched pairwise scoring (about 2.8% of per-block latency), plus co-training the drafter with LiLiCorr, which adds a training step beyond simply deploying a pretrained drafter. It can fail if the reader does not already use a diffusion-style block drafter (the method presupposes one), if co-training is infeasible under the compute budget, or on workloads whose distributions differ from the training setup, since gains are acceptance-length dependent and workload-specific.",
  "rationale": "The technique is a low-overhead inference-time addition, but it presupposes a DFlash-style block drafter and a co-training stage, so the reader must validate acceptance-length gains on their own model and workload before adopting it in production.",
  "technique": "Likelihood-correlation scoring of block-parallel draft tokens",
  "family": "decodificacao_especulativa",
  "recommendation": "testar",
  "published": "2026-08-20",
  "as_of": "2026-10-18",
  "editorial_status": "indexed",
  "source_url": "https://arxiv.org/abs/2608.20530",
  "independent_implementations": 0,
  "total_implementations": 0,
  "stars": 0,
  "citations": 0,
  "claims": [
    {
      "claim_id": "claim-01",
      "statement": "LiLiCorr replaces raw block-parallel drafting (e.g., DFlash), whose per-position marginals produce jointly incoherent token blocks, with a lightweight head that scores adjacent candidate pairs via in/out vector cosine similarity and a greedy walk to select a coherent draft path. Costs include an extra network pass and batched pairwise scoring (about 2.8% of per-block latency), plus co-training the drafter with LiLiCorr, which adds a training step beyond simply deploying a pretrained drafter. It can fail if the reader does not already use a diffusion-style block drafter (the method presupposes one), if co-training is infeasible under the compute budget, or on workloads whose distributions differ from the training setup, since gains are acceptance-length dependent and workload-specific.",
      "basis": "inferred",
      "result": "",
      "baseline": "",
      "conditions": "",
      "source_url": "https://arxiv.org/abs/2608.20530",
      "source_page": null,
      "source_excerpt": ""
    },
    {
      "claim_id": "claim-02",
      "statement": "Raises acceptance length by 9-19% over the vanilla DFlash drafter, with the scoring head accounting for about 2.8% of per-block latency; highest throughput in 70 of 72 benchmark settings against DFlash and two concurrent coherence-restoring methods.",
      "basis": "inferred",
      "result": "",
      "baseline": "",
      "conditions": "",
      "source_url": "https://arxiv.org/abs/2608.20530",
      "source_page": null,
      "source_excerpt": ""
    }
  ],
  "exposure_map": [
    {
      "dimension": "quality",
      "basis": "not_evaluated",
      "finding": "",
      "interpretation": "",
      "limitation": "",
      "next_check": "",
      "source_url": "",
      "source_page": null,
      "source_excerpt": ""
    },
    {
      "dimension": "compute",
      "basis": "not_evaluated",
      "finding": "",
      "interpretation": "",
      "limitation": "",
      "next_check": "",
      "source_url": "",
      "source_page": null,
      "source_excerpt": ""
    },
    {
      "dimension": "latency",
      "basis": "not_evaluated",
      "finding": "",
      "interpretation": "",
      "limitation": "",
      "next_check": "",
      "source_url": "",
      "source_page": null,
      "source_excerpt": ""
    },
    {
      "dimension": "operations",
      "basis": "not_evaluated",
      "finding": "",
      "interpretation": "",
      "limitation": "",
      "next_check": "",
      "source_url": "",
      "source_page": null,
      "source_excerpt": ""
    },
    {
      "dimension": "compatibility",
      "basis": "not_evaluated",
      "finding": "",
      "interpretation": "",
      "limitation": "",
      "next_check": "",
      "source_url": "",
      "source_page": null,
      "source_excerpt": ""
    },
    {
      "dimension": "security",
      "basis": "not_evaluated",
      "finding": "",
      "interpretation": "",
      "limitation": "",
      "next_check": "",
      "source_url": "",
      "source_page": null,
      "source_excerpt": ""
    },
    {
      "dimension": "data_and_training",
      "basis": "not_evaluated",
      "finding": "",
      "interpretation": "",
      "limitation": "",
      "next_check": "",
      "source_url": "",
      "source_page": null,
      "source_excerpt": ""
    },
    {
      "dimension": "reproducibility",
      "basis": "not_evaluated",
      "finding": "",
      "interpretation": "",
      "limitation": "",
      "next_check": "",
      "source_url": "",
      "source_page": null,
      "source_excerpt": ""
    }
  ],
  "risks": [],
  "minimum_test": [],
  "open_questions": [],
  "independent_tests": [],
  "lab_reproductions": [],
  "report_available": false,
  "validation_tier": "unknown",
  "evidence_tier": "unknown",
  "infrastructure_basis": "unknown",
  "equations": [
    {
      "anchor": "S3.E1",
      "label": "(1)",
      "section": "3 Method",
      "role": "proposed_method",
      "latex": "\\phi^{\\mathrm{p}}(s,k,k^{\\prime})=\\sigma\\,\\cossim(\\mathbf{o}_{s,k},\\,\\mathbf{i}_{s+1,k^{\\prime}})~~~~\\mbox{for}~~~s=0,\\dots,B-2,~~~1\\leq k\\leq K_{s},~1\\leq k^{\\prime}\\leq K,",
      "mathml": "<math display=\"block\"><mrow><mrow><mrow><mrow><msup><mi>ϕ</mi><mi>p</mi></msup><mo lspace=\"0em\" rspace=\"0em\">​</mo><mrow><mo stretchy=\"false\">(</mo><mi>s</mi><mo>,</mo><mi>k</mi><mo>,</mo><msup><mi>k</mi><mo>′</mo></msup><mo stretchy=\"false\">)</mo></mrow></mrow><mo>=</mo><mrow><mi>σ</mi><mo lspace=\"0.337em\" rspace=\"0em\">​</mo><mrow><mi>cos</mi><mo>⁡</mo><mrow><mo stretchy=\"false\">(</mo><msub><mi>𝐨</mi><mrow><mi>s</mi><mo>,</mo><mi>k</mi></mrow></msub><mo rspace=\"0.337em\">,</mo><msub><mi>𝐢</mi><mrow><mrow><mi>s</mi><mo>+</mo><mn>1</mn></mrow><mo>,</mo><msup><mi>k</mi><mo>′</mo></msup></mrow></msub><mo stretchy=\"false\">)</mo></mrow></mrow></mrow></mrow><mspace width=\"1.32em\"></mspace><mrow><mrow><mtext>for</mtext><mo lspace=\"0.990em\" rspace=\"0em\">​</mo><mi>s</mi></mrow><mo>=</mo><mn>0</mn></mrow><mo>,</mo><mi mathvariant=\"normal\">…</mi><mo>,</mo><mrow><mi>B</mi><mo>−</mo><mn>2</mn></mrow><mo rspace=\"1.157em\">,</mo><mrow><mn>1</mn><mo>≤</mo><mi>k</mi><mo>≤</mo><msub><mi>K</mi><mi>s</mi></msub></mrow><mo rspace=\"0.497em\">,</mo><mrow><mn>1</mn><mo>≤</mo><msup><mi>k</mi><mo>′</mo></msup><mo>≤</mo><mi>K</mi></mrow></mrow><mo>,</mo></mrow></math>",
      "context": "tended node is then fused with a projection of the target’s hidden state that produced the last verified token: the candidate’s own state, that projection, and their elementwise product are concatenated and mapped back to the node width by a single layer. Though one vector common to the whole block, it enters every candidate separately, so that the verifier’s view of the context, and not the drafter’s alone, shapes each of them. For each node LiLiCorr emits two vectors in , an out vector and an in vector , each normalized to unit norm. The dimension is given in Appendix A. The anchor, which precedes the first slot, is encoded far more thinly: the anchor projection itself, mapped by its own head to one further out vector. Indexing the anchor as slot , we write this vector . Adjacent slots and are then coupled by a single matching term, the cosine similarity between the out and in vectors:",
      "headline": "",
      "explanation": "",
      "objective": "",
      "symbols": {},
      "evidence": "",
      "evidence_url": "",
      "source_url": ""
    },
    {
      "anchor": "S3.E2",
      "label": "(2)",
      "section": "3 Method",
      "role": "proposed_method",
      "latex": "P(c_{s}\\mid c_{s-1})=\\softmax_{k}\\big(z_{s}[k]\\big),\\qquad z_{s}[k]=\\phi^{\\mathrm{p}}(s\\!-\\!1,\\,c_{s-1},\\,k),\\qquad s=1,\\dots,B-1,",
      "mathml": "<math display=\"block\"><mrow><mi>P</mi><mrow><mo stretchy=\"false\">(</mo><msub><mi>c</mi><mi>s</mi></msub><mo fence=\"true\" lspace=\"0em\" rspace=\"0em\">∣</mo><msub><mi>c</mi><mrow><mi>s</mi><mo>−</mo><mn>1</mn></mrow></msub><mo stretchy=\"false\">)</mo></mrow><mo>=</mo><msub><mi>softmax</mi><mi>k</mi></msub><mrow><mo maxsize=\"1.200em\" minsize=\"1.200em\">(</mo><msub><mi>z</mi><mi>s</mi></msub><mrow><mo stretchy=\"false\">[</mo><mi>k</mi><mo stretchy=\"false\">]</mo></mrow><mo maxsize=\"1.200em\" minsize=\"1.200em\">)</mo></mrow><mo rspace=\"2.167em\">,</mo><msub><mi>z</mi><mi>s</mi></msub><mrow><mo stretchy=\"false\">[</mo><mi>k</mi><mo stretchy=\"false\">]</mo></mrow><mo>=</mo><msup><mi>ϕ</mi><mi>p</mi></msup><mrow><mo stretchy=\"false\">(</mo><mi>s</mi><mo lspace=\"0.052em\">−</mo><mn>1</mn><mo rspace=\"0.337em\">,</mo><msub><mi>c</mi><mrow><mi>s</mi><mo>−</mo><mn>1</mn></mrow></msub><mo rspace=\"0.337em\">,</mo><mi>k</mi><mo stretchy=\"false\">)</mo></mrow><mo rspace=\"2.167em\">,</mo><mi>s</mi><mo>=</mo><mn>1</mn><mo>,</mo><mi mathvariant=\"normal\">…</mi><mo>,</mo><mi>B</mi><mo>−</mo><mn>1</mn><mo>,</mo></mrow></math>",
      "context": "A natural formulation scores each full path by summing its matching terms across the block and selects the path that maximizes this whole-chain score. We argue that this is the wrong target for speculative decoding. The global optimum may sacrifice an early slot to win a richer tail, yet under prefix acceptance that tail is never reached. Section 3.5 and Appendix E take up this comparison at decoding time. Optimizing the whole chain thus spends capacity on regions the metric never credits. We therefore score each slot locally, conditioned on the candidate committed just before it. Writing the per-slot node score of candidate <math display=\"inline\"><mi>k</mi></math> as <math display=\"inline\"><mrow><msub><mi>z</mi><mi>s</mi></msub><mo lspace=\"0em\" rspace=\"0em\">​</mo><mrow><mo stretchy=\"false\">[</mo><mi>k</mi><mo stretchy=\"false\">]</mo></mrow></mrow></math>, the chain rule factorizes the path distribution as",
      "headline": "",
      "explanation": "",
      "objective": "",
      "symbols": {},
      "evidence": "",
      "evidence_url": "",
      "source_url": ""
    },
    {
      "anchor": "S3.E8",
      "label": "(8)",
      "section": "3 Method",
      "role": "proposed_method",
      "latex": "\\hat{c}_{s}\\;=\\;\\argmax_{k}\\,z_{s}[k]\\;=\\;\\argmax_{k}\\,\\phi^{\\mathrm{p}}(s\\!-\\!1,\\,\\hat{c}_{s-1},\\,k),",
      "mathml": "<math display=\"block\"><mrow><mrow><msub><mover accent=\"true\"><mi>c</mi><mo>^</mo></mover><mi>s</mi></msub><mo lspace=\"0.558em\" rspace=\"0.558em\">=</mo><mrow><mrow><msub><mrow><mi>arg</mi><mo lspace=\"0.170em\" rspace=\"0em\">​</mo><mi>max</mi></mrow><mi>k</mi></msub><mo>⁡</mo><msub><mi>z</mi><mi>s</mi></msub></mrow><mo lspace=\"0em\" rspace=\"0em\">​</mo><mrow><mo stretchy=\"false\">[</mo><mi>k</mi><mo rspace=\"0.280em\" stretchy=\"false\">]</mo></mrow></mrow><mo rspace=\"0.558em\">=</mo><mrow><mrow><msub><mrow><mi>arg</mi><mo lspace=\"0.170em\" rspace=\"0em\">​</mo><mi>max</mi></mrow><mi>k</mi></msub><mo>⁡</mo><msup><mi>ϕ</mi><mi>p</mi></msup></mrow><mo lspace=\"0em\" rspace=\"0em\">​</mo><mrow><mo stretchy=\"false\">(</mo><mrow><mi>s</mi><mo lspace=\"0.052em\">−</mo><mn>1</mn></mrow><mo>,</mo><msub><mover accent=\"true\"><mi>c</mi><mo>^</mo></mover><mrow><mi>s</mi><mo>−</mo><mn>1</mn></mrow></msub><mo>,</mo><mi>k</mi><mo stretchy=\"false\">)</mo></mrow></mrow></mrow><mo>,</mo></mrow></math>",
      "context": "Decoding has a parallel- and a sequential stage, and the network runs only once. In the parallel stage, a single LiLiCorr pass produces every outgoing and incoming vector, including the anchor out vector. The block has <math display=\"inline\"><mrow><mi>B</mi><mo>−</mo><mn>1</mn></mrow></math> adjacent slot pairs, and within each pair every candidate is matched against every candidate in the next slot. This gives <math display=\"inline\"><msup><mi>K</mi><mn>2</mn></msup></math> comparisons for each of the <math display=\"inline\"><mrow><mi>B</mi><mo lspace=\"0.052em\">−</mo><mn>2</mn></mrow></math> interior pairs and <math display=\"inline\"><mi>K</mi></math> for the anchor pair, <math display=\"inline\"><mrow><mrow><mrow><mo stretchy=\"false\">(</mo><mrow><mi>B</mi><mo lspace=\"0.052em\">−</mo><mn>2</mn></mrow><mo stretchy=\"false\">)</mo></mrow><mo lspace=\"0em\" rspace=\"0em\">​</mo><msup><mi>K</mi><mn>2</mn></msup></mrow><mo>+</mo><mi>K</mi></mrow></math> matching terms in total. Evaluating them reduces to one matrix multiplication per slot pair, batched across the full block, which keeps the computation static in shape and well suited to kernel fusion and graph capture. In the sequential stage, the block is committed greedily from left to right: at slot <math display=\"inline\"><mi>s</mi></math> we select",
      "headline": "",
      "explanation": "",
      "objective": "",
      "symbols": {},
      "evidence": "",
      "evidence_url": "",
      "source_url": ""
    }
  ],
  "equations_status": "selected",
  "core_kind": "formula",
  "equations_fetched_at": "2026-09-18",
  "equations_source_url": "",
  "equations_source_sha256": "",
  "exposures_reviewed_at": "",
  "exposures_source_sha256": ""
}