SynLogic: Synthesizing Verifiable Reasoning Data at Scale for Learning Logical Reasoning and Beyond

Thank you for the comments and we address them below.

Q1: While the SynLogic dataset provides verifiable and diverse task types, the solution traces appear to be rule-based and may lack the richness and diversity of human-like reasoning strategies.

A1: We agree that logical tasks are more rule-complete, but this is determined by these tasks' inherent properties. However, this does not mean these tasks don’t trigger diverse, human-like reasoning strategies to solve. As demonstrated in Figure 4, during RL training, the ratio of reflection tokens within CoT increases, which is closely related to human-like reasoning processes involving trial and backtracking. We will provide example rollouts in the appendix in the next version to further illustrate this point.

Q2: Another concern is that the training contains only fixed-format prompts with strict reward constraints tied to specific tags.

A2: First, we do not use a single fixed prompt for each task. Instead, we implement over 10 bilingual (English and Chinese) prompts for each task separately to achieve robust prompt-following performance. We will provide more details about the prompt examples and prompt numbers in the next version. Every generated instance is randomly selected from prompt templates to achieve diverse prompt formats and robust instruction following. Additionally, given that our approach significantly improves performance on diverse benchmarks like BBEH and KOR-Bench, it demonstrates the effectiveness of our training dataset.

Q3: The paper highlights difficulty control as a key advantage of the SynLogic dataset, but it lacks concrete examples or definitions for how difficulty is parameterized and adjusted across all tasks.

A3: Typically, logical tasks contain key parameters that relate to difficulty or complexity. For example, the grid size of Sudoku problems directly correlates with complexity - higher grid sizes correspond to higher difficulty levels. Due to space limitations, we only showed this in Figure 1 and briefly discussed it in lines 102-104. We will definitely include more detailed descriptions of difficulty parameters and value ranges for every task in the appendix of the next version. Figure 1 provides a concrete difficulty example using Sudoku grid size.

Q4: Clarification and evidence of thorough verifier validation would significantly strengthen the work.

A4: Thank you for the suggestion! Our verifier validates whether the final answer is correct. Here are two detailed examples of our data construction and verification process:

For Sudoku, a typical board game, we identify the difficulty parameter as grid size and set it to 7 as example. Our generator creates a 7x7 grid instance with some missing numbers marked as X. We then format the instance with a prompt describing the Sudoku task to create the final question. Given the question, the LLM attempts to reason and solve the task, providing the final grid with filled values. Our verifier then checks whether the response's grid complies with Sudoku rules (such as single value rules) to verify correctness.

For math path problems, an example instance is: $5-{?}-0 \times 9+{?} \times 5-3 \times ({?} \bmod {?}) \times 1-1 = 4$, where each ? represents a number to be solved. The identified difficulty parameter is the missing number ratio in the equation. The verifier validates whether the LLM's solution makes the equation work correctly.

Therefore, our verifier checks answers’ correctness as in other RLVR works (rather than reasoning steps) and the verification is very accurate without apparent failing cases.

Q5: Including additional results on a distinct open-source model, such as LLaMA or Mistral, would strengthen the paper’s claim beyond Qwen-specific training dynamics.

A5: Thank you for the suggestion! We conduct RL experiments on the mid-trained LLaMA-3.1-8B model [1] and observe significant improvements in both logical reasoning and math generalization performance. The results demonstrate that our SynLogic framework is effective across different model architectures, not limited to Qwen-specific training dynamics.

Q6: While the authors demonstrate meaningful generalization improvements over base models in math and coding tasks, it would be more informative to compare against the instruct-tuned versions (e.g., Qwen2.5-Instruct)

Q7: I would encourage the authors to include or discuss results where SynLogic data is used to fine-tune even stronger models

A6 & A7: As suggested by the reviewer, we conduct RL training based on Qwen2.5-32B-Instruct, which is an instruct-tuned version and stronger than all the base models in our submission version. Results are shown below. Similarly, we observe consistent improvements on logical and math tasks, even though we only trained for 50 steps with 128 batch size due to time constraints.

