Reducing Reasoning Costs: The Path of Optimization for Chain of Thought via Sparse Attention Mechanism

Libo Wang

REVIEW 5 major objections 5 minor 30 references

Reducing Reasoning Costs: The Path of Optimization for Chain of Thought via Sparse Attention Mechanism

T0 review · 5 major / 5 minor · reviewed 2026-08-12 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper argues that replacing dense attention with a sparse attention mechanism—sparsemax activation plus sparsity masks over embeddings and attention—cuts chain-of-thought reasoning cost, and reports a custom GPT answering nine linear…

desk verdict Sparse attention could be a useful lever on CoT cost, but this paper compares a black-box custom GPT against o1 Preview and never shows the proposed mechanism is active, so the central claim is unsupported. read the letter →

arxiv 2411.09111 v8 pith:D5W7QL3K submitted 2024-11-14 cs.LG

Libo Wang This is my paper · ORCID

classification cs.LG

keywords sparseattentionchainofthoughtreasoningcostsparsemaxlargelanguagemodelsinferenceefficiencylinearalgebrao1Preview

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Chain-of-thought reasoning makes large language models more accurate but expensive, because every generated reasoning step extends an already long context and standard attention re-compares every token with every other token. This paper tries to establish that replacing dense attention with a sparse attention mechanism—sparsemax activation plus sparsity masks on embeddings and attention—cuts that cost while keeping most of the reasoning benefit. The author builds a custom GPT model called GiantRabbit around the mechanism and compares it with o1 Preview on nine linear algebra questions. GiantRabbit answered in 3.5 to 5.8 seconds with correctness between 70 and 100 percent, while o1 Preview took 7 to 50 seconds with correctness between 95 and 100 percent. If the mechanism is what causes those speed differences, sparse attention would make reasoning-heavy models much cheaper to deploy.

What carries the argument

The load-bearing object is the sparse attention layer, built from: (1) a sparsity mask $M$ on the embedding matrix that zeroes out inactive dimensions; (2) sparsemax, which converts attention scores into sparse probability distributions so low-relevance tokens get exactly zero weight; (3) dynamic masks in both causal self-attention and cross-attention that restrict each token's focus before the $QK^T$ product is computed; and (4) a chain-of-thought module that updates a reasoning state step by step, with a fresh sparsity mask applied after each step. Together these pieces are meant to lower attention complexity from $O(n^2)$ to $O(n)$ or $O(n \log n)$ while preserving the step-by-step reasoning that chain-of-thought provides.

What would settle it

Train or obtain an open-weights model with the proposed sparse attention and run the same nine linear algebra questions with the sparse masks enabled and disabled, keeping everything else fixed. If disabling sparsity does not increase runtime or chain-of-thought length, or if the attention maps contain no true zeros, then the cost reduction is not caused by the proposed mechanism.

Watch

Extended reading notes

Core claim

The paper's central claim is that a transformer in which attention weights are computed by sparsemax rather than softmax, and in which sparsity masks over embeddings, self-attention, and cross-attention force each token to attend only to a few relevant tokens, can run chain-of-thought reasoning at a fraction of the usual cost. According to the author, this reduces the attention complexity from $O(n^2)$ to $O(n)$ or $O(n \log n)$ and also shortens the chain of thought itself. The supporting experiment compares GiantRabbit, a custom GPT said to be trained with this mechanism, against o1 Preview on nine linear algebra problems: GiantRabbit needed 3.5–5.8 seconds per question and scored 70–100 percent, while o1 Preview needed 7–50 seconds and scored 95–100 percent. The author concludes from these numbers that sparse attention effectively reduces the cost of chain-of-thought reasoning.

Load-bearing premise

The load-bearing premise is that GiantRabbit actually runs the sparse attention mechanism the paper describes, but the paper offers no implementation, weights, or ablation to verify this, so if the custom GPT's speed comes from something else—model size, prompting, or API luck—the central claim collapses.

Editorial extensions

If this is right

