DyVal: Dynamic Evaluation of Large Language Models for Reasoning Tasks
Authors: Kaijie Zhu
Jiaao Chen
Jindong Wang
Neil Zhenqiang Gong
Diyi Yang
Xing Xie
Venue: ICLR 2024 spotlight (2024)
Keywords: Large Language Models
Evaluation
Data Contamination
Primary area: datasets and benchmarks
TL;DR: We present a dynamic evaluation protocol for large language models that aims to mitigate data contamination and static complexity.

Abstract: Large language models (LLMs) have achieved remarkable performance in various evaluation benchmarks. However, concerns are raised about potential data contamination in their considerable volume of training corpus. Moreover, the static nature and fixed complexity of current benchmarks may inadequately gauge the advancing capabilities of LLMs. 
In this paper, we introduce DyVal, a general and flexible protocol for dynamic evaluation of LLMs. Based on our framework, we build graph-informed DyVal by leveraging the structural advantage of directed acyclic graphs to dynamically generate evaluation samples with controllable complexities. DyVal generates challenging evaluation sets on reasoning tasks including mathematics, logical reasoning, and algorithm problems. We evaluate various LLMs ranging from Flan-T5-large to GPT-3.5-Turbo and GPT-4. Experiments show that LLMs perform worse in DyVal-generated evaluation samples with different complexities, highlighting the significance of dynamic evaluation.
We also analyze the failure cases and results of different prompting methods.
Moreover, DyVal-generated samples are not only evaluation sets, but also helpful data for fine-tuning to improve the performance of LLMs on existing benchmarks.
We hope that DyVal can shed light on future evaluation research of LLMs. Code is available at: https://github.com/microsoft/promptbench.

Published as a conference paper at ICLR 2024
DYVAL: DYNAMIC EVALUATION OF LARGE LANGUAGE MODELS FOR REASONING TASKS
Kaijie Zhu';; Chen Jindong Wang', Neil Zhenqiang Gong', Diyi Yang', Xing Xie Microsoft Research, 2Georgia Tech, Duke University, "Stanford University
ABSTRACT
Large language models (LLMs) have achieved remarkable performance in vari- ous evaluation benchmarks. However, concerns are raised about potential data contamination in their considerable volume of training corpus. Moreover, the static nature and fixed complexity current benchmarks may inadequately gauge the advancing capabilities of LLMs. In this paper, we introduce Dy VAL, gen- eral and flexible protocol for dynamic evaluation of LLMss. Based on our frame- work, we build srahh-nnfrrmed VYL by leveraging the structural advantage of directed acyclic graphs to dynamically generate evaluation samples with con- trollable complexities. VY generates challenging evaluation sets on reasoning tasks including mathematics, logical reasoning, and algorithm problems. We eval- uate various LLMs ranging from Flan-T5-large to GPT-3.5-Turbe and GPT-4. Ex- periments show that I.LMs perform worse in DY VAI -generreee evaluation sam- ples with different complexities, highlighting the significance of dynamic evalua- tion. We also analyze the failure cases and results of different prompting methods. Moreover, DY VAL-generated samples are not only evaluation sets, but also helpful data for fine-tuning to improve the performance of LLMS on existing benchmarks. We hope that Dy VAL can shed light on future evaluation research of LLMs. Code is available at: https:
INTRODUCTION
Large Language Models (LLMs) have recently achieved unprecedented performance across diverse tasks (OpenAl| 2023b Bubeck et al. (223). The great endeavor have led to positive speculation on the possibility of I.LMM being precursors of artificial general intelligence, necessitating the creation of nuanced evaluations. By pinpointing gaps for improvements, evaluation becomes the bedrock that enhances the understanding of current models and ensures Al's continued progression.
Efforts to evaluate LLMs have become intensified significantly. Liang et al. (2023) introduced HELM, which offers a holistic assessment of LLM in various scenarios. Similarly, Chatbot Arena Zheng et al.) 2023) evaluates LLMs by contrasting their generated output. Other benchmarks that
have set the standard in the realm of LLM evaluations include AlpacaEval (Li al. 2023c). C-Eval
(Huang et al. 2023). ARB (Sawada et al. (203), API-Bank (Li et al. 2023a). Socket (Choi et al.
2023). and Big-Bench (bench authors, 2023). Moreover, manual experiments have emerged as a complementary approach these benchmarks, with works such as |Bubeck al. (2023) and BBng
ct al. (2023). Complementing these, human evaluators have also been instrumental in gauging the prowess of LLMs, as discussed by Ziems al. (003) and Zečević al. (2023).
Current evaluation benchmarks face two fundamental challenges. First, data contamination. Many benchmarks source their data from the Internet, causing potential overlap with the vast corpus on which LLMs are trained, leading to the debate of "Generalization vs. Memorization" (Bender et al.) 2021 Magar& & Schwartz, 2022 Carlini et al. 20033] Biderman et al. 2023): ; Are the model's 's re- sults stemming from genuine ability or just memorization of the training data? A recent example is provided by Zéčević et al.) (2023): LLMs can ambiguously deduce the conclusion that altitude in- fluences temperature based on seen data. Similarly, [Begllund et al. (2023) found that LLMs trained
Equual contribution. Contact: kaijiezhul @ eegail.com, jiaaochen @ @gatech.edu. Correspondence Jindong Wang <jindong.wan wang @ micmosoft.ccmm..

---

Published as a conference paper at ICLR 2024
on "A is B" fail to infer "B is A", which doubts the abilities of LLMs might come from memoriza- tion. Second, static dataset and fixed complexity. As LLMs progress at a rapid pace, existing datasets usually fail to match the models' ever-evolving capabilities, because the complexity level of existing henchmarks is usually static and fixed. As Dziri et al. (2023) demonstrated, while handling simple problems pretty well, L.MSs fail to solve complex problems. The inability to automatically and dynamically increase complexity levels based on existing data prevents static benchmarks from being adapted accurately select, compare, and advance LLMs. Although there are a few existing dynamic benchmarks like DynaBench (Kiela et al. 2021) and DynaBoard (Ma et al. 2021). they rely on crowd-sourcing efforts for data collection, which might be expensive and tedious.
In this paper, we introduce DY a novel, general, and flexible evaluation protocol for the dy- namic evaluation of LLMS (Sec. 3.1 The core of DYVAL to dynamically generate evaluation samples on the fly instead of collecting fixed set of data. DY consists of three components: the constraint C mod- ulate sample complexity and validity; and 3) the description function FF to translate the generated samples into natural languages. Based on this framework, we propose a graph-informed DY VAL (Sec. 3.2 Figure I to generate data using graphs. Specifically, inspired by techniques such the compiler principle (Alfred V et al., 2007) and parsing trees which decompose complexities (Klein & Manning 2003 Vinyals al.J (015)) we employ directed acyelic graphs (DAG) (Thulasiraman & Swamy 2011) to compose fundamental elements into more intricate problems, with each unit symbolized graph node. The extendable and stochastic nature of graph generation effectively regulates the complexity levels. Additionally, the hierarchical attributes of graphs suit them for multi-step inferential tasks like logics. Problems generated by DYVAL not only require profound understanding of problem solving rather than simple memorization but also echo the human ap- proach to incremental problem-solvin and solution derivation. Being general and flexible, DYVAL co-exists and co-evolves with existing benchmarks for better LLMs evaluation and evolution.
1) the generation algorithm G to generate test samples with diversities; 2)
We leverage DAL to synthesize 7 reasoning task encompassing: (1) Mathematics: arithmetic and linear equations; (2) Logical reasoning: boolean, deductive, and abductive logic; (3) Algorithm:
reachability and maximum sum path problems. We then re-examine the statc-of-the-art LLMs rang-
ing from Flan-T5 Maan-T--lrgee (Chung et al. (0022). phi-1.5 (Li et al. (023d), Xwin-13B (Team] 2023),
(Chiang et al., 2023). WizardMath- 13B (Luo et al., 2023), to GPT-3.55 Turbo (OpenAll 2023a) and GPT-4 [ with Dy-
-lama2-13B--a
TTouvron et al. 2023). 1ouuna-1BB-ve
VAL. We also test with recent prompting techniques including Few-shot (Brown et al. 2020). CoT
(Wei et al. 2022), Least to Most prompting (Zhou al. 2023b), Automatic Prompt Engineering (Zhou et al. 2023d), and Skills-in-Contex prompting (Chen et al., 2023). Finally, we perform human study involving 82 human evaluators for comparison and fine-tuning experiments using Dy- VAL-generated evaluation samples. Furthermore, experiments on existing benchmarks also show that fine-tuning LLMs with data generated by DY could directly improve models' abilities with- out extra careful collection of training data (Zhou et al.) 2023a). We further show the flexibility of VAL by extending it to natural language tasks in Appendix H Our key findings are:
Results on DYVAL evaluation are not always consistent with those existing benchmarks, indicating possible low training data quality and/or data contamination of existing LLMs (Sec. 4.2 For instance, 1.5- WizardMath-133. and Xwin-13B perform poorly on DYVAL while claiming huge improvements on existing benchmarks.
As difficulty increases, LLMs tend to perform worse and their performance gap becomes larger, emphasizing the lack of compositionality of current LLMs and the importance of evolving complexity evaluations (Sec. 4.2)
Our error analysis based DY evaluation exhibits various failure patterns which shed light on how to further improve L.MMs. (Sec. 4.3)
No prompt engineering methods can perform best in all of our evaluation sets; and larger model sizes tend to achieve better performances (Sec. (444.
VAL can further be utilized to generate training data to improve the abilities of LLMs.
(Sec. 5). For instance, fine-tuning the Llama2 models with VAL generated data demon- strates enhanced results on 6 existing benchmarks.
We choose reasoning tasks mainly due to (1) the intrinsic connection between reasoning proficiency and intelligence; (2) the notable progress L.MSs have achieved in reasoning-centrie tasks (Sawada et al. 2023). Note that VAL. could also he applied to existing benchmarks create new and harder evaluation data.
2

---

Published as a conference paper at ICLR 2024
To sum up. this paper makes the following contributions:
A dynamic evaluation protocol. DYVAL is dynamic evaluation protocol designed to gener- ate test samples dynamically, mitigating the issues of data contamination and static complexity. A graph-informed VAL algorithm for evaluation of the reasoning abilities of LLMs. We use DAGs to compose 7 reasoning problems from mathematics, logical reasoning to algorithms.
Extensive experiments and analysis. We conduct extensive experiments provide insights for evaluating and improving LLMs.
2 RELATED WORK
Evaluating LLMs.
While neural networks recognized the universal function approximators
(Cybenko 1989) with remarkable data fitting capabilities (Zhang et al. [021 Arpit et al. (017), de-
bates (Bender et al.
2021
Zhang et al., 2021 Tänzer al. 2022 Magar & Schwartz 2022 Carlini
ct al.
2023 Wu et al. 2023 Tang et al. [2023] Zečević et al.) [023] Kocon et al., 2023] Schaeffer
2023
Biderman al. 2023
Zhu & Li 2023) persist regarding the true nature LLMs' general-
ization abilities. The growing prominence of LLMs necessitates rigorous benchmarks (Hendrycks)
al.
2021 Li et al., 2023b Zhong al. 2023 HuggingFace (0023). Recent trends include: (1)
human-centred evaluations (Gao et al.] [022 Ribeiro & Lundberg] (2022). (2) crowd-sourced testing
(Kiela et al.
2021 Ma et al. 2021), ), and (3) specialized task challenges (Liang et al., [003 Tian
et al. 2018: Ribeiro et al. 2020 bench authors 2023). Complementing with these, our DY VAL
introduces a dynamic evaluation system, consistently relevant in the swiftly evolving landscape of
AI. Although Krause al. (2018) introduced the term "dynamic evaluation", our DY differs considerably in its approach and goals. Specifically, reasoning is widely recognized as the core of both human and AI. Our focus on constructing reasoning tasks mirrors the intricate and multi-step nature of human reasoning (Brody 1999, Lohman & Lakin 2011] (Saaada et al. 2023), building reasoning benchmarks is a critical step help LLMs towards intelligence.
Data Contamination. Researchers start to realize the potential data contamination problem in LLMs (Lovin) 2023 Chowdhuri al.] 2023 Bender et al. [222]] Kocon al. 2023). 2002), The GPT-4 and
LLama reports clearly stated the phenomenon of data contamination. Recently, Zhou et al. (002cc) discussed the risks and impacts of data contamination of evaluation benchmarks in assessing LLMs.
(203)) examined the data contamination problem of LLama models. The Skywork LLM et al.
(2023) again demonstrated the data contamination issue several. [Golchin & Surdeanu (2023a b);
Oren et al. (2023): Yang et al. (2023b) designed novel methods to detect the data contamination of
LLMs. DY VAL is not a detection approach but a new protocol to mitigate the contamination issue.
Complex-to-simple problem decomposition and evaluation set construction. Employing graphs to deconstruct complex tasks has been an enduring and effective strategy across domains. Compilers, as seen in computational theory (Alfred V et al. 2007), effectively break down high- level constructs, while in NLP, parsing trees bring clarity to intricate syntactic and semantic struc-
tures (Klein & Manning 2003 Vinyals et al. 2015). Roy & Roth (2015) displayed the potency of this method in arithmetic,, using trees for solving multi-step problems. Additionally, several contem- porary techniques have implored L.MSs to decompose complex problems (Wei et al. 2022 Zhou et al. 2023b: Khot et al.) 2022 Zhang et al. 2023). Several studies have leveraged graph-based ap- proaches for constructing compositional tasks, particularly the domains of first-order logic (Sinhal
et al. 2019 Clark et al. 2020 Tian et al. 2021 and causal reasoning (Jin et al. (023). DYVAL presents notable distinctions in both objective and methodology. Additionally, Graph World (Palow- itch et al., (222) primarily benchmarks Graph Neural Networks (GNNs), whereas DY VAL focuses on LLMs using the graph structure. They are different in nature.
3 DYVAL
In this section, we first elucidate general dynamic evaluation protocol address the challenges of data contamination with dynamic data generation and controllable complexity in Sec. 3.] We then adapt this general protocol for reasoning tasks by leveraging the Directed Acyclic Graphs (DAGs) in Sec. Sec.3.2 More analysis of the flexibility of DY is in Sec. 3.3
3

---

Published as a conference paper at ICLR 2024
General Protocol
Constraint
Generation Algorithm g
Description
Descritiionuunctionn Function F
Task constraint Cr
Complexity constraint Cg
Task Description Function FFr
DAG Description Function Fo
Tree-based
Arithmetic
Nonzero dividend, Overflow,
Tree: free-based DAG
DAG
What the value of [root]?
Tree-based DAG
Depth, Wifth, Add extralinks,
B
by [Operation] A and
Linear Eq. What is the valuee of
Linear Eq. Unique solution,
General
General DAG
DAG
..* Reachability
General DAG
Reachability
Num Num links,
points None. points
Can [Node A] be reached from [Node
Children
Liriss: relationshipp batween two nodees
Arithmetic example
Step 1: Specify the constraint for DAG and task.
Step 2: Generate DAG with constraint.
Step 3: Describe DAG and task.
Arithmetic C
Tree-based DAG
value
Mensero dhvidand,
Depthed, Wistins, Add estrr lntks-), Operation set: (tooon 2
Tree-based DAG
H
value derived squaring value
Nonsero square root,
I'svalue derived summing the value F,G.H What the value of
181.2 vo)
Figure 1: The pipeline of the wraph-informed VAL. Up: the general evaluation framework; down: an arithmetic example. More details can found at Sec. 3.2 and Appendix
3.1 GENERAL DYNAMIC EVALUATION DESCRIPTION LANGUAGE
First, introduce the general description language of the dynamic evaluation protocol. Given a task T, a dynamic evaluation algorithm is formulated as Ar = F(G(C)), where (1) g is the sample generation algorithm, incorporating randomness guarantee uniqueness of each sample. Randomness may vary in different tasks, such as the numbers in math problems and the logic chains logic reasoning task. (2) [Cr, Cg) denotes constraints on G. where Cr the task constraint for task T such as the legality guarantee of the generated samples in the context of the task. Cg is the complexity constraint for the generation process, such as the sampling strategy for the value each node and the number of perturbations added to the evaluation samples. (3) F (Fr, Fo) is the description function to translate the raw evaluation samples generated by G into natural language descriptions. Fg elucidates the characteristics and properties of the samples generated by G. Fr is the description for task T such as task objective and expected outcomes.
In general, evaluation sample can be represented as deval FF Cr))) using the above description language. G first produces a sample that adheres to the complexity constraint Cg and the task constraint Cy. Then it undergoes transformation by description function Fg into natural language format and finally goes through the task description function Fr. The description language above naturally (1) avoids data contamination by dynamic generation through G, and (2) promises dynamic datasets and controllable complexity through C. Specifically, by varying the constraints in C. we can generate evaluation samples of different difficulties, allowing "co-evolution" of both the LLMs and the evaluation process. The description language is flexible since it allows for different generation algorithms and complexity control by changing G and C accordingly.
3.2
GRAPH-INFORMED DYNAMIC EVALUATION FOR REASONING TASKS
In this section, following the general evaluation description language, we implement DY for reasoning tasks by taking inspiration from the graph structure. Given the intrinsic multistep infer- ential nature of reasoning tasks, they inherently exhibit structural characteristics, making directed acyclic graphs (DAGs) a natural choice for modeling these tasks. DAGs also facilitate dynamic sam- ple generation by modulating the internal structure and fine-graine gee-gga control over problem difficulty by adjusting the structural complexity. More background of DAGs can be found in Appendix A
3.2.1 GENERATION ALGORITHM G: DAG CONSTRUCTION
The generation algorithm is established on the graph construction process. We categorize DAGs as brse- DAGS (T-DAGs) and General DAGs (G-DAGs), illustrated in Figure ! T-DAGs are inherently hierarchical, making them suitable for tasks that proceed from set of initial premises to
4