The improvements on logical benchmarks like KOR-Bench (+3.4) and math benchmarks like AIME 2024 (+6.25) validate the effectiveness of SynLogic on stronger, instruction version models.

[1] Wang et al. OctoThinker: Mid-training Incentivizes Reinforcement Learning Scaling. arXiv preprint. arXiv:2506.20512 2025

Thank you for your recognition of our further RL experiments!

Q: For Q3 & Q4, I strongly recommend you to introduce how to control the difficulties and how your verifiers work for EACH task.

A: Thank you for the suggestion! We will surely provide the details on the difficulty control and verifier implementation in the next revision of the paper, as exemplified above in Q3 and Q4.

Q: For Q2: How confident are you that after training with your 10+ prompts, models can also work well on other prompts for these tasks? What is the prompt sensitivity of your proposed method?

A: This is a good question. We are actually confident about the prompt generalization performance of our trained models. Below we provide two empirical evidence to support this:

Cross-Benchmark Validation: Our significant improvements on external benchmarks like BBEH and KOR-Bench, which use prompt formats significantly different from our training data, demonstrate strong prompt generalization.

Comprehensive Prompt Robustness Test: To directly address your concern about prompt sensitivity, we rely on Claude to generate 5 completely new prompt templates for each SynLogic task, with the minimum edit distance between new prompts and original prompts being 138.5 characters on average (average length of the prompts is 705 characters). We then evaluated our trained model across all these variants on SynLogic-Val dataset:

The results show good consistency across different prompt formulations (mean: 52.6, std: 1.4), with performance even slightly improving over the original prompt in some cases. This demonstrates that our models have learned robust logical reasoning patterns rather than memorizing specific prompt formats, confirming robust prompt generalization of our approach. We will include this prompt sensitivity analysis in the next revision of this paper.

Thank you for the comments and we address them below.

Q1: in Line 102, it is difficult to understand how parameters for each task are used to control the synthesis process.

A1: Each logical reasoning task has specific parameters that control its difficulty level. For Sudoku, the key parameter is grid size (e.g., 5x5, 7x7, 9x9) - larger grids create more complex puzzles. For Cryptarithms, consider this example: SEND + MORE = MONEY, where each letter represents a unique digit, and this task is to find the numerical equation making the equation true. The difficulty parameters include the number of letters used and the length of arithmetic expressions. These parameters are systematically varied during synthesis to create problems of different difficulty levels. We apologize for incomplete details of this process in the submission and we will provide detailed parameter descriptions for all 35 tasks in the appendix in the next revision.

Q2: In line 105, what is the output of your generator? Line 111, how do you perform automatic checks?

A2: The task generator outputs structured problem instances with specific formats. For Sudoku, it generates a grid with some numbers filled and others marked as "X" for missing values. For Cryptarithms, it outputs equations like "SEND + MORE = MONEY" where each letter represents a unique digit. The automatic solvability checks use algorithmic verification: Sudoku uses backtracking algorithms to verify solutions exist, while Cryptarithms uses constraint satisfaction to check for valid digit assignments. We will provide detailed output formats for all tasks in the appendix of the next version.

Q3: Line 117, what are the chat models?

A3: We use the Qwen-2.5-32B-Instruct model for this step.

Q4: Line 121, what is the conversion prompt?

A4: The conversion prompt transforms structured problem instances into natural language instructions. For example, in Sudoku: "Here is a 7x7 Sudoku puzzle, where X represents a hidden number that needs to be filled in. Please solve it step by step." as demonstrated in Figure 1. For Cryptarithms, we use "Solve this cryptarithm: {equation}, where each letter represents a unique digit. Find the digit substitution that makes the equation true." We use multiple prompt templates for each task to ensure robust instruction following. We did not include all prompt templates in the submission because there are many of them, and we instead only included certain examples in Figure 1.

Q5: Line 124, Is the verification the same as that in line 111?

A5: No, they are different steps in our pipeline. The automatic solvability checks (line 111) aim to filter out unsolvable problems before they enter the training dataset. In contrast, verification (line 124) happens during RL training to evaluate model responses and provide rewards. For example, the automatic solvability checks in Sudoku filter out created puzzles with no valid solutions using backtracking algorithms. The verification checks whether the model's final answer is correct (e.g., whether the filled Sudoku grid satisfies all rules).