If the measured speed-up comes from sparsity, serving reasoning models becomes cheaper per query because the dominant quadratic attention cost is replaced by near-linear cost.
Shorter chain-of-thought lengths directly reduce the number of tokens a model must generate, cutting latency and token-based billing.
The accuracy drop from the 95–100% band to the 70–100% band means sparse attention is a tunable trade-off, not a free improvement; the sparsity factor and mask strategy set where on that curve a deployment lands.
Because the changes are confined to the attention and embedding layers, the mechanism could be added to existing encoder-decoder reasoning models without redesigning the rest of the stack.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The speed gap reported is so large that it likely reflects more than the attention mechanism—model size, prompting, and API load differ between GiantRabbit and o1 Preview—so the paper's own data cannot by itself isolate sparse attention's contribution.
If sparsity is the active ingredient, then the cost problem of chain-of-thought is not the reasoning steps themselves but the dense attention over the accumulating context; sparse attention would make extended reasoning traces of hundreds of steps affordable.
A natural test is to run the proposed masks and sparsemax on an open-weights model and compare dense versus sparse versions on the same questions; that would show whether exact-zero attention weights appear and whether runtime follows the sparsity factor.
The dynamic-masking idea, which the paper sketches but does not evaluate separately, could be combined with token pruning or retrieval to make the sparsity pattern adapt to each reasoning step rather than being fixed.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

First thing to know: the central claim is not demonstrated. The paper says a custom GPT called GiantRabbit was 'trained with the sparse attention mechanism as the core' and then compares it against o1 Preview on nine linear algebra questions. But there is no evidence that GiantRabbit implements the sparsemax-plus-masks described in Section II.B. Custom GPTs are a hosted configuration layer; you cannot replace softmax with sparsemax or insert those masks via prompt engineering. So every speed and CoT-length difference is about two different models, not about sparse attention.

What the paper does well: it names a real problem—chain-of-thought inference cost—and it cites the relevant background (sparsemax, Reformer, Nyströmformer). The limitations section is honest about the model mismatch and API latency. That is credit where due.

The soft spots are substantial. The proposed 'new attention mechanism' is, by the paper's own equations, sparsemax attention with causal and cross masks—both well established. There is no ablation isolating sparsity, no error bars, and accuracy scoring is never defined. Section V contains tables about 'ADR' and 'TDR' that have nothing to do with the experiment, which reads like leftover material from another draft. The appendix says the exam is from 'Stanford MATH 113' but the actual questions are from MIT 18.06. Several equations in Section II.B are garbled. No code, weights, or API endpoint is provided, so there is no way to verify the architecture claim even post hoc.

None of this is a minor blemish. The load-bearing premise—that GiantRabbit runs the proposed mechanism—is unverified, and the comparison is confounded. The paper is not a serious candidate for peer review in its current form. I would desk reject it. The underlying question (can sparse attention shorten CoT without hurting accuracy?) is worth exploring, and a proper study would need a controllable open-source model or at least a verifiable implementation with ablations. But this manuscript does not deliver that.

Referee Report

5 major / 5 minor

Summary. The paper proposes a sparse attention mechanism intended to reduce the chain-of-thought (CoT) reasoning cost of large language models. The method description in Section II introduces sparsemax-based attention, sparsity masks, and a dynamic masking strategy, and claims to reduce attention complexity from O(n²) to O(n) or O(n log n). The experimental section compares a custom GPT called "GiantRabbit" against OpenAI's o1 Preview on nine linear algebra questions from MIT OpenCourseWare, reporting lower reasoning time and shorter CoT length for GiantRabbit with slightly lower accuracy. The paper concludes that sparse attention effectively reduces CoT reasoning costs.

Significance. If the claimed result were rigorously established, it would be a practically relevant empirical contribution: demonstrating that a sparse-attention transformer can preserve most reasoning accuracy while significantly cutting CoT inference time. The paper also correctly identifies a real cost bottleneck in CoT reasoning and cites relevant sparse-attention work. However, the manuscript provides no reproducible architecture, no implementation, no ablation, and no evidence that the tested system actually executes the proposed sparse attention computation. The empirical comparison is also confounded by base-model, version, and API differences. The claimed result is therefore not currently supported in a way that would advance the field beyond existing sparse-attention literature.

major comments (5)