---

Published as a conference paper at ICLR 2024
Table 1: Three types of reasoning tasks generated by DYLA
Field
Task
algorifimm Q
Generation
Cy
Constraint
Co
Classes
Deseliptio
Anthmmetc
Tree based
O: (fr, m, v..2)
V: (11....... 10)
Exrm links, Random dese
Depth, Widh.
Ahat is the Value of [BoSE]?
Mathematios
equation
Linear
Trap-bosed
O: (+r, m.X, v/y"
Y: 21,1,,..., 10)
Estm links, Random dese
Depti, Widh,
What the
of
Bool
Tree based
0: (AND, OR, NOT²
V. (Tree, Falso)
Extra links, Rundom desc
Depth With,
(Tree, Pals)
What 1s the [Rook]]
Logical Reasoning
Deductive
Tree-bused
O: (AND, OR, NO1²
V: (Tree, Falso)
Depth With,
links, Rundom desc
[1roe, F/bb,
What 1s the [Rook]]
Abductivv
Tree-bused
O (AND. OR, NOT))
(Tree, False)
Depth, Widhh
links, Randam dese
[Tim,, FalaeNN/A)
is
[Ract] [Valunl,
Algocitlun
Reachability
Vi-
Nudes,
rindom
(Tre,, Rales]
Oan (Node be reached from yl?
Max
path
General
V
Nudes, rundom desc
path [Node f] to (Fode 512
nexinur
final inference, such as arithmetic problems and logical reasoning tasks. Each node in T-DAGs represents a foundational subproblem. These subproblems are chained by the links between nodes and finally form a complex problem. Conversely, G-DAGs excel in mapping intricate relationships, especially in tasks demanding understanding of non-linear interactions. They are ideal for algorith- mic challenges involving complex dependencies. For instance, imagine modeling a system where a change in one entity might impact multiple others in a cascading fashion, or tasks require finding different potential pathways between entities. The generation process for these two types of DAGS are presented in Appendix B.I
Randomness in DAGS generation process. T-DAG randomness arises from operations assigned to the nodes and the initial values of the leaf nodes. For instance, in arithmetic, the operation can be "+", with the leaf nodes receiving random numbers. On the other hand, for G-DAGs, each node is endowed with random value (if needed for a certain problem). For every node, the number of children is determined randomly, and the maximum number of children depends on the input. We then establish the links by selecting the target child nodes at random.
Theorems 3.1 and 3.2 formally guarantee the dynamic generation process by exploring the prob- ability that two samples generated by T-DAG and G-DAG are identical. We focus exclusively on the base case, setting aside additional complexities like the integration of random links or the em- bedding of random descriptions, which would further diminish the likelihood of two DAGs being identical.
Theorem 3.1. Given tree-based DAG with depth d and width w, if the operation set for non- leaf nodes has i distinct operations and the value set for leaf nodes contains n distinct values, the
probability that two independently generated DAGs are identical is: P=
k
1
X n 1220
Theorem 3.2. Given general DAG with nodes where each node has a minimum of l 2 links, the probability that two randomly selected DAGs are identical is bounded by (x-1)!
Proofs can be found in Appendix C These theorems guarantee that the odds of producing identical evaluation samples are considerably low. For instance, in the arithmetic task (where k = 6, 10)
with d = 4 and w = 2, the chances that two DAGs are identical hover around le -15
3.2.2 CONSTRAINTS C FOR GRAPH GENERATION
Task constraint Cr. Task constraints vary for tasks. Take the node creation for instance: 1) What distribution should the node value adhere to? 2) What set of operations is permissible? 3) How should a node's value be computed from its children's values? In arithmetic tasks, Cr includes ensuring that a dividend is nonzero, avoiding overflow, etc. Here, we concentrate on two general task constraints: (1) Value distribution V: Specifies the permissible range or distribution from which leaf node values can be assigned. For example, in logic reasoning tasks, the premises (leaf nodes) are assigned either as True or False. (2) Operation set O: Lists the operations allowed within the DAG. The operation set constraint is usually used for tree-based DAGs. For example, in arithmetic task, the set of allowed operations can be defined as the basic arithmetic operations {+, -, x,/}.
Complexity constraint Cg. We investigate 4 techniques to inject complexity into DAGs (Figure 5 (1) Change width and depth for T-DAGs: The natural way to control tree complexity. (2) Change number of nodes and links for G-DAGs: We control the total number of nodes in G-DAGs. The
5

---

Published as a conference paper at ICLR 2024
number of links in each node is randomly selected from a predefined range, e.g., [1, (3) Add extra random links: For each node, we may introduce an additional link to another random node. (4) Embed random descriptions: Add random descriptions to the primary DAG's descriptions. More details of complexity can be found in Appendix B.2 with Figure a illustrations.
3.2.3 DESCRIPTION FUNCTION
After constructing DAGs with certain constraints, we then need to convert them into comprehensible natural language descriptions using the description function F.
DAG description function Fg. We describe the DAG node by node and then form the de- scription of the nodes into sequences. The interpretation of each node in natural language de- pends on its position and the task. For leaf nodes that represent primary input or premises, they can be described as: "The value of [Name] is [Value]." " For instance, node denoting number could be expressed as: "The value of node A is 5." For T-DAGs, the interme- diate nodes that typically denote operations performed on their child nodes, the description can be formulated as: "The value of [Name] is derived by [Operation] the values of (Children's Names]." For G-DAG, the intermediate nodes usually described as the con- nections between nodes: "The [Name] points to [Children' s Names]". Note that natural language descriptions can be replaced according to custom needs and can be further incorporated with textual adversarial attacks (Li 2019 Gao et al.. 2018 Jin et al. 2020 Li et al. 2020).
Moreover, complexity is also influenced by the order that nodes are described. We design three orders: topological, reversed topological, and random orders, each offering a unique challenge in understanding the DAGS. The details of these orders are presented in Appendix B.4
Task description function Fr. The construction of F highly depends on the context of tasks. Note- bly, this construction is also highly flexible. For instance, incorporating adversarial prompts (Zhu et al. 2023) to the task description can make problems more difficult. Here we present the task de- scription function for arithmetic and reachability tasks that are representative of T-DAG and G-DAG, respectively. Appendix B.3 presents details and examples of the remaining 5 tasks.
Arithmetic: Given a T-DAG, the DAG description function has already demonstrated the premise: the leaf nodes and the intermediate steps of inference: non-leaf nodes. Next, we select the root node as the variable required to solve, we append the question "what is the value of [Rcct] ?" to the description where [Root] is filled with the name of the root variable (Figure 88.
Reachability: The reachability task aims to model two nodes are connected DAG, the DAG description function has demonstrated the connections between nodes. The task description for reachability task is: "Can the [Node i] be reached by [Node ji" where Node and Node are randomly selected from the nodes in G-DAG (Figure
graph. For G-
Finally, while it is feasible to directly adopt GPT-4 to generate a contextualized description rather than the plain one (see Appendix B.5). it is challenging to verify the rationale of the problems generated by GPT-4. Thus, we leave it for future work.
3.3 DY COEXISTS AND CO-EVOLVES WITH EXISTING BENCHMARKS
DYVAL is complementary to existing benchmarks. First, tasks with an intrinsic structure benefit significantly from DYVAL since they can modulate complexity and randomness by adjusting the generation process. Efforts such as CheckList (Ribeiro et al. 2020), data augmentation (Andreas) 2019 ZZao al. Clark et al. 2020 Tian et al. 2021 Jin et al. 2023) can be easily integrated into VAL. On the contrary, tasks without well-defined structure may present challenges for DYVAL' implementation. Second, VY can be enhanced by existing benchmarks to formulate more challenging scenarios. For instance, the description function J is all about natural language texts, so can be casily combined with adversarial attacks (Li et al.) 2019 Jin et al.) 2020 Zhu al. 2023) duitr--dist prompts (Yang et al. 2023a) to assess the robustness of LLMs.
2020 Zhang al. 2022). and reasoning dataset synthesis (Sinha
Note that while this papers focuses evaluating reasoning tasks, DYVAL is flexible evaluate natural language tasks. We show an initial study using DY VAL to evaluate sentiment analysis in Appendix Hand more work can be done in the future. Finally, VAL guarantees unbiased and

---

Published as a conference paper at ICLR 2024
GPTI
CharGPT Arithmetic
Llama2-13b-cha
Vicuna- 13b-v13
Bookean Loge
Linear Equation
Boolean Logic
Equettin
100
103
Deductiv
Aveurary
Accuray
un
Ancuracy
50
50
Abdlaction
20
Maxe Santin Parls
Renchwallin
D1
122
D3
D2
D1
112
135
31
D1
D22
EX5
DX
Datamets
Datamels
Dedlccivv Logic
Abdiettie Logic
Reachabality
Max Stum Path
100
Accuracy 1
Aveurayy
Avcuracy
1..L1.
Accuracy
50
30
EX2
D3
D1
D1
D2
D3
D2
D1
D3
31
D1
D1
Dulccots
Dalumels
Dalumels
Dulanere
Figure 2: Results on tasks with complexity from D1 to D4 (averaged on 3 description orders and
3 seeds). Xwin- 13B, phi-1.5, and WizardMath- 13B not shown their results are all O.
balanced construction of evaluation samples by nature, since one can easily control the generation process, as shown Appendix F
EXPERIMENT
4.1 SETUP
Tasks and complexity level. We mainly discuss the constraint used each task. Test set accuracy might differ as it is generated dynamically. To balance test time and discrepancy, produce 500 samples for each dataset. To mitigate the impact of randommess on evaluation results, we assess each dataset three times. We define complexity levels (D1~D44 for each task. For tasks that use general DAGs, the number of nodes set to {7, (7, 10, 15, 20} with each node having (3, 4, 6, 8} maximum links and 1 minimum link. For tasks that tree-based DAGS, tree depths and widths are (2,2), (3, 2), 3), (4, 2), respectively. More details of D1~DD are presented Appendix [
Evaluation metric. Our primary evaluation metric accuracy. For tasks where answers are numerical, we employ relative precision (Burden et al.) 2015) to determine the correctness of a prediction, i.c., an answer is deemed correct if its relative precision within a specified thresh- old, a (e.g.. 0.01%), in relation to the ground truth value. Relative precision is calculated as ppeed - gt (gt c) S a where gt represents the ground truth value, pred the model's pre- diction, - is the absolute value function, a is the desired relative precision threshold, and is small value introduced to prevent division by zero.
LLMs. Our evaluated LLMs include Flan-T5- (Chung et al. 2022), phi- 1.5 (Li et al. 2023d) WizardMath-133 (Luo et al. 2023), Xwin-13B (Team] 2023). Llama2- Harma2-13B-char (Tourron et al. 2023), Vicuna-13B-vI.. (Chiang et al.) 2023), GPT-3.5-Turbo (OpenAl 2023a), and GPT-4 (Ope- nAl 2003b). Temperature is set to 0 to avoid randomness. We set the generation length to be directly proportional the input length. Specifically, for GPT-3.5-Turbo and GPT-4, the generate length is set to be twice the input length; for the remaining models, is set to five times the input length. We designed prompts for each task, incorporating demonstrations of rules, particularly for reason- ing and algorithm tasks. To ensure formatted output, we further ask LLMs to explicitly output their predictions between "(1(" and ")) All implementations are based on Huggingface.
4.2 RESULTS FOR MATH, LOGICAL REASONING, AND ALGORITHM TASKS
Before presenting the main results, note that the results of Flan-T5-large, phi-1.5, WizardMath- 13B, and Xwin-13R in all tasks are 0, so we longer report them. We carried out experiments using three random seeds. Figure shows the results of all tasks averaged in three generation orders and three random seeds (full results in Appendix D.4). GPT-4 performs best, followed closely performance is subpar, with (ecuma-13B-vl occasionally follows.
by GPT-3.5-Turbo Hlama2-13B-che outperforming Llama2- 12b-chat.h More findings
Inconsistent performance between existing static benchmarks and VAL: Despite the excel- lent results of phi-1.5, Xwin- 13B and WizardMath- Ma on existing benchmarks, their poor perfor- mance in our evaluations highlights the potential problems when evaluating LLMs solely on static benchmarks and possible low training data quality data contamination issue.

---

Published as a conference paper at ICLR 2024
Difficulty with complex datasets: Performance mostly decreases sharply from D1 to D4, high- lighting LLMs' struggles with increasing complexity. For example, GPT-3.5-Turbo's performance drops by 23% for arithmetic task as complexity increases. Notably, performance in abductive logic (inferring premises from conclusions) much lower than in deductive logic (deriving conclusions from premises), as supported by |Brgllnd et al. (2023), which shows LLMs excel more in "A is B" than "B is A". In addition, the performance difference between GPT-4 and GPT-3.5-Turbo, while subtle in simpler tasks like DI, becomes prominent complex tasks. These observations indicate the value of intricate and evolving tasks to effectively differentiate and evaluate models. We also present more interesting observations Appendix D.4]
Human study: We recruited 82 human evaluators with at least a bachelor's degred to gauge their skills against L.MSs on the most complex dataset (D4) for mathematical and logical reasoning tasks. Each partici- pant tackled 5 problems from each dataset. As depicted in Figure S both GPT-4 and GPT-3.5-Turbo consis- tently showed high competence in most tasks, surpass- ing average human results. The reason could be that the generated problems are generally harder for humans but easier for LLMs. Nevertheless, GPT-4 struggled in ar- cas like linear equations and abductive logic. This indi- cates that future development could involve more data from specific domains.
CluGPT
Vioms-13bee..
CPTT
10
Accuray
Th Aanletetly
I I
21
Liaw Espaie yaok
Dedective led
Nitrrtton
Thek
Figure 3: Human vs. LLMs results.
4.3 CASE STUDY
In an endeavor to comprchensively understand the behav- ior of LLMs, we meticulously examined the failure modes. Our focus is especially on the most challenging datasets for arithmetic, deductive logic, abductive logie, and reachability tasks based on the performance of GPT-4. We randomly se- lected 20 failure samples for each task and summarized the failure modes in Figure 4 The detailed failure cases are pre- sented in Appendix D.5 The error types vary, indicating that there is much room for improvement.
Error Types
Partial Calenlation Error
Unsubetantiata] Resporse
33.8
Instractional Ovensight
21.5
Lscorrees
Contrndiction
Ressoting
Figure 4: Failure modes distribution.
Partial calculation error: GPT-4 occasionally errs in inter-
mediate steps, while keeping the remaining steps correct. We emphasize that the errors may be as simple as 20/77 = 38. This aligns with (Dziri et al. 2023) noting LLMs sometimes give partially correct multi-digit multiplication results. Incorrect reasoning and self contradiction: In reason- ing tasks, GPT-4 may misinterpret rules. Given an abductive logic A V B + C' with C is False, the premise A, B must be False. However, GPT-4 inaccurately abduced that either A B might be False. Further, GPT-4 occasionally contradicts itself in its assumptions for the same inference in abductive logic task. Unsubstantiated response: In reasoming tasks and algorithm tasks, GPT-4 often answers without any inferences or justifications. Its answer-only responses suggest possible memorization or shallow understanding. Instructional oversight: Occasionally, GPT-4 adeptly ar- rives at the correct computation but stumbles when it comes adhering to the output instructions laid out in prompts, for example, the required relative precision of mathematic calculation.
4.4 ABLATION STUDY
Impact of complexity constraints Cg: In Figure 5 vary complexity in GPT-3.5-Turbe by ad- justing constraints as described in Sec. 3.2.2 and observe how L.MMs performance shifts across arithmetic, boolean logic, and deductive logic tasks. Notably, as task intricacy rises due aug- mented complexity parameters, L.MS' performance diminishes. Depth emerges as the predominant challenge in tree-based DAGs, emphasizing the LLMs' difficulty with extended inference steps.
Prompt engineering: We evaluate five prompting techniques (PE) on our most challenging datasets, outlined Table and Appendix D.7 No PE methods can perform best in all tasks. While APE notably boosts the Linear Equation task by 10%, it negatively impacts deductive and abductive logic. These varied outcomes highlight the importance of task-specific PE selection and development.
The results may represent the highest level of human performance. Demographics in Appendix D.8
8

---

Published as a conference paper at ICLR 2024
Depth Arithmetic
Width
Add Extra Links
Embed Random Deses
Boolean Logic
Deductive Logic
1000
100
Accurecy
Acoracy
30
Aceurayy
80
50
01
D4
16
130
T12
D6
Difiielly Levels
Difficulty Levels
Diffienlty Levels
Figure 5: Comparison results across different complexity constraints.
Influence of model size: We further evaluate the performance of Llama2 with different model sizes of arithmetic, boolean logic and reachability tasks their simplest dataset D1. Table that larger sizes produce better results, but mostly still not surpass GPT-4 and human.
5 DALAL HELPS FINE-TUNING
In this section, show that DYVAL-generated data can further utilized to fine-tune LLMs to improve their ca- pabilities of solving complex tasks. Specifically, gen- erate training data for 7 tasks to fine-tune Llama2-13B chat. The details of fine-tuning and training sample gener- ation are in Appendix E We then test the model with dif- ferent settings: (1) in-distribution samples with the same sam-
Vanilla
Fine- Fine-Tuned
Accuracy
30
20
30-
difficulty as the training data; (2) cud-of-distributiin ples, whose difficulty levels are higher than the training data. To further demonstrate the effectiveness of our gen- erated data, we test the models with few-shot examples on existing benchmarks including GSM8K (Cobbe et al. 2021) and SVAMP (Patel et al. 2021) to evaluate math abilities, FOLIO (Han et al. 2022) and RACO (bench au- [hors] 2023) to evaluate the logical reasoning abilities, and DP (Dziri et al. 2023) and LCS (bench) authors 2023 evaluate the algorithm abilities. Results in Figure 6 and 10 show that the perfor- mance of the fine-tuned model increases all tasks. It shows that DY VAL is effective not only as a benchmark but also in enhancing the performance of LLMs existing benchmarks via fine-tuning on its generated samples. The improvement might stem from the similarities between various bench- marks and DY VAL-generated samples. For instance, GSM8K samples can be interpreted as trees of depth 2 or 3. Interestingly, even no dynamic programming tasks in our fine-tuning, the fine-tuned model also showed improved performance on the DP and LCS datasets. This underscores the po- tential learning capability of LLMs and the efficacy of training samples generated by DY VAVA We further fine-tuned GPT-3.5- Turboo and examined its ability on general natural language understand- ing. The results indicated that fine-tuning on our generated datasets does not necessarily hurt the natural language understanding ability, as comprehensively discussed in Appendix
GisMsK
SVAMP
POLIO
RACO
DP
108
Task
Figure 6: Results on existing bench-
marks using 1auma2-13B-haa model fine-tuned on Dy VAL-generater data.
6 CONCLUSION AND DISCUSSION
We proposed DY VAL, dynamic LLMs evaluation protocol to mitigate the data contamination and static complexity of existing benchmarks. We designed the graph-informed VAL for reasoning tasks. The strength of DYVAL. lies in its dynamic generation of samples, with inherent flexibility for difficulty adjustment. We observed several interesting findings in experiments using our benchmark. More importantly, DY VAL-geerrraee samples can not only be used as evaluation samples, but also act as fine-tuning data for LLMs to enhance their performance existing benchmarks.
Our work has several limitations. (1) Tasks: We currently focused on reasoning tasks. While DYVAL supports other tasks (see Sec. H requires design of the generation algorithm G. (2) Samples: Our experiments utilized limited set of test samples due to resource constraints. Evaluations larger sets may help to observe more findings. (3) Fine-tuning: Fine-tume tuning can be done on more diverse models and datasets gain deeper insights.

---

Published as a conference paper at ICLR 2024
ACKNOTLEDGEMENT AND DISCLAIMER
The purpose of this research is to present dynamic and evolving evaluation protocol in response to the rapid development of LLMs. We have the following claims. First, the generation mechanism of VAL does not contain any potentially harmful words or expressions but only mathematical, logi- cal, and algorithmic descriptions.
the future, the usage VAL on other natural language tasks should be dealt with cautions to not include any harmful or irresponsible languages. Second, human subjects are involved in this study to act as LLMs' competitors for performance comparison and analysis. All human studies are conducted obeying laws and regulations in certain countries. Third, the experiments on GPT-3.5- -urboo and GPT-4 conducted in this paper are based on their latest ver- sion in June, 2023. Authors recommend using the same version of these services for reproducibility. As we tried our best to tune the best prompts for our experiments, it is, however, well-known that LLMs are highly sensitive to prompts. Therefore, the experiments in this paper are only based on our prompt design and codebase. Finally, we may have concluded that some LLMs in this paper achieved poor performance our benchmark, but this does not mean these models are good or cannot be used in practice. Authors remain positive and optimistic to all evaluated LLMs that they will further be stronger.
REFERENCES
Aho Alfred V, Lam Monica S, Sethi Ravi, Ullman Jeffrey D, et al. Compilers-principles techniques, and tools. pearson Education, 2007.
Jacob Andreas. Good-enough compositional data augmentation. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 7556-7566, Online, July 2020. Association for Computational Linguisties.
Devansh Arpit, Stanislaw Jastrzkebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxin- der S. Kanwal, Tegan Maharaj, Asja Fischer, Aaron Courville, Yoshua Bengio, and Simon Lacoste-Julien A closer look at memorization in deep networks. In Proceedings of the 34th International Conference on Machine Learning, volume 70, pp. 233 233-242, 06-11 Aug 2017.
Yejin Bang, Samuel Cahyawijaya, Nayeon Lee, Wenliang Dai, Dan Su, Bryan Wilie, Holy Lovenia, Ziwei Ji, Tiezheng Yu, Willy Chung, et al. A multitask, multilingual, multimodal evaluation of chatgpt reasoning. hallucination, and interactivity. arXiv preprint arXiv:2302.04022 2023.
BIG bench authors. Beyond the imitation game: Quantifying and extrapolating the capabilities of language models. Transactions Machine Learning Research, 2023. ISSN 2835-8856.
Emily M. Bender, Timnit Gebru, Angelina SiMillan-MMaoor and Shmargaret Shmitchell, On the dangers of stochastic parrots: Can language models be too big? FAccT 2021, pp. 610-623, New York, NY, USA, 2021. Association for Computing Machinery. ISBN 978 9781450383097.
Lukas Berglund, Meg Tong, Max Kaufmann, Mikita Balesni, Asa Cooper Stickland, Tomasz Kor- bak, and Owain Evans. The reversal curse: Lims trained on "a is b" fail to learn "b is a". arXiv preprint ar arX9v:2309. 12288, 2023.
Stella Biderman, USVSN Sai Prashanth, Lintang Sutawika, Hailey Schoelkopf, Quentin Anthony, Shivanshu Purohit, and Edward Raf. Emergent and predictable memorization in large language models. arXiv preprint arXiv:2304.11158. 2023.
Nathan Brody. What is intelligence? International Review of Psychiatry, 11(1):19-25 1999.
Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in nearal information processing systems, 33:1877-1901, 2020.
Sébastien Bubeck, Varun Chandrasckaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Ka- mar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott Lundberg, et al. Sparks of artificial general intelligence: Early experiments with gpt-4. arXiv preprint 2xX.:23333./2712 2023.
10

---

Published as a conference paper at ICLR 2024
Richard L Burden, Douglas Faires, and Annette M Burden. Numerical analysis. Cengage learning, 2015.
Nicholas Carlini, Daphne Ippolito, Matthew Jagielski, Katherine Lee, Florian Tramer, and Chiyuan Zhang. Quantifying memorization across neural language models. In The Eleventh International Conference on Learning Representations, 2023.
Jiaao Chen, Xiaoman Pan, Dian Yu, Kaiqiang Song, Xiaoyang Wang, Dong Yu, and Jianshu Chen. Skills-in-context prompting: Unlocking compositionality in large language models. arXiv preprint 2a0.::20000000000 2023.
Wei-Lin Chiang, Zhuohan Li, Zi Lin, Ying Sheng, Zhanghao Wu, Hao Zhang, Lianmin Zheng, Siyuan Zhuang, Yonghao Zhuang, Joseph Gonzalez, et al. Vicuna: An open-source chatbot impressing gpt-4 with 90%* chatgpt quality. See https://vicuna. Imsys. org (accessed 14 April 2023), 2023.
Minje Choi, Jiaxin Pei, Sagar Kumar, Chang Shu, and David Jurgens. Do ilms understand social knowledge? evaluating the sociability of large language models with socket benchmark. arXiv preprint 1...:.33...493,, 2023.
Raunak
Chowdhuri,
Neil
Deshmukh, and David Koplow.
gpt4 No. site/ 6c2 2023.
can't
-ttps://Eoooeer-trraa------- No 10--GP4--can-- tacccantttceeeeeee MIT--MIT--22 ------------------2------------- 01t---22222775555433322222222280
mit.
Hyung Won Chung, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Eric Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, al. Scaling instruction-finetunee language mod- els. arXiv preprint arXiv:2210. 16,6, 2022.
Peter Clark, Oyvind Tafjord, and Kyle Richardson. Transformers as soft reasoners over language. In Christian Bessiere (ed.), Proceedings of the Twenty-Ninth International Joint Conference on Artificial Intelligence, IJCAI-20, pp. 3882-3890. International Joint Conferences on Artificial Intelligence Organization, 2020.
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Relichiro Nakano, et al. Training verifiers to solve math word problems. arXiv preprini arXiv:2110. 14168, 2021.
George Cybenko. Approximation by superpositions sigmoidal function. Mathematics of control, signals and systems, 2(4):303-33 -14, 1989.
Nouha Dziri, Ximing Lu, Melanie Sclar, Xiang Lorraine Li, Liwei Jian, Bill Yuchen Lin, Peter West, Chandra Bhagavatula, Ronan Le Bras, Jena D Hwang, et al. Faith and fate: Limits of transformers compositionality. arXiv preprint arXiv:2305. 18654, 2023.
Irena Gao, Gabriel Ilharco, Scott Lundberg, and Marco Tulio Ribeiro. Adaptive testing of computer vision models. arXiv preprint arXiv:22 2022.
J. Gao, J. Lanchantin, M. L. Soffa, and Y. Qi. Black-box generation of adversarial text sequences to evade deep learning classifiers. In 2018 IEEE Security and Privacy Workshops (SPW), pp. 50-56, May 2018. doi: 10. 109/SPW.2011 ..100.......00016...
Shahriar Golchin and Mihai Surdeanu. Data contamination quiz: A tool to detect and estimate contamination in large language models. arXiv preprint arXiv:2311.06233, 2023a.
Shahriar Golchin and Mihai Surdeanu. Time travel in llms: Tracing data contamination large language models. arXiv preprint arXiv:2308.08493 2023b.
Simeng Han, Hailey Schoelkopf, Yilun Zhao, Zhenting Qi, Martin Riddell, Luke Benson, Lucy Sun, Ekaterina Zubova, Yujie Qiao, Matthew Burtell, et al. Folio: Natural language reasoning with first-order logic. arXiv preprint 22Xiv:2209000844 2022.
Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding. In International Conference Learning Representations, 2021.
11

---

Published as a conference paper at ICLR 2024
Edward J Hu, yelong shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. LoRA: Low-rank adaptation of large language models. In International Con- ference Learning Representations, 2022.
Yuzhen Huang, Yuzhuo Bai, Zhihao Zhu, Junlei Zhang, Jinghan Zhang, Tangjun Su, Junteng Liu, Chuancheng Lv, Yikai Zhang, Jiayi Lei, et al. C-eval: A multi-level multi-discipline chinese evaluation suite for foundation models. arXiv preprint vrXiv:2305.0332 2023.
HuggingFace. Open-source large language models leaderboard. https://hugginaan Spacess/Hucgingfacelle
co/
11m leaderboard. 2023.
Di Jin, Zhijing Jin, Joey Tianyi Zhou, and Peter Szolovits. Is bert really robust? strong baseline for natural language attack on text classification and entailment. In Proceedings of the AAAI conference on artificial intelligence, volume 34, pp. 8018-801 088-802,,2000 2020.
Zhijing Jin, Jiarui Liu, Zhiheng Lyu, Spencer Poff, Mrinmaya Sachan, Rada Mihalcea, Mona Diab, and Bernhard Schölkopf. Can large language models infer causation from correlation? arXiv preprint 2365:2306.05836, 2023.
Tushar Khot, Harsh Trivedi, Matthew Finlayson, Yao Fu, Kyle Richardson, Peter Clark, and Ashish Sabharwal. Decomposed prompting: A modular approach for solving complex tasks. In The Eleventh International Conference Learning Representations, 2022.
Douwe Kicla, Max Bartolo, Yixin Nic, Divyansh Kaushik, Atticus Geiger, Zhengxuan Wu, Bertie Vidgen, Grusha Prasad, Amanpreet Singh, Pratik Ringshia, Zhiyi Ma, Tristan Thrush, Sebastian Riedel, Zeerak Waseem, Pontus Stenetorp, Robin Jia, Mohit Bansal, Christopher Potts, and Adina Williams. Dynabench: Rethinking benchmarking in NLP. In Proceedings of the 2021 Confer- ence of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 4110-4124, June 2021.
Dan Klein and Christopher D Manning. Accurate unlexicalized parsing. In Proceedings of the 41st annual meeting of the association for computational linguistics, pp. 423-430, 2003.
Jan Kocoñ, Igor Cichecki, Oliwier Kaszyca, Mateusz Kochanek, Dominika Szydto, Joanna Baran, Julita Bielaniewicz, Marcin Gruza, Arkadiusz Janz, Kamil Kanclerz, al. Chatgpt: Jack of all trades, master of none. Information Fusion, pp. 101861, 2023.
Ben Krause, Emmanuel Kahembwe, Iain Murray, and Steve Renals. Dynamic evaluation of neural sequence models. In International Conference on Machine Learning, pp. 2766-2775. PMLR, 2018.
Jinfeng Li, Shouling Ji, Tianyu Du, Bo Li, and Ting Wang. TextBugger: Generating adversarial text against real-world applications. In Proceedingy 2019 Network and Distributed System Security Symposium. Internet Society, 2019, doi: 10. (0.14722/ndss.2019 2019.233
Linyang Li, Ruotian Ma. Qipeng Guo, Xiangyang Xue, and Xipeng Qiu. BERT-ATTACK: Adver- sarial attack against BERT using BERT. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1292- November 2020.
Minghao Li, Feifan Song, Bowen Yu, Haiyang Yu, Zhoujun Li, Fei Huang, and Yongbin Li. Api- bank: A benchmark for tool-augmented 1lms. arXiv preprint arXiv:2304.08244 082444 2023a.
Xuechen Li, Tianyi Zhang, Yann Dubois, Rohan Taori, Ishaan Gulrajani, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. Alpacaeval: An automatic evaluator of instructionnfollooiing models. Inttps:/// //qi thub. www./ttts--lla............. paca _ 2023b.
Xuechen Li, Tianyi Zhang. Yann Dubois, Rohan Taori, Ishaan Gulrajani, Carlos Guestrin, Percy Liang, and Tatsunori B Hashimoto. Alpacaeval: An automatic evaluator of instruction-follooiing models, 2023c.
Yuanzhi Li, Sébastien Bubeck, Ronen Eldan, Allie Del Giorno, Suriya Gunasekar, and Yin Tat Lee. Textbooks are all you need ii: phi-1.5 technical report. arXiv preprint arXiv:2309.05463 2023d.
12

---

Published as a conference paper at ICLR 2024
Yucheng Li. An open source data contamination report for llama series models. arXiv preprint 0rXiv:2310.1758. 2023.
Percy Liang, Rishi Bommasani, Tony Lee, Dimitris Tsipras, Dilara Soylu, Michihiro Yasunaga, Yian Zhang. Deepak Narayanan, Yuhuai Wu, Ananya Kumar, Benjamin Newman, Binhang Yuan, Bobby Yan, Ce Zhang, Christian Alexander Cosgrove, Christopher Manning. Christopher Re, Diana Acosta-Navas, Drew Arad Hudson, Eric Zelikman, Esin Durmus, Faisal Ladhak, Frieda Rong, Hongyu Ren, Huaxiu Yao, Jue WANG, Keshav Santhanam, Laurel Orr, Lucia Zheng, Mert Yuksekgonul, Mirac Suzgun, Nathan Kim, Neel Guha, Niladri S. Chatterji, Omar Khattab, Peter Henderson, Qian Huang, Ryan Andrew Chi, Sang Michael Xie. Shibani Santurkar, Surya Ganguli, Tatsunori Hashimoto, Thomas Ieard, Tianyi Zhang, Vishrav Chaudhary, William Wang, Xuechen Li, Yifan Mai, Yuhui Zhang. and Yuta Koreeda. Holistic evaluation of language models. Transactions on Machine Learning Research, 2023. ISSN 2835-8856
David Lohman and Joni M Lakin. Intelligence and reasoning. The Cambridge handbook of intelligence, pp. 419-441, 2011.
Brian Lovin. Gpt-4 performs significantly worse coding problems not in its training data. www.oviww..oooooooooooomooooooeo hn/ 2023.
Haipeng Luo, Qingfeng Sun, Can Xu, Pu Zhao, Jianguang Lou, Chongyang Tao, Xiubo Geng, Qing- wei Lin, Shifeng Chen, and Dongmei Zhang. Wizardmath: Empowering mathematical reasoning for large language models via reinforced evol-instruct. arXiv preprint arXiv:2308. 09583, 2023.
Zhiyi Ma, Kawin Ethayarajh, Tristan Thrush, Somya Jain, Ledell Wu, Robin Jia, Christopher Potts, Adina Williams, and Douwe Kiela. Dynaboard: An evaluation-as-a-serviee platform for holistic pext-generation benchmarking. Advances in Neural Information Processing Systems, 14:10351- 10367, 2021.
Inbal Magar and Roy Schwartz. Data contamination: From memorization to exploitation. arXiv preprint arXiv:2203.082442 2022.
OpenAl.
com. com. chat, 2023a.
OpenAI. Gpt-4 technical report, 2023b.
Yonatan Oren, Nicole Meister, Niladri Chatterji, Faisal Ladhak, and Tatsunori B Hashimoto. Proving test set contamination in black box language models. arXiv preprint arXiv:2310. 17623, 2023.
John Palowitch, Anton Tsitsulin, Brandon Mayer, and Bryan Perozzi. Graphworld: Fake graphs bring real insights for gmns. In Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pp. 3691-3701, 2022.
Arkil Patel, Satwik Bhattamishra, and Navin Goyal. Are NLP models really able to solve simple math word problems? Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 2080-2094, June 2021.
Marco Tulio Ribeiro and Scott Lundberg. Adaptive testing and debugging of nlp models. In Pro- ceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1; LLong Papers), pp. 3253-3267, 2022.
Marco Tulio Ribeiro, Tongshuang Wu, Carlos Guestrin, and Sameer Singh. Beyond accuracy: Be- havioral testing of NLP models with CheckList. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 4902-4912, Online, July 2020. Association for Computational Linguistics.
Subhro Roy and Dan Roth. Solving general arithmetic word problems. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1743-1752, September 2015.
Tomohiro Sawada, Daniel Paleka, Alexander Havrilla, Pranav Tadepalli, Paula Vidas, Alexander Kranias, John Nay, Kshitij Gupta, and Aran Komatsuzaki. Arb: Advanced reasoning benchmark for large language models. arXiv preprint 233.:23377.16622. 2023.
13

---

Published as a conference paper at ICLR 2024
Rylan Schaeffer. Pretraining the test set is all you need. arXiv preprint arXiv:2309.08632, 2023.
Koustuv Sinha, Shagun Sodhani, Jin Dong, Joelle Pineau, and William L. Hamilton. CLUTRR: A diagnostic benchmark for inductive reasoning from text. In Proceedings of the 2019 Conference Empirical Methods in Natural Language Processing and the 9th International Joint Confer- ence on Natural Language Processing (EMNLP-IJCNLP) pp. 4506-4515, Hong Kong, China, November 2019. Association for Computational Linguistics.
Xiaojuan Tang, Zilong Zheng, Jiaqi Li, Fanxu Meng, Song-Chun Zhu, Yitao Liang, and Muhan Zhang. Large language models are in-context semantic reasoners rather than symbolic reasoners. arXiv preprint arXiv:2305. 00..30....4.... /4825, 2023.
Michael Tänzer, Sehastian Ruder, and Marek Rei. Memorisation versus generalisation in pre-trained language models. In Proceedings of the 60th Annual Meeting of the Association for Computa- tional Linguistics (Volume 1: Long Papers), pp. 7564 7578, May 2022.
Xwin-LM Team. Xwin-Im, 2023. URL. htIl.htps::// /tgpt//gtttttbttt
htttps://gthhu........ com/ Xwin-IM/Xwin LM
Krishnaiyan Thulasiraman and Madisetti NS Swamy. Graphs: theory and algorithms. John Wiley & Sons, 2011.
Jidong Tian, Yitian Li, Wenqing Chen, Liqiang Xiao, Hao He, and Yaohui Jin. Diagnosing the first-order logical reasoning ability through LogicNLI. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pp. 3738 133837777,20 November 2021.
Yuchi Tian, Kexin Pei, Suman Jana, and Baishakhi Ray. Deeptest: Automated testing of deep- neural-network-drive autonomous cars. In Proceedings of the 40th international conference on software engineering, pp. 303-314, 2018
Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Niko- lay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open founda- tion and fine-tuned chat models. arXiv preprint arXiv::2007.0 009888, 2023.
Oriol Vinyals, Lukasz Kaiser, Terry Koo, Slav Petrov, Ilya Sutskever, and Geoffrey Hinton. Gram- mar as foreign language. Advances in neural information processing systems, 28, 2015.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, brian ichter, Fei Xia, Ed H. Chi, Quoe V Le, and Denny Zhou. Chain of thought prompting elicits reasoning in large language models. In Alice H. Oh, Alekh Agarwal, Danielle Belgrave, and Kyunghyun Cho (eds.), Advances in Neural Information Processing Systems, 2022.
Tianwen Wei, Liang Zhao, Lichang Zhang, Bo Zhu, Lijie Wang, Haihua Yang, Biye Li, Cheng Cheng, Weiwei Lü, Rui Hu, et al. Skywork: A more open bilingual foundation model. arXiv preprint arXiv:2310. 2tti::231..1941,,, 19341, 2023.
Zhaofeng Wu, Linlu Qiu, Alexis Ross, Ekin Akyürek, Boyuan Chen, Bailin Wang, Najoung Kim, Jacob Andreas, and Yoon Kim. Reasoning or reciting? exploring the capabilities and limitations of language models through counterfactual tasks. arXiv preprint vrXiv:2307.02477 2023.
Linyi Yang, Shuibai Zhang, Libo Qin, Yafu Li, Yidong Wang, Hanmeng Liu, Jindong Wang, Xing Xie, and Yue Zhang. Glue-x: Evaluating natural language understanding models from an out-of- distribution generalization perspective. In Findings of ACL, 2023a.
Shuo Yang, Wei-L.in Chiang, Lianmin Zheng, Joseph E Gonzalez, and lon Stoica. Rethinking benchmark and contamination for language models with rephrased samples. arXiv preprint arXiv:2311.04855 2023b.
Matej Zečević, Moritz Willig, Devendra Singh Dhami, and Kristian Kersting, Causal parrots: Large language models may talk causality but are not causal. Transactions on Machine Learning Re- search, 2023.
Chiyuan Zhang, Samy Bengio, Moritz Hardt. Benjamin Recht, and Oriol Vinyals. Understanding deep learning (still) requires rethinking generalization. Communications of the ACM, 64(3):107- 115, 2021.
14

---

Published as a conference paper at ICLR 2024
Le Zhang. Zichao Yang, and Diyi Yang. TreeMix: Compositional constituency-base data aug- mentation for natural language understandingg In Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 5243-5258, July 2022.
Yifan Zhang, Jingqin Yang, Yang Yuan, and Andrew Chi-Chih Yao. Cumulative reasoning with large language models. arXiv preprint arXiv:2308.04371 2023.
Jie Zhao, Xiang Deng, and Huan Sun. Easy-to-hard: Leveraging simple questions for complex question generation, 2019.
Lianmin Zheng. Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. Judging llm-as-a-judge with it-bench and chatbot arena. arXiv preprint 2.0.i::3300.00668,, 2023.
Wanjun Zhong, Ruixiang Cui, Yiduo Guo, Yaobo Liang, Shuai Lu, Yanlin Wang, Amin Saied, Weizhu Chen, and Nan Duan. Agieval: A human-centric benchmark for evaluating foundation models. arXiv preprint arXiv:2304.0m 06364, 2023.
Chunting Zhou, Pengfei Liu, Puxin Xu, Srini Iyer, Jiao Sun, Yuning Mao, Xuezhe Ma, Avia Efrat, Ping Yu, Lili Yu, Susan Zhang, Gargi Ghosh, Mike Lewis, Luke Zettlemoyer, and Omer Levy. Lima: Less is more for alignment, 2023a.
Denny Zhou, Nathanael Schärli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuur- mans, Claire Cui, Olivier Bousquet, Quoc Le, al. Least-to-most prompting enables complex reasoning in large language models. In ICLR, 2023b.
Kun Zhou, Yutao Zhu, Zhipeng Chen, Wentong Chen, Wayne Xin Zhao, Xu Chen, Yankai Lin, Ji-Rong Wen, and Jiawei Han. Don't make your Ilm an evaluation benchmark cheater. arXiv preprint arXiv:231 1.0/964, 2023c.
Yongchao Zhou, Andrei loan Muresanu, Ziwen Han, Keiran Paster, Silviu Pitis, Harris Chan, and Jimmy Ba. Large language models are human-level prompt engineers. In ICLR, 2023d.
Kaijie Zhu, Jindong Wang, Jiaheng Zhou, Zichen Wang, Hao Chen, Yidong Wang, Linyi Yang, Wei Ye, Neil Zhenqiang Gong, Yue Zhang, al. Promptbench: Towards evaluating the robustness of large language models on adversarial prompts. arXiv preprint arXiv:2306.0459 2023.
Zeyuan Allen Zhu and Yuanzhi Li. Physics of language models: Part 3.1, knowledge storage and extraction, 2023.
Caleb Ziems, William Held, Omar Shaikh, Jiaao Chen, Zhehao Zhang, and Diyi Yang. Can large language models transform computational social science? arXiv preprint 230.053305,35514 2023.
15

---

Published as a conference paper at ICLR 2024
CONTENTS
Preliminary on Directed Acyclic Graph
16
Details of VAL
17
B.1
Generation Algorithm
17
B.2
Complexity control
17
B.3
Description function
17
B,4
Description order
21
B.5
Potentials in Using GPT-4 Generate Description Functions
22
Proof
23
D Details of Experiments
23
D.I Experiment Environment
23
D.2 Prompts
24
D.3
Evaluation Set
25
D.4
Details of Experiment Results
25
D.5
Details of Case Study
25
D.6
Details of Varing Complexity Constraints
30
D.7 Details of Prompt Engineering
31
D.8
Human Study
31
Details of Fine-tuning
32
E.
Constructing training datal
32
Training data and testing data
36
E.3 Results of Fine-tuning
36
Imbalanced Generated Dataset
36
General Language Understanding Ability after Fine-tuning
37
Flexibility Natural Language Tasks
37
A PRELIMINARY ON DIRECTED ACYCLIC GRAPH
Directed Acyclic Graphs, commonly referred to as DAGS, are category of graphs that encapsulate a unique structure: they are directed and contain no cycles. directed links, and there exists sequence of links that loops back to original node. Every link in a DAG has an initial node and a terminal node, giving a direction. This is often symbolized b, where DAGs from other directed graphs is their lack of cycles. In other words, starting from any node in the graph, cannot traverse series of links and return to the same node.
DAG, vertices are connected by
the starting node and is the ending node. A key property that differentiates
In our implementation, each node comprises three attributes: 1) Children (Links): These are the direct dependents subsequent nodes that given node connects They highlight the immediate
16

---

Published as a conference paper at ICLR 2024
relations following particular node. 2) Value: Every node possesses value, which either be explicitly assigned or derived based on its operation and its children. This value captures the essence or result of the represented subproblem. 3) Operation: Especially relevant in tree-based DAGs, the operation dictates how node interprets or processes the values of its children to compute its own value. Operations might include mathematical functions, logical evaluations.
B DETAILS OF VAI
B.1 GENERATION ALGORITHM
We distinguish DAGs into two primary categories: Tree-based DAGs (T-DAGs) and General DAGs (G-DAGs), as shown in Figure
B.1.1 T-DAGS
Tree-based DAGs possess an innate hierarchical structure that frequently encapsulate tasks that en- tail a sequence of conditions culminating in a definitive conclusion or result. This hierarchy natu- rally aligns with the structure of many mathematical and logical problems. For instance, in solving multi-step algebraic problem, one often starts with the provided equations (leaf nodes) and pro- ceeds step-by-step, combining and reducing these equations until arriving at the final solution (root node). Such a natural progression of deduction makes tree-based DAGs particularly feasible for these problems.
We employ top-down approach to construct Tree-based DAG. This algorithm is tailored to pro- duce tree with a designated depth and width. The inherent randomness stems from two main factors: the operations assigned to intermediate nodes and the initialization values of the leaf nodes. For the intermediate nodes, we commence by randomly selecting an operation that defines the re- lationship between the node and its children. Take arithmetic task "addition (+)' implies that the node's value is the sum of its children's values. Once all child nodes established, compute the parent node's value accordingly. In the case of leaf nodes, values are assigned randomly, such as picking an integer from the range [1, 10] for arithmetic tasks.
example: selecting
B.1.2 G-DAGS
General DAGs, diverging from tree-based ones, lack strict hierarchy. Instead, they present a more intricate web of node relationships. Their strength lies in simulating complex, intertwined relations in real-world situations. A classic use-case is the representation of transportation systems where nodes symbolize cities and edges represent connecting roads. Challenges such determining if one city is accessible from another encapsulate the real-world problems general DAGs adeptly model. Their flexibility extends representing a plethora of situations, from mapping supply-chain logistics to analyzing social networks.
To create general DAG, initiate by generating isolated nodes without any connecting links. Subsequently, each node is endowed with a random value. For every node, the number of children is determined randomly, the maximum number of children is depended the input. We then establish the links by selecting target child nodes at random.
B.2 COMPLEXITY CONTROL
Figure demonstrated types of complexity constraints for T-DAGs. Compared to original case, adding width and additional links augments the computational intricacy of each subproblem. In- creasing the depth escalates the complexity by necessitating more inference steps. Embedding ran- dom descriptions aims to distract LLMs.
B.3 DESCRIPTION FUNCTION
Figure 1 presented an illustration our generated 7 tasks in 3 subjects: (1) Mathematics VAL- M), which includes arithmetic task and linera equation task; (2) Logical Reasoning (DYVAL-L.)
17