Q6: The performance in Table 2 shows that Synlogic still lags behind R1-disill-qwen in 32B, limiting the effectiveness of Synlogic data.

A6: We emphasize that Table 2 includes R1-disill-qwen for reference point only, and it is not fair to compare our RL models to R1-Distill-Qwen-32B due to fundamental differences in training approaches and resources. R1-Distill-Qwen-32B is trained on large-scale trajectory data from R1 models, which includes extensive supervised fine-tuning processes. In contrast, our SynLogic models are trained using only 33K synthetic logical reasoning instances through pure RL training without any additional supervised data. The purpose of creating SynLogic is to provide researchers and practitioners with an RL logical reasoning dataset that can be used to enhance models’ logical reasoning performance through RL.

Q7: For the experiments in Figure 5 and Figure 6, it seems the constructed logic data only do well on KOR-Bench, which can be the indomain nature of puzzle-related problems in KOR-bench. However, there is no significant effectiveness on math and code tasks.

A7: The key message from Figure 5 and Figure 6 is that our approach significantly enhances logical reasoning without hurting performance on other domains under the same training compute -- that means including our dataset in the training recipe is like a free gift without negative transfer to other domains or consuming additional compute, as described in line 244-246. The effectiveness is particularly evident when comparing performance under equivalent math/code data consumption (Figures 5-c and 6-c), where mixed training shows clear advantages over training with math or code data alone.

Q8: Meanwhile, I also found it hard to understand the difference between consumed math data and training steps since the range of these two are the same in the figure.

A8: We apologize for the confusion in Figure 5-c and Figure 6-c. The x-axis represents the number of consumed math/code data samples (step×batch_size), not training steps. We will update the axis labels in the next version. To clarify, when we mix logic data with math/code data, the total training steps remain the same, but we consume proportionally less math/code data since logic data occupies some of the training budget. For example, if we train for 1000 steps with pure math data, we consume 1000×batch_size math samples. But with mixed training (50% logic, 50% math), we still train for 1000 steps but only consume 500×batch_size math samples. Therefore, we plot Figures 5-c and 6-c to show performance under equivalent consumed math/code data. The key insight is that mixed training achieves better performance while using less domain-specific data, demonstrating the efficiency of our approach.

Q9: Is SYNLOGIC trained from qwen -base model or -instruct model in Table 2?

A9: As described in line 167, we conduct RL training starting from Qwen-Base models.

Q10: You may need to cite another paper FineReason, which also releases the generation pipeline and data for logic data, and possibly compare the effectiveness of your data and this data.

A10: Thank you for the suggestion, and we will surely cite it in the next revision. We also tried comparing it empirically during rebuttal. However, FineReason did not release their training data or the source code for their data generation pipeline. Below we describe the relation and distinction between SynLogic and FineReason.

Both SynLogic and FineReason investigate logical reasoning tasks and conduct RL training experiments. However, there are significant differences between FineReason and SynLogic in both scope and methodology.