[Section III and Section IV] The central claim that sparse attention reduces CoT cost requires that the system named GiantRabbit actually implement the SparseAttention computation of Section II.B (sparsemax, sparsity masks M, dynamic masks M_t, cross/self masks). The manuscript never demonstrates this. Custom GPTs are a hosted configuration layer over an API model (GPT-4 Turbo); they do not allow replacing softmax with sparsemax or inserting the proposed masks into the attention heads. A GitHub repository cannot retroactively verify what code served API responses during the experiment. Therefore the latency and CoT-length measurements cannot be causally attributed to the proposed sparse attention mechanism.
[Section IV and Section VI] The comparison between GiantRabbit (GPT-4 Turbo) and o1 Preview differs in base model, model version, knowledge cutoff, prompt formulation, and likely decoding configuration. Section VI acknowledges that these differences interfere with the results, yet Section VII ignores this and states that the experimental results 'prove' the effectiveness of sparse attention. With no control for these confounds, the observed speed differences cannot be uniquely ascribed to any specific architectural component.
[Section II.B] The mathematical presentation of the proposed method is not reproducible from the text. Several displayed equations are garbled or incomplete (e.g., the sparsemax attention formula and the final decoder equation), the definition of the sparsity mask M in terms of the set S and sparsity factor α is not fully specified, and the claimed complexity reduction from O(n²) to O(n) is asserted without a precise statement of which attention variant is used. These omissions prevent a reader from implementing or verifying the architecture.
[Section V] Tables 1 and 2 report quantitative metrics labeled ADR and TDR for 'mechanical synthesis data' and 'environmental synthesis data' with quantities such as sample efficiency, adaptation speed, robustness, policy stability, and domain gap. None of these terms, frameworks, or datasets are defined anywhere in the method or experiment sections, and they appear unrelated to the sparse attention mechanism or the linear algebra benchmark. This uncorroborated material undermines the coherence of the results section and should be removed or fully explained.
[Section IV] The experimental evidence consists of nine questions with no reported variance, no repeated trials, and no statistical testing. The accuracy values (70%-100% for GiantRabbit) are based on an undefined scoring procedure, and the statement that 'abnormal data' caused by API or network delays were excluded is not accompanied by any exclusion criteria. These omissions make it impossible to assess whether the reported differences in reasoning time and CoT length are statistically meaningful.

minor comments (5)

[Section I] The sentence describing the quadratic growth of attention complexity contains typographical errors: 'will grow at the rate of quadrature' and the duplicated 'will grow at the rate of quadratic of n' should be corrected to a single, precise statement.
[Section III vs. Appendix 1] Section III states the nine questions come from 'Stanford University's MATH 113 Linear Algebra (Exam 1) in the fall of 2018,' while Appendix 1 identifies the source as MIT OCW 18.06 Quiz from March 1, 2010. These descriptions are inconsistent and should be reconciled.
[Section V] The section is labeled 'RESULTS' and contains Tables 1–2, which are also numbered as 'Table 1' in the Appendix; the duplicate numbering and undefined ADR/TDR terminology should be fixed.
[Section II.B] The notation in the equations is not introduced consistently: for example, the variables Q, K, V, and S are defined only loosely, and the symbol ⊙ is used without explaining that it denotes elementwise multiplication in this context.
[Abstract and Section VII] The conclusion uses the word 'prove' in a context where the evidence is a small, uncontrolled observational comparison; a more cautious formulation such as 'suggests' or 'indicates' would better match the experimental design.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: the paper's derivation contains no fitted-parameter feedback or self-citation chain; its central weakness is an unverified implementation attribution, which is a verification gap rather than circularity.

full rationale

The paper's claimed derivation chain runs from standard sparse-attention equations (sparsemax, causal and cross-attention masks, sparse embedding) in Section II to a benchmark comparison in Sections III-IV, and finally to the conclusion that sparse attention reduces chain-of-thought cost. Tracing the dependency structure, no output quantity is fed back into the mechanism: no parameter is fitted to the MIT OpenCourseWare results and then renamed as a prediction; the benchmark is external; and no inference is justified by a prior publication of the author. The mechanism equations are standard definitions (sparsemax from Martins & Astudillo, 2016; causal and cross-attention masks), so the architecture section is not a renaming of the empirical result. The paper's real weakness is that Section III asserts, but does not verify, that the custom GPT 'GiantRabbit' actually implements the Section II sparse attention computation; since custom GPTs are a prompt-configuration layer on GPT-4 Turbo, the measured latency and chain-of-thought length cannot be causally attributed to the proposed masks or sparsemax without additional evidence. That is a load-bearing evidence gap in the experimental claim, but it is not a circular definition: the sparse-attention mechanism is not defined in terms of the measured outcome, nor is the outcome derived from the mechanism by construction. Under the requirement to exhibit a specific reduction (Equation X = Equation Y, or a fitted parameter reported as a prediction), no circular step can be quoted, so the circularity score is 0.