---

Published as a conference paper at ICLR 2024
Origin
Add width
Add depth
Add random links
random descriptions
M
A's value calculated s value i...
vallue calculated she of and Cand E, B'svalue
calculated the sum of and v'svalue
A's calculated by the sum of and Cand value
value calculated the sum of and C. valuee B's value is
G's value
L's value is..
Figure 7: The complexity constraints for Tree-based DAGs.
which includes boolean logic task, deductive logic task, and abductive logic task; (3) Algorithm Tasks (DYVAL-A), which includes reachability task and max sum path task.
B.3.1 DYVAL-M
For VYL-M,,, we design mathematical problems that can be categorized into two main types:
Arithmetic: Given a T-DAG, the DAG description function has already demonstrated the premise: the leaf nodes and the intermediate steps of inference: non-leaf nodes. Next, select the root node as the the variable required to solve, we append the question "What is the value of [Root]] ?" to the final of the description where [Root] is filled with the name of the root variable.
Here is a description of an arithmetic problem:
The value of aaa is 9.
The value of aad is 4.
aae gets its value by taking the square root of the value that aad has.
The value aab is 3.
aac gets its value by adding together the value of aaa and aab. aaf gets its value by subtracting the value of aae from the value of aac.
Compute the result of aaf. If the solution cannot be calculated, answer ( Ensure your result is within a relative precision of 0.0001 (or 0.018) compared to the ground truth value. Ensure your final result begins with <<ee and ends with <>>>', for example, if the answer is 1, your final result should be <<<1>>>.
Linear Equations: Linear equations with multiple variables present higher degree of complexity compared to arithmetic. We use two-variable linear equations described as aıæ + biy = C1 02z + bay c2. The coefficients are assigned a random value. We ask LLMs to solve the value of z, y for this linear system. Note that constructing such linear equations does not need T-DAGs or G-DAGs. To introduce additional challenges, some coefficients can be substituted with values derived from the T-DAG's roots, forcing a two-step mroolem-solving approach: first calculating the coefficients from the DAG and subsequently resolving the linear equations. Note that in experiment, the tree depth and width for linear equation task are (1, 1), (2, (2,2), (3, 2), (4, 2) respectively. (1, 1) represent that the value of the replaced coefficient is directly given.
18

---

Published as a conference paper at ICLR 2024
Given the fellcwing linear equation system with two variables:
-7 aac0 y
x -1 10
The calculation of aaco is defined as:
The value of aab0 is 4.
The value of aaa0 is 9.
aac0 gets its value by adding together the va value of aaa0 and aabb.
Determine the values of x and y. Ensure your results are within a relative precisien of 0.001 (or 0.18) compared to the ground truth
values. Your response should be formatted as: <<<x' s value y's value>>>, e.g., if x=1 and y=2, then it should be <<<1 2>>>
B.3.2 DYVAL-L
VAL-LL also shares natural compatibility with the structured representation of T-DAGs due to the innate progression and dependencies inherent in logical constructs. The tasks are:
Boolean Logic: Similar to arithmetic task, it primarily revolves around the manipulation and com- bination of True and False values using operators: AND, OR, NOT. The problems are presented as: what is the truth value of [Root]?
Here is a description of a boolean logic problem:
aaa is Truc.
The value of aab equals to (NOT aaa)
The value of equals to (NOT aab).
Compute the result of aac. If the solution can not be calculated, 'N/A". Ensure your final result begins with reee and ends with '>>>', for example, if the answer is True, your final result should be <<cTrue>>>.
Deductive Logic: The process of deductive logic similar boolean logic, but deduction intro- duces a bit complexity compared to boolean logic inference. For instance, given premises A (True) and B (False), and the relationship (A A B) + C, the value of conclusion C' remains undeter- mined because the conjunction (A A B) is false. Given the description of T-DAGs, the problem is formulated as By the rule of deduction, what the value of [Root]]
Here is a description of deducti ve logic problem:
aab is True.
аaa is True.
(aaa and aab) -> aac.
aad is False.
(NOT aad) aae.
(aac or aac) aaf.
The symbol r-x represents a deductive relationship, e.g., A -> implies that it A true, then 3 true. A false, B's truth value remains undetermined (N/A) Deduct the result of aaf. If the
19

---

Published as a conference paper at ICLR 2024
solution not be abducted, answer 'N/A'. Ensure your final result begins with rees' and ends with '>>>', for example, if the answer is True, your final result should be <<<True>>>.
Abductive Logic: aims to hypothesize the most likely cause or explanation based on observed outcomes. When working with T-DAG, assign random value the node. Then, randomly select a leaf node, the problem is to determine the leaf node' value based on the given the DAG structure and root's value. The task description Given the value of [Root] [val luel, what is the value of [Ncde]?
Here is description of abductive logic problem:
(aaa aab) (NOT aac) aad.
Given aad False, what is the value of aab?
The symbol '->² represents deductive relationship, e.g., A -> implies that if в false, then is false. If is true, A's truth value remains undetermined (N/A) If the solution can not be deducted, answer 'N/A". Ensure your final result begins with <<<'' and ends with '>>>', , for example, if the answer is True, your final result should be <<<True>>>.
B.3.3 DYVAL-A
DY tasks is suitable for D-DAG since they aim to model the real-world applications. Among many problems that can be abstracted and modeled as a G-DAG, here we select two representative tasks.
Reachability: A classic example of where G-DAGs shine is in modeling problems like the reach- ability of two nodes in the DAG. Given various nodes representing cities and links indicating roads between them, the question models can help deduce the if there exists route from one city to an- other. Thus, the description for this task is: "Can the [Nodel] be reached by [Node2]" where Nodel and Node2 are randomly selected from the nodes G-DAG.
Given a rirected graph:
aai points to: (None) aad points to: (aai).
aaj points to: (aai).
aah points to: (aai, aac, aaj).
aag points to: (aac).
aaf points to: (aag, aah, aaj).
aab points to: (aaf, aah)
aas points to: (aag, aah, aaf, aaj).
ase points to: (aai, sac, aaa).
aad points to: (aab, aaf, aae).
Can aaf be reached starting from aag?
Respond with either '<e<True>>>' if reachable, or '<<<Fale>>>>> otherwise. se.
20

---

Published as a conference paper at ICLR 2024
Max sum path: Compared reachiability problem, max sum path more complex. This problem assign a value for each city, and then requires to find path from two cities that the sum the values the path go through is maximum. It requires the LLMs to find all the path between two nodes, and then determine the path with maximum value. The description for this task is what. is the max sum path from [Node 1] to [Node 2]?
Given directed graph with values assigned each node: aaj points te: (None)
aah points to: (None)
aai points to: (aah)
aag points to: (aai).
aac points to: (aag).
aab points to: (aac, aag)
aaf points to: (aai).
aae points to: (aac, aah)
aad points to: (aag, aae, aaj).
aaa points to: (aae, aai, aaj, aad)
The value of aaj is 9 The value of aab is 8
The value aah is
The value aaf is 3
The value of aai is 3
The value of aae is 3
The value of aad is 6
The value of aac is 4
The value aag is 8
The value aaa is 4
What's s the maximum sum path from aaa to ase? For exmaple, the value of the path A->B->C is obtained by summing the values of nodes A, B, and C. Please format your response as <<<answer>>>, For example, if the answer 1, it should be presented as <<<1>>>.
B.4 DESCRIPTION ORDER
This approach sequences the description of nodes in manner where every node is introduced after all its descendent nodes. Such a sequence ensures that leaf nodes are laid out prior any operation that utilizes them (e-g., addition logical AND).
Topological Order:
Reversed Topological Order:
Taking an almost counter-intuitioe approach, this order starts by spotlighting the culminating nodes outcomes. Once these results laid bare, the narrative retraces its steps, navigating backwards to the root nodes or primary inputs.
Random Order: This unstructured method presents nodes in random sequence, irrespec- tive of their dependencies within the DAG. Such a disordered narrative challenges LLMs to independently connect the dots and derive patterns.
21

---

Published as a conference paper at ICLR 2024
Fg g
FT
Arithmetic
Linear Equation Cis orodded
20+3ye5 Asadynii
F gets its value by dividing from
Topological Order
18
IS
18
16
Boolean Logic litha
Deductive Logic
Abductive Logic
Reversed Topological Order
A
B
C
Random Order
Reachability
Max Sum Path from Alt
4
is
IS
Figure Description function of arithmetic task.
Figure 9: Descriptions of 7 tasks.
B.5 POTENTIALS USING GPT-4 TO GENERATE DESCRIPTION FUNCTIONS
In this section, explore the potentials in using GPT-4 to generate natural and contextualized problem descriptions rather than the plain ones in Section B.3
We simply feed the following instruction GPT-::
"Here is description of an arithmetic problem, please generate an application math test using the following information. not change the exact numbers. Note that the test should be contextualized, real applicati test, instead of the plain description." followed by the DYVAL- generated problems such as the one in VAL-M..
Then, GPT-4 will generate the following application problem which is more vivid:
Problem:
Imagine you are managing small warehouse The warehouse has a total storage capacity of 9 large crates (represented by 'aaa'). You also have acditional area that stere 3 more crates (represented by 'aab').
Recently, you purchased a set of special crates (represented by 'aad') that are stackable. when stacked, these crates take the space of 2 regular crates.
Your task is to calculate the tctal storage capacity of your warehouse after adding the stackable crates and utilizing the additional storage area.
Steps:
Identify the tctal initial capacity (aaa). Identity the additional capacity (aab) Calculate the effective space taken by the stackable crates (aae) consider them a single unit after stacking. Calculate the new total capacity by adding the initial and additional capacities (aac). Finally, adjust the total capacity by considering the space taken by the stackable crates (aaf). Question:
what is the new total storage capacity of the warehouse after these adjustments?
(Use the given values and operations to solve the problem)
22

---

Published as a conference paper at ICLR 2024
While the above application problem looks more vivid than the plain one, it is in fact challenging to verify its rationale and correctness. For instance, is the problem natural? Is the context correct? Note that GPT-4 tends to first compute the answers to the original problem before generating new one, which may accumulate errors including problem understanding, application generation, and computation. Therefore, while point the feasibility of such practice, this in current stage is difficult to verify and should be left for future work.
C PROOF
Theorem C.1. Given a tree-based DAG with depth d and width if the operation set for non- leaf nodes has & distinct operations and the value set for leaf nodes contains n distinct values, the
X 12 u
probability that two independently generated DAGs are identical is: P
Proof. To determine the overall probability, we analyze the likelihood at each depth and then multi- ply these probabilities. For depth i, the number of nodes is w'-1,
For depth 1 < i < d 1. Since these nodes are non-leaf nodes, the probability they are identical two independently generated DAGs is the likelihood all of them have the same operations: pt
kw
For the leaf nodes at depth d, the probability that they are the same across two DAGs is: Pd
Thus, the overall probability P that two DAGs are identical is: P II Ps X Pa-
Substituting the above expressions and simplifying gives the result: P
k
nd-I-1 w-
nw
Note: We consider two trees to be distinct even if they only differ in the order of operations. For instance, the tree representing 3x 5 is considered different from the tree representing 5x3. Excluding such cases may be non-trivial and is unlikely to significantly affect the odds.
Theorem C.2. Given a general DAG with nodes where each node has minimum 2 links, the lower bound of the probability that two randomly selected DAGs of this configuration are identical is ((n- 1)!)-
Proof. Consider DAG where each node has exactly outgoing link. The first node can be connected to any the remaining π - nodes. Subsequently, the second node can connect to any of the remaining logic, the third node can connect to any of the n 3 unconnected nodes, and so on.
2 nodes, excluding the one already connected to the first node. Following this
Thus, the total number of distinct DAGs that can be constructed under these constraints is given by: (n 1) x (n 2) x x 2 = (n 1)!
Given two randomly chosen DAGs of this kind, the likelihood they are identical is the inverse of the number unique DAGs: (n-1))
This probability serves as the lower bound when considering the general case of DAGs with nodes having minimum of > links, hence proving the theorem.
D DETAILS OF EXPERIMENTS
D.1 EXPERIMENT ENVIRONMENT
All experiments are conducted on a workstation equipped with an NVIDIA V100 GPU with 16GB memory and A100 GPU with 80GB memory. For GPu-o.5-Turbo and GPT-4, OpenAl's
23

---

Published as a conference paper at ICLR 2024
API for inference, the versions are gpt-3.5-turbo-0613 and gpt-4-0613. For the Llama2 models, downloaded from the Llama2 github repository and follow the instruction to convert them into huggingface models. For Vicuna- 13B-v1.3, Vicuna-13B-v1.3, we downloaded it from its github repository The remaining models can be downloaded directly via huggingface.
D.2 PROMPTS
Arithmetic:
Here is description of an arithmetic problem:
(
Compute the result (). If the solution cannot be calculated, answer "N/A". Ensure your result is within a relative precision of 0.0001 (or 0.018) compared the ground truth value. Ensure your final result begins with <<<'' and ends with '>>>', for example, if the answer your final result should <<<>>>>
Linear Equation:
Given the follewing linear equation system with two variables:
{}
Determine the values of and y. Ensure your results
within relative precision of 0.001 (or 0.18) compared to the ground truth values. Your response should formatted value>>>, e.g., if x=1 and y=2, then it should be <<el 2>>>
<<<x's value y's
Boolean Logic:
Here is description a boolean logie probiem:
Compute the result (. If the solution can not calculated, answer 'N/A". Ensure your final result begins with '<c<" and ends
with '>>>', for example, if the answer is True, your final result should be <<<True>>>,
Deductive Logic:
Here is description a deductive logic problem: {
The symbol r-x1 represents deductive relationship, e.g., A implies that if A is true, then B is true. If A is false, B's truth value remains undetermined (N/A) Deduce the result of (). If the solution can not be deduced, anawer "N/A'. knsure your final result begins with '<<K" and ends with <>>>', for exampie, if the answer is True, your final result should be <<<True>>>,
Abductive Logic:
Here is description of an abductive logic problem: [) The symbol '->- represents deductive relationship, e.g., A -> B implies that if is false, then false. is true,
wwwpyy/ww....n.aoogoooooo/o//aan llama weights to hf.py haaps:/ggthhh..cmm/msssyaaaaaaa
24

---

Published as a conference paper at ICLR 2024
truth value remains undeterminee (N/A) If the solution be abduced, answer "N/A" Ensure your final result begins with '<s<! and ends with '>>>' for example, if the answer is True, your final result should be <<<True>>>.
Reachability:
Given rected graph:
Respond with either <<<TTru>>>>' if reachable, or r<<<False>>>> otherwise.
Max Sum Path:
Given a directed graph with values assigned to each node:
{
For exmaple, the value of the path A->B->C is obtained by summing the values of nodes A, B, and C. Please format your reaponse <<<Ånswer>>>, For example, it the answer is it should be presented as <<<l>>>.
D.3 EVALUATION SET
We categorize tasks into four complexity levels, denoted as DI to D4. For tasks reliant general Directed Acyclic Graphs (DAGs), the node count set to 7, 10, 15, 20. Each these nodes pos- sesses maximum link range of 4, 6, 8 and minimum link count of 1. Conversely, for tasks that utilize tree-based DAGs, the tree depths and widths are defined as (2,2), (3, 2), (3, 3). (4, 2). in order of increasing complexity.
The range of these datasets progresses from simple to intricate. To illustrate, an arithmetic problem with tree depth of represents basic two-variable arithmetic computation. In contrast, task with a tree depth of exhibits heightened complexity, necessitating multiple inferential steps for resolution.
D.4 DETAILS OF EXPERIMENT RESULTS
We do not report the results Flan-T5-large, phi-1.5, WizardMath-133. and Xwin-13B since their performance almost 0 even on simplest evaluation sets generated by our DY Therefore, we extensively run the results of four remaining models: Vicuna-13B-vl.. Turbo, and GPT-4. Table 3 and 4 report the detailed results (average error) of these models in different complexity D4) and different description generation orders (topological, reversed topological, and random orders).
GPT-3.5-
In the reachability task, as task difficulty escalated, 1aama2-13B-chaal performance paradoxically improved. Upon investigation, -lama22-13--chal essentially resorted to random guessing across datasets. The proportion of 'True" answers increased (from 40% in DI to 60% in D3), with 'False" responses being nearly absent. The remainder were non-responses, thus elevating the overall accuracy. The observation is similar to those made in Sec 4.4 where we investigated the influence of different model size.
Further, generation description order affects outcomes: in the reachability task. GPT-4's accuracy drops by 13.67% when given reversed order compared to topological order. See Appendix D.4 for details of experiment results.
D.5 DETAILS OF CASE STUDY
We select 20 failure cases of the most challenging datasets of arithmetic, deductive logic, abductive logic, and reachability of GPT-4.
25

---

Published as a conference paper at ICLR 2024
Table 2: Results for Mathematic Tasks
Task
Dunsee
CPPT
ChaGPP
Llunad. Bbedal
Viaume 1lbe133
Topo
Revense
Rand
Topo
Reversed
Razd
Topo
Revened
Read
Togo
Revessed
Razd
12
59 Shats
V1.27am
12.83a0m
36.07
24 20
2.40ae
Arilhuatic
94. 17atus
85
37.67.141
14.35
15.50.10
90.47-117
76.20
02.27a
78477130
92.07
5.73-141
1077.u0
247.003
3.77 207s
4,00us
1:13
1.53
0.07aei2
0,07
0.20uex
0:00.::
77.77
72.7%are
60.40
56.33a
18.50.0m
56.33
16.20.104
36 36.20
36.27424
0.00
0.00
0,00
0.00
Lanzar
122
42.67am
42 17
43.00
17.67111
10.57a11
20.60
0.00
0.00
0.0
0.00eam
(10)se
000
Equation
D3
44 Statoo
4% 48.17ax
43.8
19.40a11
23.574:10 79.674104
0.00
0.0
0.0
0.00saa:
0.00s:
D4
38.833425
37,17
34.00.100
13880.105
21,07/259
14.93120
0.000.00
0,00.009
0,001.:00
0,0021::0
0,000.:00
Table 3: Results for Logical Reasoning Tasks
Datasci
GPT4
ChorIPT
Lamul- Bb-cha
Vicuras 1b-el_3
Tapo
Tope
Resence
Tope
D1
100.00 asm
150 80
100:00
90 22.
90.87
97 60.600
25.33
12 23
19.53
77.83
64.93
81.
Bockan
D2
100:002mmm
W. Than
100: 100:00amm
9% Min33s
59 60la33
96 M0
7.87
17:0
4310 18.67
m
51 51.9%21 as
Logic
D3
$7.00.1.0
100000
100:00as
99.00 235
95,00
92.90 21
13.33
20.07..:5
17.93.c3
28.93
39,67 39,67 42.4712.0
99 49.67
90-402301
95.47
47
10.77e
19:9
16. 16.3
20.20z1 m
20.3
20 20-00am
Deductive
98.50
92.50ucat
97.174
65.03
43.60134
34.47-1
43.07
48.00-33)
38.75xca
44.57.0m
17
87 Ne
98 Stano
61.477744
61.500770
76.000m
36.77p17
46
65.77am
54.7
D4
96, 17
64
90.67
15.40.173
47.33
56.47.200
20.001154
20.20
30,60.1
38,07-113
37,40.12:
33.40.3.7
D1
63 33
91.00
37.00
43.33
35. -22
3.73
0.00-00
1,73
56.40-323
31,60.13:
43.53-2.
Abductive Logic
76.81 K7
51.472293
11:77211
10:51::0
1767
19:00
29.47am
21:0::1
64.67.88
49.83
38.501338
36.13
60.50.u6
37.87
12.00
7.60-22
a.07
20.40.131
14.80
17.20
Here present one failure case for each error type.
Partial calculation error It has been observed that GPT-4, in certain situations, commits errors in intermediate computational steps, while it maintains correctness in the remaining steps. This characteristic anomaly is not isolated to complex calculations. In fact, not only complex calculation, seemingly straightforward calculations such as can be incorrectly computed. This observed behavior consistent with the findings presented by (Dziri al., 2023), where they highlighted that low-level learning models (LLMs) occasionally produce results that are only partially accurate, particularly in the realm of multi-digi multiplication.
Input:
Here is a description of an ari problem:
The value of aaj is 7.
aak gets its value by squaring the value that aaj has.
The value of aah is 6.
The value of aag is 2. aai gets its value by dividing the value of aag by those of aah. aan gots its value by multiplying tegether the value of aai and aak. The value of aaa is 6.
aab gets its value by squaring the value that aaa has.
The value of aac is 8. The value of aad is 1.
Table 4: Results for Algorithm Tasks
Task
Dataser
GPT4
Chacet
Llan2: 13b-chat
Vicuma 136-1.3
Toys
Reversal
Rana
Topo
Reseraal
Rand
Topoo
Reveread
Raad
Topo
Resersed
Rond
63.67..115
85.33
(3.67
43.400144
21.60.130
23.20
26.771
11.47
20.800210
23.53.130
Reachabilrty
17
91.001100
83.0012
54
34,60.140
2657
27
12.07
31.731644
21.73.000
13.00..1
76.67.055
49.40
59.131549
52:33,2
33.67.287
41.53112
38.00.00
10,00097
12.00.144
D1
37.33 m:
30.67a41
26.07.400
29.47.1m
29.671253
25
0,001am
0.20aum
0.001a0e
0.00uc.0
0,00a00
Mas Sum
D2
18.07
27.00ccs:
37.67
14:20kmm
13 13.88am
11 11.5usm
0.00aam
0.00aam
0.0ee m
0.00amm
Put
D3
21.33
3434
17.00
16.671416
6,401164
8.00115
7.60.07s
0,001xm0
8.00
0,00
0.001100
0.00.c00
0.00azo
16.7
12.00ucmm
1067es
5:07
6:30pmm
66771
0.00smm
0.00samm
0.00aam
0.00ssse
0.0ss
0000am
26

---

Published as a conference paper at ICLR 2024
aae gets its value by dividing the value of by those of aad. aaf gets its value by dividing the value aso gets its value by adding together the value aaf and aan.
by those aae.
Compute the result of aao. If the solution cannot be calculated, answer 'N/A., Ensure your result is within a relative precision of 0.0001 (or 0.018) compared to the ground truth value. Ensure your final result begins with '<ss' and ends with '>>>', for example, if the answer is 1, your final result should be <<<i>>>.
GPT-4's response:
First, let's calculate the values stop by step:
aaj 7
aak aaj" 7 49
aah
aag 2
aai aag aah / 0.3333
aan aai aak 0.3333 * 49 16.3167 (should be 16.3317)
aaa 6
aab aaa² - 62 36
aad
aae aac aad /
aaf aab aac 36 / 4.5
aao = aaf + aan = 4.5 16.3167 = 20.8167
So, the result of aao is 20. 8167.
Therefore, the final result is <<<20. 216622.
Ground truth: 8333
Incorrect reasoning When tasked with reasoning, GPT-4 can occasionally falter in rule interpre- tation, especially in abductive logic task.
Input:
Here is a description of an abductive logic problem:
(aaa and aab) -> aac.
(aae or aaf) -> aag.
(aah or aai) -> aaj.
(aag or aaj) aak.
(NOT aac) aad.
(aad or aak) -> aan.
Given aan is False, what is the value of aab?
The symbol '->" represents deductive relationship, e.g., A -> implies that if B is false, then A is false. If is true, A's truth value remains undetermined (N/A). the solution can not be abduced, answer 'N/A", Ensure your final result begins with <ece and ends with
27

---

Published as a conference paper at ICLR 2024
'>>>', for example, if the answer is Truc, your final result should be <<<True>>>.
GPT-4's response:
Given aan is False, it means either add aak must be False (both aad and aak should be False) (since aad or aak aan).
If aak False, then either aag or aaj must be False (since aaq or aaj -> aak)
If aag is False, then either aae or aaf must be False (since aae or aaf -> aag)
If aaj is False, then either aah aai must False (since aah aai -> aaj). However, none of these conditions provide any information about aab. Therefore, the value of aad cannot be abduced from the given information.
So, the answer is <<<M/>>>>. Ground truth: N/A
Self Contradiction GPT-4, occasion, presents self-contradictory assumptions during the same inference in an abductive logic task.
Input:
Here is description of an abductive Logie problem:
(aah or aai) -> aaj.
(NOT aaj) >> aak.
(aad or aac) -> aaf.
(aaa or aab) -> aac.
(aac aaf) -> aag.
(aag or aak) aan.
Given aan False, what the value of sah?
The symbol r->1 represents a deductive relationship, e.g., A -> implies that if B is false, then A is false. If B is true, A's truth value remains undetermined (N/A). If the solution can not be abduced, 'N/A". Ensure your final result begins with "<<"" and ends with ">>>', for example, if the answer True, your final result should be <<<True>>>.
GPT-4's response:
Since aan is False, at least of aag aak must be False. However, don't know which value of aah. (This inference step contradicts to the former example, where GPT-4 assumes aah is False.) Therefore, the answer is /N/A.
False, so we can't determine the
<<<N/>>>>
Ground truth: N/A
Unsubstaintiated response A recurring observation in both reasoning and algorithmic tasks GPT-4's propensity to provide answers without accompanying justifications. These succinet, answer-only responses raise concerns about the depth of GPT-4's understanding and whether its ap- proach is grounded actual comprehension or simply a result of memorization. This error mostly happens in algorithm tasks and occasionally happens in logical reasoning tasks.
28

---

Published as a conference paper at ICLR 2024
Input:
Here is a description of an abductive logic problem:
(aaa or aab) -> aac.
(aad or aae) -> aaf.
(aac aaf) -> aag.
(NOT aah) aai.
(NOT aaj) aak.
(aai or aak) -> aan.
(aag or aan) -> aac.
Given aao is False, what is the value of aaa?
The symbol r->! represents deductive relationship, e.g., A -> implies that if B is false, then A is false. If is true, A truth value remains undetermined (N/A) If the solution can not be abduced, answer 'N/A.. Ensure your final result begins with reee" and ends with <>>>' for example, if the answer is True, your final result should be <<<True>>>,
GPT-4's response:
<<<N/>>>>
Ground truth: N/A
Instructional oversight Interestingly, while GPT-4 often computes accurately, it sometimes fal- ters when comes to precisely following the output instructions as described in given prompts. This discrepancy points to a potential gap in the model's ability to parse and adhere to intricate instructional details, even when the underlying computational capability is sound.
Input:
Here is a description of an arithmetic problem:
The value of aac is 6.
The value of aai is 6. The value aag is 8.
aan gets its value by subtracting the sum the values aak aae from the value of aah.
aаo gets its value by multiplying together the value of aae and aan and aae.
aah gets its value by multiplying tegether the value of aaf and aag and aac.
The value aap is 1. The value of aaa is 6.
aad gets its value by taking the square root of the value that aac has.
The value of aaj is 4.
aak gets its value by subtracting the sum of the values aaj and aae from the value of asi.
The value of aaq is 7.
aar gets its value by dividing the value of aap by those of aaq.
29

---

3. aag Published as a conference paper at ICLR 2024
aab gets its value by squaring the value that aaa has.
The value aaf is ase gets its value by multiplying together the value of aab and aad and aai.
Compute the result of aao. If the solution cannot be calculated, answer 'N/A", Ensure your result is within a relative precision of 0.0001 0.018) compared to the ground truth value. Ensure your final result begins with <<<'' and ends with '>>>', for example, if the answer is 1, your final result should be <<<1>>>.
GPT-4's response:
Let's solve this step by step:
1. aac
2. aai
4. aaa 6
5. aad
sqrt (aac) - sqrt (6)
6. aaj 4
7. aaq
aap
9. aaf 10
10. aab aaa² 62 36
11. aae aab aad * aai 36 * sqrt(()
12. aak = aai (aa) aac) = 6 (4 + 36 sqrt (6) 6)
13. aah aaf aag aae 10
36 sqrt (6)
14. aah (aak ase) 10
36 sqrt (6) 6 (6
sqrt (6) * 6) 36 sqrt (6) 6)
15. aao aae aan + aae (36 (6) * 6) (10
(6) 6 (6 (4 36 sqrt(6) 6) 36 sqrt (6) 6)) (36 sqr 6)
This is complex calculation and it's not possible to simplify it further. Hewever, it's clear that the result will be a very large number. Since the problem doesn't provide any constraints on the values of the variables, we can't say that the solution is "N/A'. (The equation is correct however GPT-4 did not simplify it. In our experiment, we found that GPT-4 does not originate from them.)
handle large numbers, the
So, the result of aso a very large number that can't be simpli fied further.
Ground truth: 11848342359.78579
D.6 DETAILS OF VARING COMPLEXITY CONSTRAINTS
As shown in F we systematically vary the levels complexity GPT-3.5-Turbo by adjusting individual constraints while keeping others constant. Specifically, explore how performance metrics evolve as we incrementally adjust depth, width, #nodes, #max links, the number of extra links, and the quantity of random descriptions across arithmetic, boolean logic, and deductive logic tasks. To comprehensively evaluate the impact complexity constraints, various parameters were meticulously adjusted. The following elucidates the configurations employed:
30

---

Published as a conference paper at ICLR 2024
Table 5: Results of GPT-3.5-Turbo with prompt engineering techniques on the toughest evaluation sets generated by Dy DYVAL (D4).
Table 6: Results of Llama
with different sizes on DY-
VAL- VAL-generated evaluation
Prompt engineering
Anthmeticc
Equerien
Lincer
Dolnectivn Lnglc
Abdiativve
Lagic
Reachahility
ples (DI),
43.7%
Size
Anthmetic
Doolean
Reachabilitt
Frosdey
35.93
13:07
28.93
29.53
13b
24.20
19.53
26.53
706
28.30
47.38
32.07
13.00
63,00
78.27
71.40
11,50
Maintaining the width at 2, with neither the addition of random links nor the embedding of extra descriptions (both set to O), the depth was systematically varied, with
Depth Constraint:
values set 2, 3, 4, 5, and
Width Constraint: With a fixed depth of 3, and with the addition of random links and embed- ding of extra descriptions both neutralized to O, the width was tested with the values 2,3, 4, 5, and 6.
Random Link Addition Constraint: For this, a depth of 4 and width of were maintained, with extra descriptions set to O. The number of random links introduced varied as 0, 1, 2, and 4. should highlighted that due to the inherent acyclic constraint, certain nodes may preclude the addition of extra links.
Embedding Extra Deseriptions: With a depth and width fixed at 4 and 2, respectively, and no addition of random links (set to 0), the levels of embedded extra descriptions were calibrated to 0, 1, 2, 3, and 4.
Across these variations, our results consistently underscore notable trend: the tasks become more intricate through the augmentation of these complexity parameters, LLMs progressively strug- gle, underscoring the inherent challenges posed by increasing task intricacy. It can be observed that depth is the most influential complexity constraint of tree-based DAGs, indicates that LLMs struggle deal with problems that requires more inference steps.
D.7 DETAILS OF PROMPT ENGINEERING
We explored five prompting techniques to evaluate their potential impact on our most challenging datasets (excluding boolean logic since GPT-3.5-Turbo achieved comparable results on most chal- lenging datasets): Zeroshot-CoT (Wei et al. 2022). Few-shot (3-shot in our experiments) (Brown al. 2020), Least-to-most (Zhou et 2023b), automatic prompt engineering (APE) (Zhou al., 2023d), and skill-in-context (SkiC) (Chen et al. 2023). The details of these techniques are as fol-
lows:
Zeroshot-CoT: An approach that allows models to generalize from their pre-training without explicit examples in the target task (Wei et al. 2022).
Fewshot (3-shot in our experiments): Provides the model with small number of examples from the target task to aid understanding and generalizing to the broader task (Brown et al.)
2020
Least to Most Prompting: This technique incrementally provides more specific prompts to guide the model's responses, adapting the prompt based on the difficulty level of the problem
ZZhou et al., 2023b).
Automatic Prompting Engineering (APE): A method where prompts are automatically engi- neered to elicit the desired response from the model, often maximizing its performance (Zhou
et al. 2023d).
Sxill-in-Conteds (SKiC): This method seeks to understand a model's inherent skills and utilize them in specific context to improve its outputs (Chen et al. 2023
D.8 HUMAN STUDY
We conducted our human study by obeying the local laws and regulations. The demographics of the human subjects are shown in Table
31

---

Published as a conference paper at ICLR 2024
Table 7: Demographies of the recruited human subjects.
Sex
Age
Degree
Male: 63 (63%)
20-25: 75 (75%)
Bachelor: 62 (62%)
Female: 37 (37%)
26-36: 25 (25%)
Master: (38%)
E DETAILS OF FINE-TUNING
E. CONSTRUCTING TRAINING DATA
The training data includes the problems and their corresponding inference steps. Constructing in- ference steps is similar the DAG description. For mathematics tasks and logical reasoning tasks, which utilize T-DAG, we follow the topological order to describe how the intermediate gets its value from its children. For algorithm tasks, the inference are indeed an algorithm, thus, we formalize each step in the algorithm into natural language, which finally form the inference steps. Following list presented training sample of each task. Note that the inference steps for each task are also highly flexible and can be augmented with more details, and we believe that the more detailed inference steps will benefit more.
Arithmetic:
Input:
Here is description of an arithmetic problem: The value of aae is 2.
The value of aad is 4.
aaf gets its value by dividing the value aad by those ase. aag gets its value by taking the square root of the value that aaf has.
Compute the result of aag. If the solution cannot be calculated, answer 'N/A', Ensure your result is within a relative precision of 0.0001 (or 0.01%) compared to the ground truth value. Ensure your final result begins with '<ee" and ends with '>>>', for example, if the answer is your final result should be <<<i>>> Inference steps:
2.0
aad is 4.0
aaf aad / aac 4.0 2.0 2.0 aag sqrt aaf = sqrt (2.0) 1.41421356
Thus, the answer is <<<1.43 414.142223356>>
Linear Equation:
Input:
Given the following linear equation system with two variables:
aag0 -6 = -6
-2 x 6
The calculation of aag0 is defined as: The value of aab0 is 10. The value of aaa0 is 6. aaco gets its value by adding together the value aaa0 and aabC. The value of aad0 is 6.
The value of aae0 is aaf0 gets its value by multiplyin together the val ue of aad0 and
32

---

Published as a conference paper at ICLR 2024
aae0.
aag0 gets its value by multiplying together the value of aaco and aaf0.
Determine the values of and y. Ensure your results relative precision of 0.001 (or 0.18) compared to the ground truth values. Your response should be formatted as: <<xx' value y's value>>>, e.g., if x=1 and y=2, then it should be <<<l 2>>> Inference steps:
within
Let's first solve the coefficients of the linear equation.
aab0 is 10.0
aaa0 is 6.0
aac0 aaa0
aab0 6.0 + 10.0 16.0
aad0 is 6.0
aael is 1.0
aaf0 aad0
aae0 6.0 1.0 6.0
aag0 aac0 aaf0 16.0 * 6.0 96.0
Thus, aag0 96.0
Next, solve the linear equation:
96.0 x 05.0y=-- -6.0
-2.0 6.0 y 0.0
eliminate 'y', muitiply the first equation by and the second equation by -6. This makes the coefficients of 'y' equal. Subtracting the second equation from the first then gives: 564.0x -36.0.
From the equation 0x = -36.0, we can solve for x. 0.06382979.
Solving for x, get Substituting x = -0.06382979 into the first original equation, we get: -6.0y 12765999,, which gives -0.02:2766.
Thus, the answer is <<<-0, <ck-0.06382979 -0. 0212766>>>
Boolean Logic:
Input:
Here is description boolean logic problem:
aaa is False.
aab True. The value of aac equals to (aaa OR aab) aad False. aac is Falsc. The value of aaf equals to (aad AND aae)
The value of aag equals to (aac AND aaf).
Compute the result of aag. If the solution can not be calculated,
answer 'N/A". Ensure your final result begins with reck and ends
with <>>>', for example, it the answer is True, your sinal result should <<<True>>>, Inference steps:
is False. aab is True. aac (aaa aab) (False OR True) True.
aad is False.
aae False. aaf (aad AND aae) (False AND False) = False.
33

---

Published as a conference paper at ICLR 2024
aag (aac AND aaf) (Truc AND False) Falsc.
Thus, the is <<<False>>>
Deductive Logic:
Input:
Here is description of a deductive logic problem:
aaa False.
aab is False.
(aaa or aab) -> aac.
(NOT aac) -> aad.
The symbol '->' represents deductive relationship, e.g., A -> implics that if is true, then B is true. If A is false, B's truth value romains undetermined (N/A), Deduce the result of aad. If the solution can not be deduced, answer 'N/A'. Ensure your final result begins with '<<<' and ends with '>>>', for example, if the answer is True, your final result should be <<<True>>>. Inference steps:
False.
aad is False.
(aaa OR aab) (False OR False) aac.
The premise (False OR False) is False, thus, the value of aac carnot be deduced and set to N/A.
(NOT aac) = (NCT N/A) -> aad. The value of aad cannot be deduced, and is set to N/A.
Thus, the answer is <<<N/>>>>
Abductive Logic:
Input:
Here is description of abductive logic problem:
(aad or aae) -> aaf.
(aaa or aab) (aac or aaf) -> aag.
a&c.
Given aag is False, what is the value aab?
The symbol h->² represents deductive relationship, e.g., A -> B implies that if is false, then A is false. If B is true, A's truth value remains undetermined (N/A). If the solution abduced, answer 'N/2, Ensure your final result begins with 'see' and ends with <>>>', , for example, is the answer is True, your final result should be <<<True>>>. Inference steps:
not be
(aac OR aaf) -> aag = False. Given aag is False, the value premise (aac OR aaf) False, thus, the value of aac is abduced as False.
(aaa OR aab) -> asc False.
Given aac is False, the value of premise (aaa OR aab) is False, thus, the value of aab is abduced as False.
Thus, the answer is <<<False>>>
Reachability:
34

---

Published as a conference paper at ICLR 2024
Input:
Given a directed graph:
aag points tor (None)
aaf points to: (None)
aaa points to: (aag, aaf)
points to: (aaa).
aab points to: (aaa).
aad points to: (asa).
aae points to: (aad).
Can aag be reached starting from aaf?
Respond with either <<<True>>>> if reachable, or <<<Pals>>>>>> otherwise
Inference steps:
Starting the search process from node aaf with the goad to reach node aag.
Checking node aaf.
Node aaf has no unvisited children. Moving back. Exhausted all possible paths without reaching node aag.
Thus, the answer is <<<False>>>
Max Sum Path:
Input:
Given a directed graph with values assigned to each node: aag points tc: (None).
aaf points to: (aag).
aae points to: (aaf, aag)
aab points to: (eaf).
aad points to: (aab, aac)
aac points to: (aag, aad)
aaa points to: (aac, aag, aae)
The value of aaa is 3 The value of aab is The value of aaf is 5 The value of aag is The value of aae is 1 The value of aad is The value of aac is 2 What's the maximum sum path from aab to aae? For exmaple, the value of the path A->B->C is obtained by sunning the values of nodes A, B, and C. Please format your reaponse <<cAnswer>>>, For example, if the answer is 1, it ahould d be presented as <<<l>>>.
Inference steps: Starting the search for the maximum sum path from node aab to node aae.
Reaching node aab with current sum of 2. Now, we explcre the children of node aab: aaf. Reaching node aaf with current sum of 7. Now, we explcre the children of node aaf: aag. Reaching node aag with current sum of 12. Node aag has no children. Moving back. There is no path from node aab to node aae.
Thus, the answer is <<<N/>>>>
35

---

Published as a conference paper at ICLR 2024
E.2
TRAINING DATA AND TESTING DATA
E.2.1 TRAINING DATA
For mathematical tasks and logical reasoning tasks that utilize T-DAGs, we construct four types of training datasets. Each dataset consists of 500 training samples. All of these types have a depth of 3. The settings are follows:
1. width=2, add random links=0, embed random descs=0,
2. width=2, add random links=1, embed random descs=0,
3. width=2, add random links=1, embed random descs=1,
4. width=3, add random links=0, embed random descs=0.
For algorithm tasks, types of training datasets generated:
1. num nodes=7, max links per node=3,
2. num nodes=10, max links per node=4.
E.2.2 TESTING DATA
We create three types of testing data:
1. In-Distribution (ID) Test Set: The difficulty level matches that of the training set.
For T-DAGs: depth=4, width=2, with extra links and random descriptions.
For G-DAGs: num nodes=15 with max links=6.
2. Out-of Distti-Distiittiinnn (OOD) Test Set:
For T-DAGs: depth=4, 2idth=2, without extra links and random descriptions.
For G-DAGs: num nodes=15 with max links=6.
3. Outtaf-Distribbttion-aaadd (OOD-hard) Test Set:
For T-DAGs: depth=4, width=2, with one extra link per node and one random description.
For G-DAGs: num nodes=20 with max links=8.
Note that the definition of OOD in our tasks is mainly on the different complexities of the samples that may with more advanced structures or descriptions. For model evaluation, when using the
VAL generated testing data, a zero-shot setting was adopted. For existing benchmarks, few-shot COT examples were provided in the context: 4 examples for GSM8K and SVAMP, 3 for FOLIO and RACO, and 2 for DP and LCS. The results of evaluation in our tasks are presented in Figure I0
E.3 RESULTS OF FINE-TUNING
We fine-tuned Llama2- 1-b-cchhtt with LORA (Hu al.) 2022) for epochs where the rank was 8, the scaling factor was 16 and the drop out rate was 0.05. We used 0.0003 learning rate with batch size 128. Results on existing benchmarks of the fine-tuned model Figure the main paper.
Figure 10 displays the results after fine-tuning our test datasets described in Sec E.2.2 The performance of 1lama2-13B-cht on tasks like boolean logic, deductive logic, and reachability sig- nificantly improves after fine-tuning areas such as mathematic tasks, abductive logic and the max sum path.
dataset. However, noticeable gaps remain, particularly
F IMBALANCED GENERATED DATASET
Our algorithm can easily satisfy the balance requirement by meticulously controlling the flexible dynamic generation process. For example, in reachability task, we can drop the generated evaluation samples with 'False' labels until generate sample with 'True' label. We presented the results of GPT-3.5-Tumm Turbo and GPT-4 in balanced datasets in Table g The results in balanced datasets are similar to initial findings: (1) G consistently predicted all questions "True.", resulted in a uniform accuracy rate of 50%. (2) GPT-4 demonstrated excellent performance. maintained significantly higher accuracy rates across all complexity levels.
36

---

generated datasets does Published as a conference paper at ICLR 2024
Vudti-OOn
Nivill-OO Gain PTC-0D laed
Ges FT-I
Guin PT-OD
1,0
0,8
0.6
62
Livent Fot
Buol Logts
Dediutive Logte
Alelnctive Longs
Beadalally
Max Sint Puth
Figure 10: Fine-tuned results on ID and OOD of our tasks. For arithmetic, linear equation, reachability and max sum path tasks, the vanilla accuracy is zero.
Table 8: Results of fine-tuned ChatGPT model on general natural langugage understanding tasks
Model
ChatGPT
GPT4
Complexity
D1
D2
D3
D4
D1
D2
D3
D4
Balanced
50
50
50
50
84.54
79.03
73.5
72.41
Imbalanced
63.87
54.27
53.73
52.33
85.33
83
67.67
74.33
G GENERAL LANGUAGE UNDERSTANDING ABILITY AFTER FINE-TUNING
We fine-tuned 9TT-3.5-turbo-0611 using our generated data on abductive logic and reachability datasets, GPT-3.5 performs worst these two datasets. Specifically, we generated 100 samples across complexity levels DI, D2, and D3 for each task. We compared the performance of original and fine-tuned models several benchmark tasks in GLUE dataset. The performance of abductive logic and reachability task are tested on D4 task (different from fine-tuning dataset). As shown in Table performance WNLI and QNLI datasets dropped for the fine-tuned model. However, fine- tuned model achieves better results on CoLA, QQP, and MRPC datasets. Despite the mixed results, the overall improvement in several datasets suggests that fine fine-tuning not necessarily hurt the general language understanding ability.
Table 9: Results of fine-tuned ChatGPT model on general natural langugage understanding tasks
Abductive Logie Reachability
SST-2
CoLA
WNLI
QNLI
QQP
MRPC
GPT3.5 GPT3.5-FT
55.27 85.10
50.00 96.53
93.29
77.00
59.15
80.00
76.50
73.0
93.23
78.00
45.07
72.50
78.00
77.5
H FLEXIBILITY TO NATURAL LANGUAGE TASKS
Finally, we discuss the flexibility of VAL while the main focus of this paper is on reasoning tasks. We show that DYVAL be easily extended to natural language processing tasks using an initial experiment on sentiment analysis.
Generally speaking, natural language sentence can be expressed syntax tree, similar DAGs. However, generating sentences through direct syntax tree construction (which is similar to the con- struction of arithmetic task) presents notable challenges, primarily due to the need for grammatical correctness and the inherent naturalness of these sentences. Nevertheless, DY VAL can still be ap- plied to generate tasks in natural language by utilizing syntax tree templates extracted by existing sentences. For each sentence in the SST-2 dataset, we initially employ GPT-3.5-Ture to extract its syntactic structure. Within each syntax tree (i.e., DAGs), we identify the elements that can be modified: namely, nouns (such names and places) and adjectives. GPT-3.5-Turbo is then used to create five alternative candidates for each of these modifiable components, which are subsequently replaced in iterative fashion. Throughout this process, continuously assess whether these replacements alter the original semantic meaning of the sentence. Any changes that result in a se- mantic shift discarded. Note that the graph cannot be randomly generated as the reasoning tasks
37

---

Published as a conference paper at ICLR 2024
since need to constrain the naturalness and grammar correctness of the generated sentences. As a remedy, the structure of the graph can be abstracted using the template sentences generated by GPT-3.5-Turbo.
We generate three alternative versions for each sentence in the above process, forming our newly generated dataset. We then evaluate the performance of both Flan-TS-large and Llama2-7b models, using the original SST-2 dataset as well as our generated dataset for comparison. The results of these evaluations are detailed in Table 10 It shows that using our generated samples, the performance drops, indicating that we are creating challenging test sets. Note that this is an initial study and extending Dy VAL to NLP tasks nontrivial that cannot be covered in this paper, but should be left for future work.
Table 10: Results for Logical Reasoning Tasks
Flan-T Flan-T5-large T5-large
Llama2-7b
Origin Dy Val
93.12 86.46
90.37
72.03
38


Reviews:
[{"review_id": "9mU1CVhcbM", "reviewer": "Reviewer_iwJv", "summary": "Presents a general framework to generate certain \"graph-based\" evaluation tasks for LLMs randomly, implements 7 example tasks, and presents and analyzes empirical results.", "questions": "None", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "S1. Simple, yet flexible framework.\nS2. Dynamic task generation with controllable complexity\nS3. Extensive evaluation of selected LLMs / prompting strategies for seven simple reasoning tasks.\n\nOn S1. The general idea of the proposed benchmarking framework is to generate tasks that can be described by a directed acyclic graph. This includes \"compute graphs\" (e.g., evaluate a numerical expression or perform logical reasoning) or \"data graphs\" (e.g., determine connectivity between vertices). The framework takes care of graph generation, task implementations add contraints, labels, solutions, and verbalization. This is a very natural approach and (most probably) how many of the existing benchmarks of this form are generated in the first place. Such a framework may increase usability, especially when many tasks were implemented in it.\n\nOn S2. Tasks are generated automatically and with varying complexity (mainly graph size). Again, this is a simple, very natural approach. Here the framework proposed by the paper may make comparative evaluation across a range of tasks more feasible, as all share the same notion of \"complexity\".\n\nOn S3. The paper reports performance results on simple computational tasks (such as evaluating simple equations). Generally, all models break down when complexity goes up so that the benchmark may be used as a way to evaluate progress. Also, the performance reported on these simple tasks sometimes contradict performance results published on related, static benchmarks.", "weaknesses": "W1. Certain computational tasks only\nW2. Discussion of related work / results lacking\nW3. Limitations in generated graphs\nW4. Code/data availability unclear\nW5. Limited insight of experimental study\n\nOn W1. By the nature of the benchmark, it focuses on problems that can be expressed as (currently small) compute graphs or data graphs and are somewhat artificial. It only tests a very limited field of LLM functionality.\n\nOn W2. There are benchmarks for all of the tasks that are implemented in this framework already. The paper states that its performance results contradict the ones on some of these benchmarks, but does not say which ones and, perhaps more importantly, does not provide any insight into why this is the case. Also, the data generation strategies used by existing benchmarks are not discussed. Finally, to what extent the benchmark can be used to really do new things (beyond existing benchmarks) is not discussed.\n\nOn W3. First, the paper focuses solely on DAGs, but it's unclear why this is done for data graphs (e.g., reachability, max-sum). Second, it's unclear whether graph size is the right complexity measure. E.g., for reachability appears easier is source and target are neighbors, no matter how large the graph. Finally, the system does not seem to generate balanced datasets. For example, the paper reports in the appendix that the proportion of true answers for reachability is not controlled, leading to \"paradoxical\" results.\n\nOn W4. It's important for benchmarking papers such as this one to make all code, datasets, prompts, results, etc. public. The paper currently does not provide any ressources (or, at least, I did not see them).\n\nOn W5. The insight that can be drawn from the experiments is somewhat limited. I do not count this against the paper, however. It does show exposed limitations of LLMs and prompting strategies, and it does show that the generated tasks are useful for fine-tuning.\n\nMinor points:\n\nI am not sure how useful the comparison to human performance is. Clearly, all of the tasks can be solved \"easily\" by humans, it's just a pain to do so.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "mkhIBGrSpw", "reviewer": "Reviewer_sT7J", "summary": "Evaluating LLMs is important in current literature as LLM has boosted significant performance in various tasks. This paper proposes a new evaluation method that evaluates the performance of various LLMs in their reasoning abilities by generating dynamic evaluation samples. Results show that several tasks are still hard for current LLMs.", "questions": "1. Can you discuss the influence of fine-tuning on reasoning tasks on the general language understanding ability?\n\n2. Can you provide how to fairly evaluate the different models, especially if this evaluation method is released as a public leaderboard?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The motivation of this paper is clear. As many LLMs tend to memorize static data for evaluation, this paper proposes a dynamic approach to avoid this kind of problem.\n\n2. The idea of generating tasks with different difficulties in a DAG style sounds interesting.\n\n3. The problem is clearly described with sufficient notations and examples.\n\n4. Experiments are conducted in various aspects, including 7 reasoning tasks, 1 human evaluation, on about 8 well-known LLMs. Fine-tuning experiments are also conducted to demonstrate that the LLMs' ability in learning to reason.", "weaknesses": "1. The title is somewhat misleading. The evaluation tasks in this paper are mostly about reasoning on maths, logic, algorithms, etc. However, the title reflects no information about this point. The abstract could be also clearer if this point can be mentioned earlier.\n\n2. For the fine-tuning results in Section 5, I wonder when these LLMs are fine-tuned for the reasoning tasks proposed in this method, will the general abilities be influenced? Or to what extent will they be influenced? \n\n3. As the samples for evaluation are dynamic, the comparison may be unfair when the generated data are different in different evaluation stages.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "DG1xErIvIc", "reviewer": "Reviewer_MYvY", "summary": "The paper proposes a new dynamic generation of samples that can be used to evaluate or fine-tune LLMs. Roughly speaking, a sample corresponds to a DAG with controllable complexity that can be translated into a comprehensible natural language description. This translated sample and a task description can then form an evaluation task for the LLM. The proposal is to use dynamic draws of graph-informed samples to evaluate LLMs and potentially train and fine-tune them on specific tasks. Since the space of large DAGs is exponentially large, it's very unlikely to observe repetitive samples, and hence the algorithm addresses two potential flaws of static benchmarks: data contamination and saturation due to static complexity.", "questions": "Feel free to respond to the weaknesses.", "limitations": "", "rating": 6, "confidence": 5, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "- Extensive experiments are conducted. \n- Graph-based notions of complexities can be used as a means to control the compositional complexity of the examples.\n- Address data contamination and static complexity of the benchmarks.", "weaknesses": "- A common challenge associated with this framework is the need to manually specify a problem as a computation graph with valid constraints. This requirement is only understandable if LLM is intended to acquire specific skills written in these formats. \n- Before reading this paper, I believed that generating a large number of mathematical problems of specific types and evaluating LLMs on them was primarily for debugging specific LLM capabilities, such as compositionality, rather than as an evaluation framework. I'm not sure if these types of problems are fundamental questions about LLMs. In fact, prior studies, such as those by Dziri et al., have already highlighted the limitations of transformers in these settings, using a very similar setup for demonstration.\n- It's not clear if LLMs are losing some skills when fine-tuned on DyVal as DyVal examples and the chosen existing benchmarks are from very similar domains. The generalization of the fine-tuned model on DP is interesting though.\n\nRecommendation:\nAs a person who has worked on dynamic adversarial data collection, or more broadly dynamic benchmarks, I think your review of this literature is underestimating their importance. In fact, in dynamic adversarial data collection annotators can be provide interesting problem instances hard to find in static benchmarks and even hard to manually specify as a DyVal task. So, I encourage you to include a better review of these works. If you are concerned with the human-in-the-loop, I believe the recent theoretical frameworks of dynamic benchmarking are still valid if humans are replaced by generative tools which you may consider mentioning. So, I encourage you to revisit page 2 paragraph 1 at your discretion. \n\nOverall, I believe that in the era of LLMs, we should explore new methods of evaluation, and this paper's framework might be one of them. The ICLR audience may find this work interesting, so I will maintain a positive rating despite the concerns I have.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "62SrNlTWFL", "reviewer": "Reviewer_ydTt", "summary": "The paper introduces DYVAL, a novel and flexible evaluation protocol for assessing Large Language Models (LLMs). DYVAL addresses two fundamental challenges in current LLM evaluation: potential data contamination in training data and the static nature of existing benchmarks that inadequately gauge LLMs' evolving capabilities. DYVAL dynamically generates evaluation samples using directed acyclic graphs (DAGs), allowing for controllable complexities in reasoning tasks. The authors evaluate various LLMs using DYVAL across mathematics, logical reasoning, and algorithmic problems, highlighting the importance of dynamic evaluation. They also demonstrate the effectiveness of DYVAL-generated data in fine-tuning LLMs on existing benchmarks. Key findings include inconsistencies between DYVAL and existing benchmarks, LLMs' performance decline with increasing complexity, and insights into failure patterns and prompt engineering methods.", "questions": "1. Can you clarify the concept of \"co-evolution\" in the context of DYVAL's evaluation process?\n\n2. Could you show the data contamination problem in existing datasets on the proposed problems?\n\n3. Is there a risk of potential bias in the graph generation process that could lead to biased text generation?", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. DYVAL presents an innovative approach to evaluating LLMs by dynamically generating evaluation samples, mitigating concerns about data contamination and providing a more realistic assessment of LLMs' capabilities.\n\n2. The paper conducts extensive experiments across various reasoning tasks and LLMs, offering valuable insights into LLM performance, failure patterns, and the impact of different prompt engineering methods.\n\n3. DYVAL's ability to improve LLMs' performance on existing benchmarks through fine-tuning with DYVAL-generated data demonstrates its practical utility in enhancing LLM capabilities beyond evaluation", "weaknesses": "1. The claim on \"co-evolution\" is not clear. I do not quite understand what co-evolution means. It seems that the evaluation process is not dependent on the LLM, then how they are correlated from each other.\n\n2. The data contamination problem is not clear. Notably, the data generated by the proposed method is rather limited type as it can not generate narrative generation tasks and others related to common sense.  I am wondering how the existing datasets have the contamination problem. I think such a problem may not happen frequently in the logical reasoning and algorithm domains (especially, these abilities may be majorly from finetune from code and scientific papers). However, they are much easier to happen on those storytelling data.\n\n3. The potential bias may exist in the graph generation. The paper focuses on how to conduct constraints for the graph to avoid illegal ones. Nonetheless, there may be lacked of details on how the graph is generated to meet those constraints. I am concerned that the graph generation algorithms remain biased. Therefore, there will be bias in the generated text, leading to the potential issue.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (spotlight)