1. Scale & Diversity: SynLogic covers 35 distinct logical reasoning tasks (vs. FineReason's 4 puzzle tasks), providing much broader coverage of reasoning patterns and cognitive skills.
2. Scalable Synthesis: SynLogic features adjustable difficulty parameters and automated generation of unlimited training data with verifiable rewards, enabling efficient RL training. FineReason did not open-source their data generation code.
3. Strong RL Scaling: SynLogic conducts large and comprehensive RL experiments on these 35 logical reasoning tasks and math and coding domains over 7B and 32B models, while FineReason only conducts experiments on 4 logical tasks and math domain over smaller 1.5B and 7B models.

Thanks for your helpful comments; we are glad that you acknowledged our work's strengths! Below we address your concerns:

Q1: The generalization to more realistic benchmarks (LiveCode and GPQA) shows observable but modest improvements considering the additional amount of training data.

A1: Thank you for the comment. We first note that, in all table comparisons, different RL training runs are always benchmarked using the same number of training steps. Therefore, our model does not consume more training tokens than the baselines, even when additional datasets are incorporated. More importantly, we emphasize that the contribution of SynLogic, as shown in the tables, is that it greatly improves logical reasoning performance without negatively impacting other domains, all within the same training compute budget. This means that including our dataset in the training pipeline acts as a free addition—providing significant benefits on logical reasoning without causing negative transfer or requiring extra computation. Consequently, the modest improvements observed on LiveCode and GPQA do not undermine our main contribution or the claims as improving them is not the main goal.

Q2: While the paper compiles a set of tasks, most of them can be found in existing resources. The paper does not add new things for testing LLMs.

A2: As discussed in Section 2.2 (The Data Synthesis Framework), although most tasks can be found in existing resources, they do not open-source their synthesis code and do not conduct careful difficulty control. We have overcome this challenge through the time-consuming development of these tasks’ generation framework. Furthermore, our work focuses on conducting RLVR on diverse and scalable logical tasks rather than introducing new testing paradigms for LLMs.

Q3: I feel the paper could benefit from a bit more analysis, such as impact of additional training data size, generalization across tasks within SynLogic.

A3: Thanks for your suggestions! Here, we conduct ablation studies on different data sizes by controlling the selected task numbers. Using the Qwen2.5-7B-Base model, we conduct RL training varying the logical reasoning tasks: 10 tasks (5K samples), 20 tasks (10K samples), and all 27 tasks (16K samples) under the same training steps. The results are shown below:

The results show that increasing the number of tasks generally improves performance across most benchmarks, demonstrating the effectiveness of our diverse task collection.

Q4: The experiment only contains one model family (Qwen). It is unsure how the results could generalize across different model families like Llama.

A4: Thank you for the suggestion! We conduct RL experiments on the mid-trained LLaMA-3.1-8B model [1] and observe significant improvements in both logical reasoning and math generalization performance. The results demonstrate that our SynLogic framework is effective across different model architectures, not limited to Qwen-specific training dynamics.

[1] Wang et al. OctoThinker: Mid-training Incentivizes Reinforcement Learning Scaling. arXiv preprint. arXiv:2506.20512 2025

We sincerely appreciate your thoughtful comments and recognition of the strengths of our work. Below, we address each of your concerns and questions in detail:

Q1: Conduct additional experiments to compare the generalization performance of the 7B and 32B models when trained with mixed SYNLOGIC, mathematical, and coding data. This could include a more granular analysis of performance on specific benchmarks and tasks.

A1: To provide more granular analysis, here we analyze the effect of mixed training on response length and training efficiency beyond accuracy on AIME 2024. Specifically, based on the 7B model trained on mixed synlogic, math, and code data, we compare its performance to training on math-only data. Results on AIME 2024 are shown below. We find that mixed training leads to higher performance under the same training steps (while consuming less math data). Also, mixed training leads to longer responses.

Q2: Perform ablation studies to investigate the impact of dataset size on training efficiency and performance.

A2: Thank you for the suggestion. Here, we conduct ablation studies on different data sizes by controlling the selected task numbers. Using the Qwen2.5-7B-Base model, we conduct RL training varying the logical reasoning tasks: 10 tasks (5K samples), 20 tasks (10K samples), and all 27 tasks (16K samples) under the same training steps. The results are shown below:

The results show that increasing the number of tasks generally improves performance across most benchmarks, demonstrating the effectiveness of our diverse task collection.

Q3: Conduct experiments to investigate the integration of SYNLOGIC with other training techniques.

A3: Thanks for your suggestion. Our paper primarily focuses on the RLVR setting, which we believe is sufficiently substantive to stand on its own. We look forward to investigating the impact of SYNLOGIC in other training paradigms like SFT in future work.

Q4: Consider implementing a dynamic difficulty adjustment mechanism where the difficulty of the tasks is gradually increased during training.

A4: Thank you for your suggestions. Curriculum learning as advised here may indeed help learn logical reasoning greatly. Due to time and resource limitations we were unable to conduct this experiment during rebuttal, but we will consider exploring it in future work.