Assumptions & free parameters 1 free parameters · 4 assumptions · 1 invented entities

This ledger reflects the paper's lack of explicit parameters: only the sparsity factor alpha is introduced and never set or tuned. The main axioms are standard transformer assumptions and the unverified premise that the custom GPT implements the architecture. The only invented entity is the black-box model GiantRabbit, which has no public artifact.

free parameters (1)

sparsity factor alpha
Introduced in Section II.B to control which embedding dimensions are active; no value, tuning procedure, or ablation is reported.

assumptions (4)

standard math Standard transformer components (attention, residual connections, layer norm, feed-forward) work as in Vaswani et al. (2017).
Section II.A assumes these components without proof or modification.
domain assumption Sparsemax attention with masking reduces complexity from O(n^2) to O(n) or n log n while preserving accuracy.
Section II.B cites Kitaev et al. (2020) and Treviso et al. (2021) for this claim; it is an external empirical and theoretical assumption.
ad hoc to paper GiantRabbit, a custom GPT built with OpenAI GPTs, actually implements the proposed sparse attention architecture.
Section III states this without any evidence of an implemented sparse attention layer; the description only mentions prompt engineering and 'trained with custom GPTs'.
domain assumption Chain-of-thought reasoning can be decomposed into stepwise state updates through a sparse multi-head attention and feed-forward network.
Section II.B postulates this recurrence without theoretical justification or validation.

invented entities (1)

GiantRabbit
purpose: The model claimed to embody the proposed sparse attention mechanism and serve as the experimental subject.
No public model, weights, or reproducible construction procedure is given; it is described only as a custom GPT, so there is no external falsifiable handle.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Reducing Reasoning Costs: The Path of Optimization for Chain of Thought via Sparse Attention Mechanism." pith.science (2026). https://pith.science/paper/D5W7QL3K

@misc{pith2026241109111,
  author       = {Pith},
  title        = {Pith review of: Reducing Reasoning Costs: The Path of Optimization for Chain of Thought via Sparse Attention Mechanism},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/D5W7QL3K}},
  note         = {Machine review of arXiv:2411.09111}
}

read the original abstract

In order to address the chain of thought in the large language model inference cost surge, this research proposes to use a sparse attention mechanism that only focuses on a few relevant tokens. The researcher constructed a new attention mechanism and used GiantRabbit trained with custom GPTs as an experimental tool. The experiment tested and compared the reasoning time, correctness score and chain of thought length of this model and o1 Preview in solving the linear algebra test questions of MIT OpenCourseWare. The results show that GiantRabbit's reasoning time and chain of thought length are significantly lower than o1 Preview. It verifies the feasibility of sparse attention mechanism for optimizing chain of thought reasoning. Detailed architectural details and experimental process have been uploaded to Github, the link is:https://github.com/brucewang123456789/GeniusTrail.git.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

30 extracted references · 18 canonical work pages

[1]

Condevaux, C., & Harispe, S. (2023). Lsg attention: Extrapolation of pretrained transformers to long sequences. In Pacific-Asia Conference on Knowledge Discovery and Data Mining (pp. 443-454). Cham: Springer Nature Switzerland

work page 2023
[2]

Frantar, E., & Alistarh, D. (2023). Sparsegpt: Massive language models can be accurately pruned in one-shot. In International Conference on Machine Learning (pp. 10323-10337). PMLR

work page 2023
[3]

R., & Goldberg, Y

Geva, M., Caciularu, A., Wang, K. R., & Goldberg, Y. (2022). Transformer feed-forward layers build predictions by promoting concepts in the vocabulary space. arXiv preprint arXiv:2203.14680

arXiv 2022
[4]

Guan, Y., Li, Z., Leng, J., Lin, Z., & Guo, M. (2022). Transkimmer: Transformer learns to layer-wise skim. arXiv preprint arXiv:2205.07324

work page Pith review arXiv 2022
[5]

Jin, M., Yu, Q., Shu, D., Zhao, H., Hua, W., Meng, Y., ... & Du, M. (2024). The impact of reasoning step length on large language models. arXiv preprint arXiv:2401.04925

arXiv 2024
[6]

Khot, T., Trivedi, H., Finlayson, M., Fu, Y., Richardson, K., Clark, P., & Sabharwal, A. (2022). Decomposed prompting: A modular approach for solving complex tasks. arXiv preprint arXiv:2210.02406

arXiv 2022
[7]

Kitaev, N., Kaiser, Ł., & Levskaya, A. (2020). Reformer: The efficient transformer. arXiv preprint arXiv:2001.04451

arXiv 2020
[8]

Li, Y., Li, Z., Wang, P., Li, J., Sun, X., Cheng, H., & Yu, J. X. (2023). A survey of graph meets large language model: Progress and future directions. arXiv preprint arXiv:2311.12399

arXiv 2023

Show all 30 references

[9]

Li, Z., Liu, H., Zhou, D., & Ma, T. (2024). Chain of thought empowers transformers to solve inherently serial problems. arXiv preprint arXiv:2402.12875

2024 arXiv
[10]

L., Ho, C

Liu, C. L., Ho, C. T., & Wu, T. C. (2024). Custom GPTs enhancing performance and evidence compared with GPT-3.5, GPT-4, and GPT-4o? A study on the emergency medicine specialist examination. In Healthcare (Vol. 12, No. 17, p. 1726). MDPI

2024
[11]

Martins, A., & Astudillo, R. (2016). From softmax to sparsemax: A sparse model of attention and multi-label classification. In International conference on machine learning (pp. 1614-1623). PMLR

2016
[12]

Mitra, C., Huang, B., Darrell, T., & Herzig, R. (2024). Compositional chain-of-thought prompting for large multimodal models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (pp. 14420-14431)

2024
[13]

A., & Field, D

Olshausen, B. A., & Field, D. J. (2004). Sparse coding of sensory inputs. Current opinion in neurobiology, 14(4), 481-487

2004
[14]

OpenAI. (2024). Introducing OpenAI o1-preview. https://openai.com/index/introducing-openai-o1-previe w/

2024
[15]

OpenAI. (2024). Learning to Reason with LLMs. Available online: https://openai.com/index/learning-to-reasonwith-llms (accessed on 18 October 2024)

2024
[16]

Raiaan, M. A. K., Mukta, M. S. H., Fatema, K., Fahad, N. M., Sakib, S., Mim, M. M. J., ... & Azam, S. (2024). A review on large Language Models: Architectures, applications, taxonomies, open issues and challenges. IEEE Access

2024
[17]

Ramesh, G., Dou, Y., & Xu, W. (2024). GPT-4 Jailbreaks Itself with Near-Perfect Success Using Self-Explanation. arXiv preprint arXiv:2405.13077

2024 arXiv
[18]

Rego, J., Watkins, Y., Kenyon, G., Kim, E., & Teti, M. (2023). A novel model of primary visual cortex based on biologically plausible sparse coding. In Applications of Machine Learning 2023 (Vol. 12675, pp. 156-161). SPIE

2023
[19]

Treviso, M., Góis, A., Fernandes, P., Fonseca, E., & Martins, A. F. (2021). Predicting attention sparsity in transformers. arXiv preprint arXiv:2109.12188

2021 arXiv
[20]

Vaswani, A. (2017). Attention is all you need. Advances in Neural Information Processing Systems

2017
[21]

& Zhou, D

Wei, J., Wang, X., Schuurmans, D., Bosma, M., Xia, F., Chi, E., ... & Zhou, D. (2022). Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35, 24824-24837

2022
[22]

Xiong, Y., Zeng, Z., Chakraborty, R., Tan, M., Fung, G., Li, Y., & Singh, V. (2021). Nyströmformer: A nyström-based algorithm for approximating self-attention. In Proceedings of the AAAI Conference on Artificial Intelligence (Vol. 35, No. 16, pp. 14138-14148)

2021
[23]

Yun, J., Kim, M., & Kim, Y. (2024). Focus on the core: Efficient attention via pruned token compression for document classification. arXiv preprint arXiv:2406.01283

2024 arXiv
[24]

Zheng, T., Yan, G., Li, H., Zheng, W., Shi, W., Zhang, Y., ... & Wu, D. (2023). A microstructure estimation Transformer inspired by sparse representation for diffusion MRI. Medical Image Analysis, 86, 102788

2023
[25]

Zheng, W., Lu, S., Yang, Y., Yin, Z., & Yin, L. (2024). Lightweight transformer image feature extraction network. PeerJ Computer Science, 10, e1755

2024
[26]

& Liu, T

Zhong, T., Liu, Z., Pan, Y., Zhang, Y., Zhou, Y., Liang, S., ... & Liu, T. (2024). Evaluation of openai o1: Opportunities and challenges of agi. arXiv preprint arXiv:2409.18486. APPENDIX 1 This research selects and excerpts exam questions from Exam 1 of MIT OpenCourseWare - Li...

2024
[27]

Forward elimination changes Ax = b to a row reduced Rx = d: the complete solution is (a)Wat is the 3 by 3 reduced row echelon matrix R and what is d? (b)If the process of elimination subtracted 3 times row 1 from row 2 and then 5 times row 1 from row 3, what matrix connects R ...
[28]

All combinations of the four columns

Suppose A is the matrix (a)Find all special solutions to Ax = 0 and describe in words the whole nullspace of A. (b) Describe the column space of this particular matrix A. “All combinations of the four columns” is not a suﬃcient answer. (c) What is the reduced row echelon form ...
[29]

Then the equation Ax = b (always / sometimes but not always) has (a unique solution / many solutions / no solution)

Circle the words that correctly complete the following sentence: (a) Supose a 3 by 5 matrix A has rank r = 3. Then the equation Ax = b (always / sometimes but not always) has (a unique solution / many solutions / no solution). (b) What is the column space of A? Describe the nu...
[30]

All combinations of the four columns

Suppose that A is the matrix (a) Explain in words how knowing all solutions to Ax = b decides if a given vector b is in the column space of A. (b) Is the vector b = in the column space of A? Section B: Conversion of Computer Language Each sub-question within an exam question c...

Pith tools

Reviewed August 12, 2026 · model on record in the stance chip above.

[1] [1]

Condevaux, C., & Harispe, S. (2023). Lsg attention: Extrapolation of pretrained transformers to long sequences. In Pacific-Asia Conference on Knowledge Discovery and Data Mining (pp. 443-454). Cham: Springer Nature Switzerland

work page 2023

[2] [2]

Frantar, E., & Alistarh, D. (2023). Sparsegpt: Massive language models can be accurately pruned in one-shot. In International Conference on Machine Learning (pp. 10323-10337). PMLR

work page 2023

[3] [3]

R., & Goldberg, Y

Geva, M., Caciularu, A., Wang, K. R., & Goldberg, Y. (2022). Transformer feed-forward layers build predictions by promoting concepts in the vocabulary space. arXiv preprint arXiv:2203.14680

arXiv 2022

[4] [4]

Guan, Y., Li, Z., Leng, J., Lin, Z., & Guo, M. (2022). Transkimmer: Transformer learns to layer-wise skim. arXiv preprint arXiv:2205.07324

work page Pith review arXiv 2022

[5] [5]

Jin, M., Yu, Q., Shu, D., Zhao, H., Hua, W., Meng, Y., ... & Du, M. (2024). The impact of reasoning step length on large language models. arXiv preprint arXiv:2401.04925

arXiv 2024

[6] [6]

Khot, T., Trivedi, H., Finlayson, M., Fu, Y., Richardson, K., Clark, P., & Sabharwal, A. (2022). Decomposed prompting: A modular approach for solving complex tasks. arXiv preprint arXiv:2210.02406

arXiv 2022

[7] [7]

Kitaev, N., Kaiser, Ł., & Levskaya, A. (2020). Reformer: The efficient transformer. arXiv preprint arXiv:2001.04451

arXiv 2020

[8] [8]

Li, Y., Li, Z., Wang, P., Li, J., Sun, X., Cheng, H., & Yu, J. X. (2023). A survey of graph meets large language model: Progress and future directions. arXiv preprint arXiv:2311.12399

arXiv 2023