Paper deep dive
Logic Before Language: Pre-pretraining on Formal Derivations Fosters Skill Acquisition and Compressibility
Jo-Ku Cheng, Nikolaos Aletras, Marco Valentino
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Pre-pretraining language models (LMs) on symbolic data can accelerate and improve natural language acquisition. However, existing pre-pretraining tasks, such as Dyck and procedural algorithms, rely on narrow primitives that fail to capture the expressive capacity of natural language. Moreover, prior studies remain restricted to relatively small token budgets, offering limited insight into skill emergence and representational dynamics. To address these limitations, we propose logic pre-pretraining (Logic-PPT) as a principled initialization strategy, leveraging formal derivations to impart richer structural and linguistic biases. Formal derivations require abstract mechanisms that are central to natural language, simultaneously binding variables, connecting quantifiers and relational dependencies, and composing predicate-argument structures over long contexts. Scaling our evaluation to a 100B-token regime, logic pre-pretraining substantially accelerates skill acquisition in LMs, achieving 80\% accuracy on linguistic tasks with 36B fewer tokens than standard initialization, and outperforming alternative pre-pretraining baselines. Mechanistically, formal derivations induce persistent structural reorganization, distinctively characterized by a lower-rank, spectrally concentrated representation space. Crucially, we show that this internal geometry enables improved model compressibility via pruning, matching the dense baseline performance even at $\approx$33\% sparsity.
Tags
Links
- Source: https://arxiv.org/abs/2608.03930v1
- Canonical: https://arxiv.org/abs/2608.03930v1
Trouble viewing inline? Open PDF directly →
Full Text
101,044 characters extracted from source content.
Expand or collapse full text
Logic Before Language: Pre-pretraining on Formal Derivations Fosters Skill Acquisition and Compressibility Jo-Ku Cheng Nikolaos Aletras Marco Valentino School of Computer Science, University of Sheffield, United Kingdom jcheng34,n.aletras,m.valentino@sheffield.ac.uk Abstract Pre-pretraining language models (LMs) on symbolic data can accelerate and improve natural language acquisition. However, existing pre-pretraining tasks, such as Dyck and procedural algorithms, rely on narrow primitives that fail to capture the expressive capacity of natural language. Moreover, prior studies remain restricted to relatively small token budgets, offering limited insight into skill emergence and representational dynamics. To address these limitations, we propose logic pre-pretraining (Logic-PPT) as a principled initialization strategy, leveraging formal derivations to impart richer structural and linguistic biases. Formal derivations require abstract mechanisms that are central to natural language, simultaneously binding variables, connecting quantifiers and relational dependencies, and composing predicate-argument structures over long contexts. Scaling our evaluation to a 100B-token regime, logic pre-pretraining substantially accelerates skill acquisition in LMs, achieving 80% accuracy on linguistic tasks with 36B fewer tokens than standard initialization, and outperforming alternative pre-pretraining baselines. Mechanistically, formal derivations induce persistent structural reorganization, distinctively characterized by a lower-rank, spectrally concentrated representation space. Crucially, we show that this internal geometry enables improved model compressibility via pruning, matching the dense baseline performance even at ≈ 33% sparsity. Logic Before Language: Pre-pretraining on Formal Derivations Fosters Skill Acquisition and Compressibility Jo-Ku Cheng Nikolaos Aletras Marco Valentino School of Computer Science, University of Sheffield, United Kingdom jcheng34,n.aletras,m.valentino@sheffield.ac.uk 1 Introduction Figure 1: (A) Faster learning: Logic-PPT reaches 0.8 mean accuracy using 36B fewer natural language training tokens than the PT baseline in the 100B-token run. (B) Lower-rank representations: Logic-PPT promotes a more structured and compact internal geometry, organizing representations around a smaller set of directions. (C) Greater compression robustness: At ≈ 33% sparsity, the Logic-PPT model retains accuracy comparable to a dense PT baseline. Recent work on symbolic pre-pretraining, exposing language models (LMs) to procedurally generated symbolic data prior to natural language training, has emerged as a strategy to accelerate natural language acquisition and improve downstream performance and robustness to noise Hu et al. (2025); Jiang et al. (2026); Guo et al. (2026); Lee et al. (2026a); Mita et al. (2026). However, existing pre-pretraining frameworks remain limited in two critical respects. Qualitatively, the symbolic tasks considered in prior work capture only a narrow range of structural inductive biases relevant to languageWilcox et al. (2018); Montague (2002); Hewitt and Manning (2019). For example, Dyck languages primarily isolate hierarchical nesting and bracket symmetry Hu et al. (2025), whereas algorithmic tasks such as sorting isolate purely procedural sequence transformations, lacking the expressive capacity inherent to natural language Jiang et al. (2026). Quantitatively, prior studies have generally trained on fewer than 10B natural language tokens Hu et al. (2025); Lee et al. (2026a); Jiang et al. (2026), leaving unclear whether the impact of symbolic pre-pretraining persists at longer training and whether it fundamentally changes internal representational dynamics. These limitations motivate our contribution: we introduce formal logical derivations as a more expressive and structurally richer source of pre-pretraining data and study its impact on imparting linguistic biases and representational changes at larger training token budget (i.e. 100B tokens). Figure 2: (Left) We introduce Logic Pre-pretraining (Logic-PPT), a new framework for initializing LMs on symbolic data before exposure to natural language. Compared to previous approaches relying on formal languages and procedural algorithms, Logic-PPT adopts more expressive and structurally richer formal derivations to impart deeper linguistic inductive biases. (Right) Overview of the methodology to generate synthetic formal derivations for Logic-PPT: (A) A derivation-tree is constructed by backward chain of rule schemata, starting from a goal and recursively replacing selected leaves with instantiated premises. (B) Each derivation-tree is augmented with symbol-renaming variants that preserve its topology and rule sequence. (C) A post-order traversal produces a leaf-to-root derivation sequence to construct a next-step prediction example. Specifically, we organize our investigation around three questions: (1) Behavioral: Can pre-pretraining on formal derivations accelerate and improve language and skill acquisition in LMs? (2) Mechanistic: How does pre-pretraining affect internal representational geometry and dynamics? (3) Interventional: can we leverage the structural changes induced by pre-pretraining to further improve LMs’ efficiency? To answer these questions, we curate a library of 247 formal logic schemata spanning propositional, term, and first-order logic. By leveraging backward chaining algorithms, we construct a large-scale next-step formal derivation dataset to symbolically pre-pretrain Transformer models prior to a 100B-token natural language pretraining run on FineWeb-Edu Lozhkov et al. (2024). We systematically compare our logic pre-pretraining framework (Logic-PPT) against established symbolic methods, including formal languages (Dyck/ShuffleDyck) and procedural algorithms (Set/Sort/Union), as well as a random initialization baseline. Our key findings can be summarized as follows: • Logic-PPT significantly accelerates language and skill acquisition, achieving 80% accuracy across a suite of linguistic tasks using 36B fewer natural language tokens than standard initialization and outperforming existing symbolic PPT methods by 7.1% points in accuracy at the final checkpoint. • Mechanistically, formal derivations induce a distinctive lower-rank, spectrally concentrated representation space characterized by clearer layer differentiation that persists throughout 100B tokens of language pretraining. • We demonstrate for the first time that this internal geometry translates into superior pruning resilience, matching dense baseline performance at ≈33%≈ 33\% sparsity. At 40% sparsity, Logic-PPT incurs only a 14.4% relative drop compared to an average 26.8% degradation across alternative symbolic PPT methods. 2 Methodology Our objective is to investigate how pre-pretraining on formal logical derivations shapes subsequent natural language acquisition. Specifically, we examine whether formal logic instills inductive biases that accelerate skill emergence, reorganize internal representations, and enhance model efficiency. Our framework consists of two main stages: Logic Pre-Pretraining (Logic-PPT) and Natural Language Pretraining (PT) via backbone transfer. 2.1 Defining Formal Derivations Formal logical derivations demonstrate the validity of an argument by deriving conclusions from premises through a sequence of rule-governed steps Hardegree (1994). Each step is either one of the original premises or a formula that follows from preceding steps according to a derivation rule, with the final step being the conclusion. Definition. Let Γ be a set of premises, A a set of logical axioms, and ℛR a set of inference rules. A formal logical derivation of a formula φ from Γ is a finite sequence of formulas D=⟨α0,…,αn⟩D= _0,…, _n such that αn _n is φ and, for each k≤nk≤ n, either 1. αk∈Γ∪ _k∈ , or 2. αk _k is obtained from formulas occurring earlier in the sequence by applying an inference rule in ℛR. If such a derivation exists, we write Γ⊢ℛφ _R . 2.2 Stage 1: Logic Pre-pretraining In the first stage, the model is trained exclusively on formal derivations. We denote the randomly initialized model parameters as Θlogic=Θbackbone,logic,logic _logic=\ _backbone,E_logic,H_logic\, where Θbackbone _backbone represents the shared Transformer backbone parameters (multi-head self-attention layers, feed-forward networks, and layer normalizations), logic∈ℝ|Vlogic|×dE_logic ^|V_logic|× d is the input token embedding matrix, and logic∈ℝd×|Vlogic|H_logic ^d×|V_logic| is the output language-modeling head. Here, d denotes the hidden dimension and VlogicV_logic represents a character-level logic vocabulary. Task Formulation. We cast formal derivation generation as an auto-regressive next-step prediction task. Given a derivation D=⟨α1,…,αn⟩D= _1,…, _n , we construct one training example for each step i, where the input contains the premises Γ=p1,…,pm =\\ p_1,…,p_m\\ , the derivation prefix D<i=⟨α1,…,αi−1⟩D_<i= _1,…, _i-1 , and the target conclusion φ , and its output is the next derivation step yi=αiy_i= _i. The input is serialized as the token sequence xix_i: xi= x_i= ⟨⟩p1;…;pm premises \;p_1;…;p_m (1) ⟨⟩α1;…;αi−1 derived \; _1;…; _i-1 ⟨⟩φ goal \; \; ⟨⟩. next \;. This construction yields a training pair (xi,yi)(x_i,y_i). All sequences are processed using a domain-specific character-level tokenizer. Optimization Objective. The model is trained autoregressively to predict the target step yiy_i. To prevent the model from expending capacity on reconstructing fixed prompt contexts, the cross-entropy loss is computed strictly over the tokens corresponding to the target step yiy_i: ℒlogic(Θlogic)=−∑j=1|yi|logPΘ0(yi,j∣xi,yi,<j).L_logic( _logic)=- _j=1^|y_i| P_ _0 (y_i,j x_i,y_i,<j ). (2) After Logic-PPT, the resulting parameters are denoted as Θlogic∗=Θbackbonelogic,logic∗,logic∗ _logic^*=\\ _backbone^logic,E_logic^*,H_logic^*\\ . 2.3 Stage 2: Natural Language Pretraining Following Logic-PPT, we transfer the inductive biases learned in the Transformer backbone to a standard natural language pretraining setup. Vocabulary & Head Re-initialization. Because symbolic logic and natural language operate over distinct token spaces, vocabulary-dependent parameters are non-transferable. We discard the symbolic token embedding matrix logic∗E_logic^* and output head logic∗H_logic^*. We retain the pre-trained Transformer backbone parameters Θbackbonelogic _backbone^logic and attach a randomly initialized embedding matrix lang∈ℝ|Vlang|×dE_lang ^|V_lang|× d and output head lang∈ℝd×|Vlang|H_lang ^d×|V_lang|, sized to match a natural language tokenizer vocabulary VlangV_lang. Natural Language Pretraining. The composite parameter set Θ=Θbackbonelogic,lang,lang =\\ _backbone^logic,E_lang,H_lang\ is trained on a large-scale natural language text corpus textD_text (FineWeb-Edu). All parameters remain fully trainable under the standard causal language modeling objective: ℒlang(Θ)=−∑t=1TlogPΘ(wt∣w<t),L_lang( )=- _t=1^T P_ (w_t w_<t ), (3) where wt∈Vlangw_t∈ V_lang denotes the t-th natural language token in a sequence of length T. 2.4 Logic Pre-pretraining Data Schema Premises Conclusion Propositional Modus ponens P→Q,P→ Q,\;P Q Modus tollens P→Q,¬QP→ Q,\; Q ¬P P Resolution P∨Q,¬P∨RP Q,\; P R Q∨RQ R Term Barbara A⊧B,B⊧CA B,\;B C A⊧CA C Ferio C⊧¬B,A⊧̸¬C B,\;A C A⊧̸BA B CM-Barbara A⊧¬B,¬B⊧CA B,\; B C A⊧CA C First-order Universal instantiation ∀xΦ(x)∀ x\, (x) Φ(t) (t) Universal modus ponens ∀x(Φ(x)→Ψ(x)),Φ(a)∀ x( (x)→ (x)),\; (a) Ψ(a) (a) Equality substitution s=t,Φ(s)s=t,\; (s) Φ(t) (t) Table 1: Representative formal derivation schemata from the three logic families used for Logic-PPT. Collecting Formal Schemata. To cover complementary forms of logical structure and inference, we first curate a library ℛR of formal derivation rule schemata from three logic families: propositional logic, term logic, and first-order logic. Propositional logic captures truth-functional composition and transformations involving logical connectives. Term logic captures categorical and syllogistic relations in the Aristotelian tradition, expressed through relations of inclusion and exclusion between terms. First-order logic provides greater expressive power by introducing variables, predicates, relations, and universal and existential quantifiers. Each schema defines an ordered set of premises and a conclusion that together represent a derivation rule. The library contains 247 schemata: 49 propositional, 77 term, and 121 first-order inference-rule schemata. Representative schemata are shown in Table 1 while a full breakdown is provided in Table 5 in the Appendix. Derivation-Tree Generation. Given a target formula φ and a library of derivation schemata ℛR, we apply the rules in ℛR backward to recursively derive a finite sequence of intermediate formulas αi _i and a corresponding set of premises Γ . Inspired by the LogicTree method Wang et al. (2025), we construct a derivation tree through backward chaining. Starting from a sampled goal φ , we recursively apply compatible derivation rule schemata backwards for at most L steps. The leaves of the resulting tree constitute the premise set Γ , and its root remains the final goal φ . Further dataset details are provided in the Appendix D. Example. An example is given in Figure 2, where Q∨PQ P is selected as the target formula φ . Through backward chaining, the generator identifies constructive dilemma as an applicable inference rule and expands the target into three premises: G→QG→ Q, F→PF→ P, and G∨FG F. The resulting formulas can then be recursively expanded by applying other schemata until the maximum expansion depth is reached or no applicable rule remains. Structure-Preserving Symbol Renaming. To increase the diversity of the training data and prevent the model from overfitting to simple surface-level patterns, we generate n structure-preserving variants of each derivation tree. Each variant applies injective random renaming to the symbols throughout the tree while preserving the derivations topology, rule sequence, and logical relations. Next-Step Derivation Construction. Each derivation is finally expanded into K next-step prediction examples. At derivation step i, the input contains the complete set of premises Γ , the previously derived prefix (y1,…,yi−1)(y_1,…,y_i-1), and the final goal φ . The prediction target is the next valid derivation step yiy_i. The serialized derivations are then adopted for Logic-PPT (Section 2.2). Figure 3: Behavioral trajectories over the 100B-token natural language pretraining run. Top: Language modeling perplexity across three training phases, alongside overall BLiMP accuracy. For BLiMP, Formal-PPT performs slightly better than the other variants, but all four saturate quickly and stay close together. Bottom: Mean accuracy trajectories across elemental tasks Liu et al. (2026), shown as an overall mean and broken down by category. Logic-PPT shows substantial improvements on Morphology, Reading Comprehension, and Compositional tasks. 3 Experimental Setup Baselines. We compare Logic-PPT against two established symbolic PPT methods using a mixture of procedurally generated algorithmic data (i.e., Alg-PPT), including Set, Sort, and Union Jiang et al. (2026), and a mixture of formal language data (i.e., Formal-PPT) combining Dyck and Shuffle-Dyck Hu et al. (2025) (see Figure 2, left). Examples for each class of PPT method are interleaved using balanced round-robin sampling. All PPT methods use an approximately equivalent budget of 2.5B tokens. In addition, we compare our method against a randomly initialized baseline undergoing only language pretraining (i.e., PT). Model Architecture. For all configurations, we use a 14-layer Qwen3 architecture Team (2025) as the Transformer backbone. Following the setup of Yamaguchi et al. (2026), we replace the Qwen3 tokenizer with the 32K Mistral tokenizer Jiang et al. (2023) to reduce the compute cost. The resulting model has a 220M-parameter Transformer backbone and 254M parameters in total. Language Pretraining. After PPT and weight transfer, all parameters remain trainable during pretraining on approximately 100B FineWeb-Edu tokens Lozhkov et al. (2024). We use LLaMA Factory Zheng et al. (2024) with a sequence length of 2,048, a batch size of 96, and checkpoints saved every 2,000 steps to track training progress. Additional implementation and training details, as well as hyperparameters are provided in Table 2, 3, and 6 in the Appendix. Evaluating Language and Skill Acquisition. We use perplexity on a held-out test set of FineWeb-Edu to evaluate general language modeling capabilities. In addition, to track skill acquisition and emergence during language pretraining, we evaluate the models on BLiMP Warstadt et al. (2020) and on the elemental tasks by Liu et al. (2026). Following Liu et al. (2026), we retain the elemental tasks for which at least one PPT configuration achieves 80% accuracy during language pretraining within the 100B token budget. This leads to a total of 17 elemental tasks spanning emergent linguistic capabilities such as string operations, morphology, reading comprehension, and compositional tasks (Table 8 in the Appendix). 4 Results 4.1 Language Acquisition As shown in Figure 3, language modeling perplexity evolves through three training phases. During the early phase (0–3B), the perplexity decreases rapidly under all four configurations. Logic-PPT yields a faster reduction than the PT baseline, producing a clear gap within the first 1B tokens. This advantage persists throughout both the middle (3–20B) and late (20–108.6B) phases. At the final checkpoint, the PT baseline reaches a perplexity of 11.183, compared with 11.088 for Alg-PPT (a 0.85% reduction) and 11.074 for both Formal-PPT and Logic-PPT (a 0.97% reduction). These results show that the language modeling advantage of PPT emerges early and remains stable throughout extended natural language training. At the same time, we found that perplexity alone is insufficient to fully characterize the differences between symbolic PPT approaches, with different methods exhibiting comparable trajectories and final perplexity values. 4.2 Skill Acquisition Analysing the results on BLiMP, we observe that all four models improve rapidly early in training, reaching approximately 80% accuracy within 10-25B tokens, after which performance largely plateaus, with no further gains over the remaining 80B+ tokens. This suggests that, similarly to perplexity, methods relying solely on BLiMP provide little insight into the emergence of more complex capabilities. Despite this, results show that Logic-PPT outperforms the PT baseline and is competitive with alternative symbolic PPT methods. Performance on the elemental tasks continues to improve throughout the full 100B-token training run, while the separation among training conditions persists, providing deeper insight into skill acquisition dynamics. Across these tasks, the PPT models outperform the PT baseline, indicating that symbolic PPT improves the speed and strength of skill acquisition. Logic-PPT, in particular, achieves the 80% accuracy threshold earlier than the other configurations. By the final checkpoint, the overall mean accuracy across all 17 tasks is 87.4% for Logic-PPT, versus 80.3% for Formal-PPT, 77.3% for PT, and 76.8% for Alg-PPT. The gains are particularly clear in Morphology, Reading Comprehension, and Compositional tasks, where Logic-PPT outperforms the strongest competing condition by 5.5–6.7% accuracy points. Further details are in Appendix K. 5 Mechanistic Analysis We analyze model representational dynamics throughout language PT in both activation and weight space. For the activation-space analysis, we use a held-out subset of FineWeb-Edu containing 15K samples and extract the hidden state of the final non-padding token at each layer. We first use centered kernel alignment (CKA) Kornblith et al. (2019) to measure activation similarity both across layers within the same model and between models trained under different PPT configuration. We further compute RankMe Garrido et al. (2023) and the spectral decay Agrawal et al. (2022) from the centered covariance eigenspectrum of these activations to characterize the geometry and effective complexity. Following Li et al. (2025), we use these metrics to characterize changes in the models’ training dynamics. For the weight-space analysis, we compute the stable rank of the model weight matrices to measure how concentrated or distributed their singular-value spectra are. Formal definitions of all metrics are provided in Appendix A. 5.1 Activation Space CKA Analysis. Figure 4: Self layer-to-layer CKA (each model compared against itself) at three checkpoints. Rows are training conditions (PT, Formal-PPT, Alg-PPT, Logic-PPT (Ours)); columns are checkpoints. All four models initially exhibit uniformly high similarity and develop block-diagonal structure as training progresses. However, Logic-PPT exhibits more clear blocks, with lower CKA at the boundary layers. Figure 5: Layer-to-layer CKA between baseline PT and each pre-pretraining (PPT) model, computed at the final checkpoint (108.6B). The y-axis indexes PT’s layers; the x-axis indexes the PPT model’s layers. Logic-PPT exhibits lower similarity with PT’s activations, particularly in the middle layers (layers 4–9, marked by the dashed box). Figure 6: Layer-group trajectories of RankMe and the spectral decay. During the middle and later stages of language PT, Logic-PPT shows much lower RankMe and a higher spectral decay, indicating more compact and lower-dimensional representations. Figure 4 shows that within-model layer-wise CKA becomes increasingly structured during language PT. Early checkpoints exhibit high similarity across many layer pairs, whereas later checkpoints show lower off-diagonal CKA and clearer block structure, indicating increasing layer differentiation and the formation of distinct representational stages. Logic-PPT produces the clearest block structure, particularly in the middle and upper layers, suggesting a more differentiated and modular organization that persists after extensive language training. Consistent with this finding, pairwise CKA at the final checkpoint (Figure 5) shows lower similarity between the Logic-PPT and the PT in the middle layers, indicating that Logic-PPT induces a distinct and persistent activation space organization that fundamentally differs from other symbolic PPT configurations. RankMe and Spectral Decay. The CKA analysis reveals clear layer-wise representational differences, motivating a closer examination of activation space geometry and effective complexity. Figure 6 shows the trajectories of RankMe and the spectral decay in three layer-groups. We observe that early in training RankMe increases while the spectral decay decreases, indicating that variance becomes distributed across a broader set of representational directions. Later, this pattern reverses: RankMe decreases and spectral decay increases, showing that variance is progressively concentrated into fewer dominant directions. Although the transition occurs at different times and with different magnitudes across layers, the overall pattern is consistent with the entropy-seeking and compression-seeking phases described by Li et al. (2025). The effects of PPT become most pronounced during this compression-seeking phase. Logic-PPT produces the lowest RankMe in this phase and the highest spectral decay in the middle and upper layers, indicating a more compact and anisotropic representation space than the other training configurations. Rather than merely reducing representational dimensionality, Logic-PPT appears to promote a more efficient form of spectral concentration, organizing representations around a smaller set of directions. This interpretation is consistent with our CKA results, which reveal a clearer layer-wise block structure under Logic-PPT. 5.2 Weight Space A complementary analysis of the weight trajectory in Figure 7 shows that stable rank drops sharply during the early stage of training and then gradually plateaus. The PPT models generally begin with a lower stable rank than the PT baseline, suggesting that symbolic PPT already biases the attention weights toward a more structured and lower-dimensional spectrum before language exposure. Figure 7: Stable rank trajectories of attention weight matrices across layer groups during language PT. Across all layer groups, PT starts with a higher stable rank than the PPT configurations. Figure 8: Stable rank of the attention and MLP weight matrices during symbolic PPT. Under Logic-PPT, stable rank continues to decrease, whereas the other PPT conditions plateau. To further analyse this, Figure 8 tracks the stable rank of the attention and MLP weight matrices over the PPT stage. Here, under Logic-PPT, stable rank contracts continually throughout training, for both attention and MLP, with no clear plateau. The other symbolic PPT methods, by contrast, show a much weaker effect, in which stable rank drops only in the earliest training steps and quickly flattens out, remaining largely unchanged for the remainder of training. These results suggest that formal derivation data indeed imposes a stronger and more persistent structural bias on the model’s weights than the formal-language or algorithmic objectives. 6 Model Compression Figure 9: Mean accuracy under Wanda pruning across four elemental task categories, and FineWeb-Edu perplexity under Wanda pruning. Logic-PPT (Ours) performs robustly under compression, retaining the highest accuracy across nearly all categories and sparsity levels. Prior work using CKA has shown that highly similar upper-layer representations permit some layers to be removed with minimal performance degradation in fine-tuned Transformers Phang et al. (2021). Although their experiments concern layer truncation rather than weight pruning, they establish a connection between representational organization and model compressibility. Motivated by this connection, together with our representational and spectral analyses, we hypothesize that Logic-PPT induces a more structured and robust computational organization, enabling the model to better preserve its capabilities under weight pruning. To test this, we apply Wanda pruning Sun et al. (2023) at sparsity levels up to 40% to models trained under different PPT conditions. Wanda scores weights using both parameter magnitude and input activation strength. We evaluate pruning robustness on the elemental tasks and FineWeb-Edu perplexity. Figure 9 shows that Logic-PPT retains the highest mean accuracy across the four task categories. At 40% sparsity, Logic-PPT mean accuracy decreases from 0.87 to 0.745, a relative drop of 14.4%, compared with drops from 24.7% for the PT baseline, 22.0% for Formal-PPT, and 31.6% for Alg-PPT. Logic-PPT also exhibits the smallest increase in FineWeb-Edu perplexity under pruning. Importantly, this robustness advantage does not arise from PPT in general. Formal-PPT and Alg-PPT do not exhibit the same degree of resistance to pruning, with Alg-PPT suffering the largest performance degradation. 7 Related Work Symbolic and Procedural Pre-pretraining. Recent work explores whether structured synthetic data can provide useful inductive biases before language pretraining Mita et al. (2026); Guo et al. (2026); Lee et al. (2026a); Shinnick et al. (2026); Wu et al. (2022). Hu et al. (2025) show that pre-pretraining on formal languages improves language-modeling loss and linguistic generalization, while Jiang et al. (2026) extend this approach to procedurally generated formal and algorithmic data. Despite these promising results, prior work has primarily assessed pre-pretraining through language-modelling loss and downstream accuracy, often at relatively small training scales. Logic Data Generation. Logic data has been widely used for model evaluation and post-training Liu et al. (2025); Morishita et al. (2024); Lacombe et al. (2026); Xie et al. (2025); Abdin et al. (2024); Tan et al. (2025); Kim et al. (2025); Lee et al. (2026b); Cao et al. (2026). For example, LogiConBench constructs controllable logical graphs to evaluate model consistency Chen et al. (2026), while LogicTree generates instantiated multi-step reasoning problems with diverse structures and contexts Wang et al. (2025). In contrast, we use formal derivation before language pretraining to shape representations and inductive biases for broader language learning, rather than to teach specific logic tasks. Pretraining Dynamics and Mechanistic Analyses. Dense checkpoint suites, such as Pythia Biderman et al. (2023) and OLMo OLMo et al. (2024), have enabled researchers to study how language-model capabilities and internal structures evolve throughout pretraining, rather than evaluating only the final checkpoint. At the behavioural level, language models exhibit broadly consistent skill-acquisition trajectories across random seeds, model families, and training mixtures Evanson et al. (2023); Liu et al. (2026). Mechanistic studies reveal systematic changes in representation and weight geometry Kulkarni et al. (2026); Yu et al. (2026); Yunis et al. (2024). Li et al. (2025) identify warm-up, entropy-seeking, and compression-seeking phases using RankMe and spectral decay, while related work tracks effective rank and spectral structure in Transformer weights Kulkarni et al. (2026). However, these tools have not yet been used to examine how pre-pretraining reshapes subsequent natural language learning dynamics and internal model organization. 8 Conclusion We investigated how symbolic logic can shape natural language pretraining in LMs, examining its effects from behavioral, mechanistic, and interventional perspectives. Behaviorally, Logic-PPT accelerates the acquisition of linguistic skills, reaching strong task accuracy with substantially fewer natural language PT tokens. Mechanistically, these gains are accompanied by persistent changes in model organization: Logic-PPT develops a more modular, compact, and lower-rank representation space that emerges early and persists throughout training. As an intervention, this altered organization translates into greater robustness under pruning, showing that the structure induced by formal logical derivations yields models that are not only more data-efficient but also more compressible. Limitations Model Scale and Data. Due to computational constraints, we restrict our experiments to a Qwen architecture with approximately 254M parameters. Following a computationally feasible academic setting like work Yamaguchi et al. (2026), we train each model from scratch on approximately 100B natural language tokens. Single Seed. The main behavioral, representational, and pruning results are based on a single 100B-token training run for each condition. Repeating all pretraining configurations was prohibitive within the constraints of the available academic computing infrastructure. To partially assess seed sensitivity, we train each transferred model with three different initialization seeds for 10B natural language tokens (see Appendix F). The resulting self-layer CKA matrices show consistently high correlations across seeds, indicating that the observed layer-wise representational organization is stable at this stage of training. Evaluation Scope. Our evaluation primarily focuses on capability acquisition during language pretraining, using the elemental tasks and BLiMP, together with analyses of representation geometry and pruning robustness. We do not evaluate whether the benefits of Logic-PPT persist after supervised fine-tuning or transfer to a broader range of downstream tasks, such as natural language reasoning, question answering, or instruction following. Future work should examine whether the observed pretraining advantages translate into consistent improvements under different post-training and downstream evaluation settings. Hyperparameter Selection. We approximately match the symbolic PPT conditions by the total number of observed tokens. However, their sequence lengths are task-specific and follow the configurations adopted in prior work, reflecting differences in the structure and serialization of the symbolic tasks. Language Coverage. Our analysis is limited primarily to English-language pretraining and evaluation. We therefore do not test whether symbolic PPT improves multilingual transfer or whether the same skill-acquisition patterns hold across languages with different morphology, syntax, or writing systems. Acknowledgments We acknowledge the University of Sheffield IT Services for providing access to the Stanage high-performance computing facilities. We also acknowledge the Isambard-AI National AI Research Resource (AIRR), operated by the University of Bristol, for providing computational resources under Award ID 0261-5075-3967-1. This work was further supported by computational resources awarded by the EuroHPC Joint Undertaking under Project ID EHPC-DEV-2026D05-083 through access to the Leonardo supercomputer, hosted by CINECA in Italy. References Abdin et al. (2024) Marah Abdin, Jyoti Aneja, Harkirat Behl, Sébastien Bubeck, Ronen Eldan, Suriya Gunasekar, Michael Harrison, Russell J. Hewett, Mojan Javaheripi, Piero Kauffmann, James R. Lee, Yin Tat Lee, Yuanzhi Li, Weishung Liu, Caio C. T. Mendes, Anh Nguyen, Eric Price, Gustavo de Rosa, Olli Saarikivi, and 8 others. 2024. Phi-4 technical report. Preprint, arXiv:2412.08905. Agrawal et al. (2022) Kumar K Agrawal, Arnab Kumar Mondal, Arna Ghosh, and Blake Richards. 2022. α-req : Assessing representation quality in self-supervised learning by measuring eigenspectrum decay. In Advances in Neural Information Processing Systems, volume 35, pages 17626–17638. Curran Associates, Inc. Biderman et al. (2023) Stella Biderman, Hailey Schoelkopf, Quentin Anthony, Herbie Bradley, Kyle O’Brien, Eric Hallahan, Mohammad Aflah Khan, Shivanshu Purohit, USVSN Sai Prashanth, Edward Raff, Aviya Skowron, Lintang Sutawika, and Oskar Van Der Wal. 2023. Pythia: a suite for analyzing large language models across training and scaling. In Proceedings of the 40th International Conference on Machine Learning, ICML’23. JMLR.org. Brown et al. (2023) Davis Brown, Charles Godfrey, Nicholas Konz, Jonathan Tu, and Henry Kvinge. 2023. Understanding the inner-workings of language models through representation dissimilarity. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 6543–6558, Singapore. Association for Computational Linguistics. Cao et al. (2026) Mingzi Cao, Xingwei Tan, Mahmud Elahi Akhter, Marco Valentino, Maria Liakata, Xi Wang, and Nikolaos Aletras. 2026. Fundamental reasoning paradigms induce out-of-domain generalization in language models. In Findings of the Association for Computational Linguistics: ACL 2026, pages 33025–33046, San Diego, California, United States. Association for Computational Linguistics. Chen et al. (2026) Zheng Chen, Chuan Zhou, Fengxiang Cheng, Yip Tin Po, Fenrong Liu, Yisen Wang, Jiajun Chai, Xiaohan Wang, Guojun Yin, Wei Lin, Bo Li, Haoxuan Li, and Zhouchen Lin. 2026. Logiconbench: Benchmarking logical consistencies of LLMs. In The Fourteenth International Conference on Learning Representations. Evanson et al. (2023) Linnea Evanson, Yair Lakretz, and Jean Rémi King. 2023. Language acquisition: do children and language models follow similar learning stages? In Findings of the Association for Computational Linguistics: ACL 2023, pages 12205–12218, Toronto, Canada. Association for Computational Linguistics. Garrido et al. (2023) Quentin Garrido, Randall Balestriero, Laurent Najman, and Yann LeCun. 2023. Rankme: Assessing the downstream performance of pretrained self-supervised representations by their rank. Guo et al. (2026) Xu Guo, Runyu Peng, Jian Tong, Yunhua Zhou, Haijun Lv, Zhihui Lu, and Qipeng Guo. 2026. Synthetic pre-pre-training improves language model robustness to noisy pre-training data. Preprint, arXiv:2605.10129. Gurnee et al. (2026) Wes Gurnee, Nicholas Sofroniew, Adam Pearce, Mateusz Piotrowski, Isaac Kauvar, Runjin Chen, Anna Soligo, Paul Bogdan, Euan Ong, Rowan Wang, Ben Thompson, David Abrahams, Subhash Kantamneni, Emmanuel Ameisen, Joshua Batson, and Jack Lindsey. 2026. Verbalizable representations form a global workspace in language models. Preprint, arXiv:2607.15495. Hardegree (1994) Gary M Hardegree. 1994. Symbolic logic: A first course. McGraw-Hill. Hewitt and Manning (2019) John Hewitt and Christopher D. Manning. 2019. A structural probe for finding syntax in word representations. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4129–4138, Minneapolis, Minnesota. Association for Computational Linguistics. Hu et al. (2025) Michael Y. Hu, Jackson Petty, Chuan Shi, William Merrill, and Tal Linzen. 2025. Between circuits and Chomsky: Pre-pretraining on formal languages imparts linguistic biases. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 9691–9709, Vienna, Austria. Association for Computational Linguistics. Jiang et al. (2023) Albert Q. Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lucile Saulnier, Lélio Renard Lavaud, Marie-Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, Thomas Wang, Timothée Lacroix, and William El Sayed. 2023. Mistral 7b. Preprint, arXiv:2310.06825. Jiang et al. (2026) Liangze Jiang, Zachary Shinnick, Anton van den Hengel, Hemanth Saratchandran, and Damien Teney. 2026. Procedural pretraining: Warming up language models with abstract data. In Forty-third International Conference on Machine Learning. Kim et al. (2025) Geonhee Kim, Marco Valentino, and Andre Freitas. 2025. Reasoning circuits in language models: A mechanistic interpretation of syllogistic inference. In Findings of the Association for Computational Linguistics: ACL 2025, pages 10074–10095, Vienna, Austria. Association for Computational Linguistics. Kornblith et al. (2019) Simon Kornblith, Mohammad Norouzi, Honglak Lee, and Geoffrey Hinton. 2019. Similarity of neural network representations revisited. In International conference on machine learning, pages 3519–3529. PMlR. Kulkarni et al. (2026) Atharva Kulkarni, Jacob Mitchell Springer, Arjun Subramonian, and Swabha Swayamdipta. 2026. Disentangling geometry, performance, and training in language models. In Forty-third International Conference on Machine Learning. Lacombe et al. (2026) Valentin Lacombe, Valentin Quesnel, and Damien Sileo. 2026. Reasoning core: A scalable procedural data generation suite for symbolic pre-training and post-training. Preprint, arXiv:2603.02208. Lee et al. (2026a) Dan Lee, Seungwook Han, Akarsh Kumar, and Pulkit Agrawal. 2026a. Training language models via neural cellular automata. Preprint, arXiv:2603.10055. Lee et al. (2026b) Isabelle Lee, Sarah Liaw, and Dani Yogatama. 2026b. FOL-traces: Verified first-order logic reasoning traces at scale. In Findings of the Association for Computational Linguistics: EACL 2026, pages 2181–2203, Rabat, Morocco. Association for Computational Linguistics. Li et al. (2025) Melody Zixuan Li, Kumar Krishna Agrawal, Arna Ghosh, Komal Kumar Teru, Adam Santoro, Guillaume Lajoie, and Blake Aaron Richards. 2025. Tracing the representation geometry of language models from pretraining to post-training. In The Thirty-ninth Annual Conference on Neural Information Processing Systems. Liu et al. (2026) Emmy Liu, Kaiser Sun, Millicent Li, Isabelle Lee, Lindia Tjuatja, Jen tse Huang, and Graham Neubig. 2026. What do language models learn and when? the implicit curriculum hypothesis. Preprint, arXiv:2604.08510. Liu et al. (2025) Junteng Liu, Yuanxiang Fan, Zhuo Jiang, Han Ding, Yongyi Hu, Chi Zhang, Yiqi Shi, Shitong Weng, Aili Chen, Shiqi Chen, Mozhi Zhang, Pengyu Zhao, and Junxian He. 2025. Synlogic: Synthesizing verifiable reasoning data at scale for learning logical reasoning and beyond. In The Thirty-ninth Annual Conference on Neural Information Processing Systems. Lozhkov et al. (2024) Anton Lozhkov, Loubna Ben Allal, Leandro von Werra, and Thomas Wolf. 2024. Fineweb-edu: the finest collection of educational content. Mita et al. (2026) Masato Mita, Taiga Someya, Ryo Yoshida, and Yohei Oseki. 2026. Language acquisition device in large language models. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 19564–19577, San Diego, California, United States. Association for Computational Linguistics. Montague (2002) Richard Montague. 2002. The Proper Treatment of Quntification in Ordinary English, chapter 1. John Wiley & Sons, Ltd. Morishita et al. (2024) Terufumi Morishita, Gaku Morio, Atsuki Yamaguchi, and Yasuhiro Sogawa. 2024. Enhancing reasoning capabilities of LLMs via principled synthetic logic corpus. In The Thirty-eighth Annual Conference on Neural Information Processing Systems. OLMo et al. (2024) Team OLMo, Pete Walsh, Luca Soldaini, Dirk Groeneveld, Kyle Lo, Shane Arora, Akshita Bhagia, Yuling Gu, Shengyi Huang, Matt Jordan, Nathan Lambert, Dustin Schwenk, Oyvind Tafjord, Taira Anderson, David Atkinson, Faeze Brahman, Christopher Clark, Pradeep Dasigi, Nouha Dziri, and 21 others. 2024. 2 olmo 2 furious. Preprint, arXiv:2501.00656. Phang et al. (2021) Jason Phang, Haokun Liu, and Samuel R. Bowman. 2021. Fine-tuned transformers show clusters of similar representations across layers. In Proceedings of the Fourth BlackboxNLP Workshop on Analyzing and Interpreting Neural Networks for NLP, pages 529–538, Punta Cana, Dominican Republic. Association for Computational Linguistics. Shinnick et al. (2026) Zachary Shinnick, Liangze Jiang, Hemanth Saratchandran, Damien Teney, and Anton van den Hengel. 2026. Can you learn to see without images? procedural warm-up for vision transformers. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 27439–27448. Sun et al. (2023) Mingjie Sun, Zhuang Liu, Anna Bair, and J. Zico Kolter. 2023. A simple and effective pruning approach for large language models. arXiv preprint arXiv:2306.11695. Tan et al. (2025) Xingwei Tan, Marco Valentino, Mahmud Elahi Akhter, Maria Liakata, and Nikolaos Aletras. 2025. Enhancing logical reasoning in language models via symbolically-guided Monte Carlo process supervision. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 31886–31900, Suzhou, China. Association for Computational Linguistics. Team (2025) Qwen Team. 2025. Qwen3 technical report. Preprint, arXiv:2505.09388. Wang et al. (2025) Zehao Wang, Lin Yang, Jie Wang, Kehan Wang, Hanzhu Chen, Bin Wang, Jianye HAO, Defu Lian, Bin Li, and Enhong Chen. 2025. Logictree: Improving complex reasoning of LLMs via instantiated multi-step synthetic logical data. In The Thirty-ninth Annual Conference on Neural Information Processing Systems. Warstadt et al. (2020) Alex Warstadt, Alicia Parrish, Haokun Liu, Anhad Mohananey, Wei Peng, Sheng-Fu Wang, and Samuel R. Bowman. 2020. Blimp: The benchmark of linguistic minimal pairs for english. Transactions of the Association for Computational Linguistics, 8:377–392. Wilcox et al. (2018) Ethan Wilcox, Roger Levy, Takashi Morita, and Richard Futrell. 2018. What do RNN language models learn about filler–gap dependencies? In Proceedings of the 2018 EMNLP Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP, pages 211–221, Brussels, Belgium. Association for Computational Linguistics. Wu et al. (2022) Yuhuai Wu, Felix Li, and Percy S Liang. 2022. Insights into pre-training via simpler synthetic tasks. Advances in Neural Information Processing Systems, 35:21844–21857. Xie et al. (2025) Tian Xie, Zitian Gao, Qingnan Ren, Haoming Luo, Yuqian Hong, Bryan Dai, Joey Zhou, Kai Qiu, Zhirong Wu, and Chong Luo. 2025. Logic-rl: Unleashing llm reasoning with rule-based reinforcement learning. Preprint, arXiv:2502.14768. Yamaguchi et al. (2026) Atsuki Yamaguchi, Maggie Mi, and Nikolaos Aletras. 2026. Enhancing linguistic competence of language models through pre-training with language learning tasks. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), pages 316–336, San Diego, California, United States. Association for Computational Linguistics. Yu et al. (2026) Junjie Yu, Yue Wang, Zihan Deng, Yan Zhu, Wenxiao Ma, and Quanying Liu. 2026. Pretraining induces a reusable spectral basis for downstream task adaptation. Preprint, arXiv:2605.07302. Yunis et al. (2024) David Yunis, Kumar Kshitij Patel, Samuel Wheeler, Pedro Savarese, Gal Vardi, Karen Livescu, Michael Maire, and Matthew R. Walter. 2024. Approaching deep learning through the spectral dynamics of weights. Preprint, arXiv:2408.11804. Zheng et al. (2024) Yaowei Zheng, Richong Zhang, Junhao Zhang, Yanhan Ye, Zheyan Luo, Zhangchi Feng, and Yongqiang Ma. 2024. Llamafactory: Unified efficient fine-tuning of 100+ language models. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations), Bangkok, Thailand. Association for Computational Linguistics. Appendix A Mechanistic Analysis Tools CKA. To quantify representational similarity between layers, we use linear centered kernel alignment (CKA) Kornblith et al. (2019). CKA is invariant to orthogonal transformations and isotropic rescaling, making it well suited for comparing representations across language-model layers Phang et al. (2021); Brown et al. (2023); Gurnee et al. (2026). Let Xi∈ℝn×diX_i ^n× d_i and Xj∈ℝn×djX_j ^n× d_j denote the activation matrices extracted from layers i and j, where n is the number of examples and did_i and djd_j are the corresponding hidden dimensions. Linear CKA is defined as CKA(Xi,Xj)=‖X~i⊤X~j‖F2‖X~i⊤X~i‖F‖X~j⊤X~j‖F,CKA(X_i,X_j)= X_i X_j _F^2 X_i X_i _F X_j X_j _F, (4) where X~i=HXi X_i=HX_i and X~j=HXj X_j=HX_j are column-centered activation matrices, H=In−1nnn⊤H=I_n- 1n1_n1_n is the centering matrix, and ∥⋅∥F · _F denotes the Frobenius norm. RankMe and Spectral Decay Rate. Following Li et al. (2025), we use RankMe Garrido et al. (2023) and the spectral decay rate Agrawal et al. (2022) to characterize how different pre-pretraining conditions affect the complexity of the representation space. For each checkpoint and layer, we collect a representation matrix X∈ℝn×dX ^n× d from last-token activations on a 15K-example subset of FineWeb-Edu, where n is the number of examples and d is the hidden dimension. We center the features across examples to obtain XcX_c and compute the empirical covariance matrix Σ^=1nXc⊤Xc = 1nX_c X_c. Let λi _i denote the eigenvalues of Σ . To compute RankMe, we normalize the eigenvalues as pi=λi∑jλjp_i= _i _j _j and define RankMe as the exponential entropy of this normalized spectrum: RankMe(X)=exp(−∑ipilogpi).RankMe(X)= (- _ip_i p_i ). (5) To measure spectral concentration more directly, we compute the spectral decay rate by fitting a power law to the same covariance eigenspectrum, λi∝i−α _i i^-α. Equivalently, we fit the linear regression logλi=c−αlogi. _i=c-α i. (6) The fitted negative slope gives the spectral decay rate α. A larger α indicates faster spectral decay, meaning that variance is more strongly concentrated along the leading principal directions. Conversely, a smaller α indicates a flatter spectrum and a more uniform spread of variance across dimensions. A higher RankMe indicates that representational variance is distributed more evenly across dimensions, corresponding to a higher effective dimensionality. Conversely, a lower RankMe indicates that variance is concentrated in fewer dominant directions, resulting in a more anisotropic and lower-dimensional representation. A larger spectral decay rate indicates a more rapidly decaying spectrum and stronger concentration along the leading principal directions, whereas a smaller spectral decay rate corresponds to a flatter spectrum. Stable Rank. To complement the representation-space analysis, we use stable rank to characterize the effective dimensionality of model weight matrices. For a weight matrix W with singular values σi\ _i\, stable rank is defined as srank(W)=‖W‖F2‖W‖22=∑iσi2σ12.srank(W)= \|W\|_F^2\|W\|_2^2= _i _i^2 _1^2. (7) Higher stable rank indicates that the weight energy is distributed across more singular directions, while lower stable rank indicates that the matrix is dominated by a few leading directions. We use this metric to test whether different pre-pretraining conditions lead to different levels of spectral concentration in the learned weights. Appendix B Pruning For a weight matrix ∈ℝCout×CinW ^C_out× C_in and input activations ∈ℝNL×CinX ^NL× C_in, Wanda assigns each weight the importance score Sij=|Wij|‖j‖2.S_ij=|W_ij| _j _2. (8) Here, jX_j denotes the activation of the j-th input channel across all tokens. Appendix C Model Architecture Table 2 summarizes the model architecture used in our experiments. Table 2: Model architecture used in the experiments. Hyperparameter Qwen3-14L Model architecture Hidden size 1,024 Intermediate size 3,072 Number of hidden layers 14 Number of attention heads 16 Number of key–value heads 8 Attention head dimension 128 Maximum position embeddings 40,960 Maximum window layers 14 RoPE theta 1,000,000 RMSNorm epsilon 10−610^-6 Attention dropout 0.0 Hidden activation SiLU Transformer parameters 220M Total parameters 254M Appendix D Derivation generation details Inspired by LogicTree Wang et al. (2025), we represent each reasoning instance as a proof tree constructed through backward chaining. For each source example, we select a goal from a predefined pool consisting of manually specified seed formulas and the conclusions of the available inference-rule schemata. The selected formula becomes the root of the derivation tree. Starting from the root, we perform at most L backward-expansion steps. At each step, the generator examines the current leaves and identifies all leaf–rule pairs for which the conclusion of the rule can be structurally unified with the formula at the leaf. To encourage broad coverage of the rule library, it preferentially selects among the applicable rules with the lowest cumulative usage counts. One of the corresponding leaf–rule pairs is then sampled using a seeded pseudo-random number generator. The substitution obtained through unification is applied to the rule, and the selected leaf is replaced by the resulting instantiated premises. Schema variables that remain unbound after unification are assigned fresh symbols that do not already occur in the tree, preventing unintended symbol collisions. Expansion terminates after L rule applications or earlier if no current leaf admits a valid backward expansion. The leaves of the completed tree form the premise set Γ=p1,…,pm =\p_1,…,p_m\, while the root remains the final goal φ . We then traverse the expanded nodes in post-order to obtain a valid leaf-to-root proof sequence Y=(y1,…,yK),K≤L,yK=φ.Y=(y_1,…,y_K), K≤ L, y_K= . (9) Because each node is visited only after its children, every step yiy_i is derivable from the initial premises and the preceding steps y1,…,yi−1y_1,…,y_i-1. Thus, although the tree is constructed backward from the goal, its post-order traversal yields a valid forward derivation from Γ to φ . We set the maximum number of backward-expansion steps to L=10L=10 and generate n=5n=5 variants for each derivation tree. Appendix E Pretraining Details After symbolic pre-pretraining, we transfer the Transformer blocks to the language-pretraining stage and reinitialize the token embeddings and language-modeling head to match the natural-language tokenizer. All model parameters remain trainable during language pretraining. We train all model variants on approximately 100B tokens from FineWeb-Edu using the same architecture, data, and optimization configuration; the no-pre-pretraining baseline is trained under identical conditions. Table 3 summarizes the language-pretraining hyperparameters. Table 3: Hyperparameters of language-pretraining for the 100B-token experiments. Hyperparameter Qwen3-14L Language pretraining Training corpus FineWeb-Edu Training tokens ∼ 100B Tokenizer Mistral Vocabulary size 32,768 Sequence length 2,048 Packing Yes Batch size per GPU 96 GPU 4× NVIDIA GH200 Gradient accumulation steps 1 Training steps 127,160 Maximum learning rate 3×10−43× 10^-4 Learning-rate scheduler Cosine Warmup steps 2,000 Optimizer AdamW Adam ϵε 10−810^-8 Adam β1 _1 0.9 Adam β2 _2 0.999 Gradient clipping 1.0 Weight decay 0.01 Training precision BF16 Initialization seed 42 Appendix F Seed Stability of CKA Cross-seed agreement. For a given model, let (s)∈ℝnc^(s) ^n denote the vector of off-diagonal upper-triangular entries of its self-layer CKA matrix under seed s. For each of the three seed pairs (sa,sb)(s_a,s_b), we compute MeanAbsDiff(sa,sb) (s_a,s_b) =1n∑k=1n|ck(sa)−ck(sb)|, = 1n _k=1^n |c^(s_a)_k-c^(s_b)_k |, PearsonR(sa,sb) (s_a,s_b) =corr((sa),(sb)). =corr\! (c^(s_a),c^(s_b) ). The former measures the absolute magnitude of seed-to-seed drift in CKA values; the latter measures whether the relative pattern of which layer pairs are more or less similar is preserved across seeds. To examine the effect of random seeds on model representations, we initialize the transferred model with three different seeds and train each run for 10B tokens. As shown in Table 4, the mean absolute difference between CKA matrices is small for all models. At the same time, the mean Pearson correlation between vectorized off-diagonal CKA entries is consistently above 0.990.99. This indicates that different seeds produce very similar layer-to-layer representational similarity patterns. Model Mean Abs. Diff. Mean Pearson r PT 0.0138 0.9955 Formal-PPT 0.0201 0.9942 Alg-PPT 0.0171 0.9941 Logic-PPT 0.0182 0.9926 Table 4: Seed stability of self-layer CKA at the 10B-token checkpoint. Appendix G Licenses We adopt the Qwen3 architecture but initialize all model parameters from scratch; no pretrained Qwen3 weights are used. The Mistral-7B-Instruct v0.3 tokenizer is released under the Apache License 2.0. FineWeb-Edu is released under the Open Data Commons Attribution License (ODC-By) v1.0, and its use is also subject to the Common Crawl Terms of Use. The elemental tasks repository is released under the MIT License, while BLiMP is distributed under the Creative Commons Attribution 4.0 License. Appendix H Logic schemata We organize our formal-derivation schema library into three broad classes: propositional logic, term logic, and first-order logic. Within each class, schemata are further grouped into rule families according to the logical operations or inference patterns they instantiate. As summarized in Table 5, the library contains 49 propositional, 77 term-logic, and 121 first-order schemata, for a total of 247 inference-rule schemata. Table 5: Counts of derivation schemata in the library by logic type and rule family. Logic type Rule family Count Propositional De Morgan 4 Dilemma 4 Distribution 4 Resolution 3 Absorption 2 Association 2 Biconditional elimination 2 Classical laws 2 Commutation 2 Conjunction elimination 2 Disjunctive syllogism 2 Double negation 2 Idempotence 2 Material equivalence 2 Material implication 2 Transposition 2 Addition 1 Biconditional introduction 1 Conjunction introduction 1 Excluded middle 1 Exportation 1 Hypothetical syllogism 1 Importation 1 Modus ponens 1 Modus tollens 1 Proof by cases 1 Total 49 Term Categorical syllogisms 24 Complemented-term variants 16 Syllogistic reductions 15 Square of opposition 9 Sorites chains 8 Derived syllogisms 5 Total 77 First-order Syllogism 57 Scope 14 Derived patterns 12 Equality 9 Distribution 6 Classical quantifier laws 4 Quantifier negation 4 Uniqueness 4 Vacuous quantification 4 Quantifier rules 3 Quantifier commutation 2 Renaming 2 Total 121 Overall 247 Appendix I Logic Data Samples I.1 Propositional Logic Sample 1 Θ =(¬X∨A)∧(¬X∨B∨C), =( X A) ( X B C), (1)= ^(1)=\ G∨W;W→X;G→X;¬Θ→(¬Θ∧¬Y); G W;W→ X;G→ X; →( Y); K→Θ;Y,g(1)=A∧(B∨C). K→ ;Y\, g^(1)=A (B C). x1(1)= x^(1)_1= ⟨premises⟩(1)⟨derived⟩none premises \,P^(1) derived \, none ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y1(1)= y^(1)_1= W∨G. W G. x2(1)= x^(1)_2= ⟨premises⟩(1)⟨derived⟩y1(1) premises \,P^(1) derived \,y^(1)_1 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y2(1)= y^(1)_2= X. X. x3(1)= x^(1)_3= ⟨premises⟩(1)⟨derived⟩y1(1);y2(1) premises \,P^(1) derived \,y^(1)_1;y^(1)_2 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y3(1)= y^(1)_3= ¬Θ→¬Y. → Y. x4(1)= x^(1)_4= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y3(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_3 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y4(1)= y^(1)_4= Y→Θ. Y→ . x5(1)= x^(1)_5= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y4(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_4 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y5(1)= y^(1)_5= Y∨K. Y K. x6(1)= x^(1)_6= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y5(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_5 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y6(1)= y^(1)_6= Θ. . x7(1)= x^(1)_7= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y6(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_6 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y7(1)= y^(1)_7= ¬X∨(A∧(B∨C)). X (A (B C)). x8(1)= x^(1)_8= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y7(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_7 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y8(1)= y^(1)_8= A∧(B∨C). A (B C). x9(1)= x^(1)_9= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y8(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_8 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y9(1)= y^(1)_9= (A∧B)∨(A∧C). (A B) (A C). x10(1)= x^(1)_10= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y9(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_9 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y10(1)= y^(1)_10= A∧(B∨C). A (B C). Sample 2 (2)= ^(2)=\ O;A→L;L→M;(M→B∨C)→D; O;A→ L;L→ M;(M→ B C)→ D; D→(M→B∨C);D,g(2)=A→B∨C. D→(M→ B C);D\, g^(2)=A→ B C. x1(2)= x^(2)_1= ⟨premises⟩(2)⟨derived⟩none premises \,P^(2) derived \, none ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y1(2)= y^(2)_1= ¬D→¬(M→B∨C). D→ (M→ B C). x2(2)= x^(2)_2= ⟨premises⟩(2)⟨derived⟩y1(2) premises \,P^(2) derived \,y^(2)_1 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y2(2)= y^(2)_2= (M→B∨C)→D. (M→ B C)→ D. x3(2)= x^(2)_3= ⟨premises⟩(2)⟨derived⟩y1(2);y2(2) premises \,P^(2) derived \,y^(2)_1;y^(2)_2 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y3(2)= y^(2)_3= D∧M→B∨C. D M→ B C. x4(2)= x^(2)_4= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y3(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_3 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y4(2)= y^(2)_4= D→(M→B∨C). D→(M→ B C). x5(2)= x^(2)_5= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y4(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_4 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y5(2)= y^(2)_5= (M→B∨C)↔D. (M→ B C) D. x6(2)= x^(2)_6= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y5(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_5 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y6(2)= y^(2)_6= M→B∨C. M→ B C. x7(2)= x^(2)_7= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y6(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_6 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y7(2)= y^(2)_7= L→B∨C. L→ B C. x8(2)= x^(2)_8= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y7(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_7 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y8(2)= y^(2)_8= A→B∨C. A→ B C. x9(2)= x^(2)_9= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y8(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_8 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y9(2)= y^(2)_9= O∧(A→B∨C). O (A→ B C). x10(2)= x^(2)_10= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y9(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_9 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y10(2)= y^(2)_10= A→B∨C. A→ B C. Sample 3 (3)= ^(3)=\ L∧(¬B∨C);A,g(3)=A∧(B→C). L ( B C);A\, g^(3)=A (B→ C). x1(3)= x^(3)_1= ⟨premises⟩(3)⟨derived⟩none premises \,P^(3) derived \, none ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y1(3)= y^(3)_1= (L∧¬B)∨(L∧C). (L B) (L C). x2(3)= x^(3)_2= ⟨premises⟩(3)⟨derived⟩y1(3) premises \,P^(3) derived \,y^(3)_1 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y2(3)= y^(3)_2= L∧(¬B∨C). L ( B C). x3(3)= x^(3)_3= ⟨premises⟩(3)⟨derived⟩y1(3);y2(3) premises \,P^(3) derived \,y^(3)_1;y^(3)_2 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y3(3)= y^(3)_3= (L∧¬B)∨(L∧C). (L B) (L C). x4(3)= x^(3)_4= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y3(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_3 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y4(3)= y^(3)_4= ((L∧¬B)∨L)∧((L∧¬B)∨C). ((L B) L) ((L B) C). x5(3)= x^(3)_5= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y4(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_4 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y5(3)= y^(3)_5= (L∧¬B)∨(L∧C). (L B) (L C). x6(3)= x^(3)_6= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y5(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_5 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y6(3)= y^(3)_6= L∧(¬B∨C). L ( B C). x7(3)= x^(3)_7= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y6(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_6 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y7(3)= y^(3)_7= ¬B∨C. B C. x8(3)= x^(3)_8= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y7(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_7 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y8(3)= y^(3)_8= B→C. B→ C. x9(3)= x^(3)_9= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y8(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_8 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y9(3)= y^(3)_9= (B→C)∧A. (B→ C) A. x10(3)= x^(3)_10= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y9(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_9 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y10(3)= y^(3)_10= A∧(B→C). A (B→ C). I.2 Term Logic Sample 1 (1)= ^(1)=\ A⊧T;T⊧V;V⊧J;J⊧F;F⊧¬O;¬O⊧X; A T;T V;V J;J F;F O; O X; X⊧¬N;¬N⊧H;H⊧Z;Z⊧¬Q;¬Q⊧M;M⊧B, X N; N H;H Z;Z Q; Q M;M B\, g(1) g^(1) =A⊧B. =A B. x1(1)= x^(1)_1= ⟨premises⟩(1)⟨derived⟩none premises \,P^(1) derived \, none ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y1(1)= y^(1)_1= J⊧¬O. J O. x2(1)= x^(1)_2= ⟨premises⟩(1)⟨derived⟩y1(1) premises \,P^(1) derived \,y^(1)_1 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y2(1)= y^(1)_2= ¬O⊧¬N. O N. x3(1)= x^(1)_3= ⟨premises⟩(1)⟨derived⟩y1(1);y2(1) premises \,P^(1) derived \,y^(1)_1;y^(1)_2 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y3(1)= y^(1)_3= ¬O⊧H. O H. x4(1)= x^(1)_4= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y3(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_3 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y4(1)= y^(1)_4= Q⊧¬H. Q H. x5(1)= x^(1)_5= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y4(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_4 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y5(1)= y^(1)_5= ¬O⊧¬Q. O Q. x6(1)= x^(1)_6= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y5(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_5 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y6(1)= y^(1)_6= J⊧¬Q. J Q. x7(1)= x^(1)_7= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y6(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_6 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y7(1)= y^(1)_7= J⊧M. J M. x8(1)= x^(1)_8= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y7(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_7 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y8(1)= y^(1)_8= V⊧M. V M. x9(1)= x^(1)_9= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y8(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_8 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y9(1)= y^(1)_9= T⊧M. T M. x10(1)= x^(1)_10= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y9(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_9 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y10(1)= y^(1)_10= A⊧B. A B. Sample 2 (2)= ^(2)=\ A⊧G;G⊧¬M;¬M⊧R;R⊧U; A G;G M; M R;R U; ¬C⊧E;E⊧¬Q;¬Q⊧X;X⊧¬W;¬W⊧¬U, C E;E Q; Q X;X W; W U\, g(2) g^(2) =A⊧̸¬C. =A C. x1(2)= x^(2)_1= ⟨premises⟩(2)⟨derived⟩none premises \,P^(2) derived \, none ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y1(2)= y^(2)_1= G⊧R. G R. x2(2)= x^(2)_2= ⟨premises⟩(2)⟨derived⟩y1(2) premises \,P^(2) derived \,y^(2)_1 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y2(2)= y^(2)_2= ¬C⊧¬Q. C Q. x3(2)= x^(2)_3= ⟨premises⟩(2)⟨derived⟩y1(2);y2(2) premises \,P^(2) derived \,y^(2)_1;y^(2)_2 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y3(2)= y^(2)_3= ¬C⊧X. C X. x4(2)= x^(2)_4= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y3(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_3 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y4(2)= y^(2)_4= X⊧¬U. X U. x5(2)= x^(2)_5= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y4(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_4 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y5(2)= y^(2)_5= ¬C⊧¬U. C U. x6(2)= x^(2)_6= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y5(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_5 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y6(2)= y^(2)_6= R⊧¬C. R C. x7(2)= x^(2)_7= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y6(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_6 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y7(2)= y^(2)_7= G⊧¬C. G C. x8(2)= x^(2)_8= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y7(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_7 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y8(2)= y^(2)_8= A⊧¬C. A C. x9(2)= x^(2)_9= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y8(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_8 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y9(2)= y^(2)_9= ¬(A⊧̸¬C). (A C). x10(2)= x^(2)_10= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y9(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_9 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y10(2)= y^(2)_10= A⊧̸¬C. A C. Sample 3 (3)= ^(3)=\ Y⊧F;F⊧L;A⊧¬L;¬Y⊧D; Y F;F L;A L; Y D; D⊧K;K⊧¬T;¬T⊧W;W⊧B, D K;K T; T W;W B\, g(3) g^(3) =¬(A⊧¬B). = (A B). x1(3)= x^(3)_1= ⟨premises⟩(3)⟨derived⟩none premises \,P^(3) derived \, none ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y1(3)= y^(3)_1= Y⊧L. Y L. x2(3)= x^(3)_2= ⟨premises⟩(3)⟨derived⟩y1(3) premises \,P^(3) derived \,y^(3)_1 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y2(3)= y^(3)_2= A⊧¬Y. A Y. x3(3)= x^(3)_3= ⟨premises⟩(3)⟨derived⟩y1(3);y2(3) premises \,P^(3) derived \,y^(3)_1;y^(3)_2 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y3(3)= y^(3)_3= ¬Y⊧K. Y K. x4(3)= x^(3)_4= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y3(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_3 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y4(3)= y^(3)_4= ¬Y⊧¬T. Y T. x5(3)= x^(3)_5= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y4(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_4 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y5(3)= y^(3)_5= ¬Y⊧W. Y W. x6(3)= x^(3)_6= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y5(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_5 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y6(3)= y^(3)_6= ¬Y⊧B. Y B. x7(3)= x^(3)_7= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y6(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_6 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y7(3)= y^(3)_7= A⊧B. A B. x8(3)= x^(3)_8= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y7(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_7 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y8(3)= y^(3)_8= ¬(A⊧̸B). (A B). x9(3)= x^(3)_9= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y8(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_8 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y9(3)= y^(3)_9= A⊧̸¬B. A B. x10(3)= x^(3)_10= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y9(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_9 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y10(3)= y^(3)_10= ¬(A⊧¬B). (A B). I.3 First-Order Logic Sample 1 (1)= ^(1)=\ ∀x(N(x)→K(x));∀x(K(x)→O(x));∀x(O(x)→Ψ(x)); ∀ x\,(N(x)→ K(x));∀ x\,(K(x)→ O(x));∀ x\,(O(x)→ (x)); ∀xI(x)∨∀xN(x);∀x¬I(x),g(1)=∀xΨ(x). ∀ x\,I(x) ∀ x\,N(x);∀ x\, I(x)\, g^(1)=∀ x\, (x). x1(1)= x^(1)_1= ⟨premises⟩(1)⟨derived⟩none premises \,P^(1) derived \, none ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y1(1)= y^(1)_1= ∀x(K(x)→O(x)). ∀ x\,(K(x)→ O(x)). x2(1)= x^(1)_2= ⟨premises⟩(1)⟨derived⟩y1(1) premises \,P^(1) derived \,y^(1)_1 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y2(1)= y^(1)_2= ∀x(N(x)→Ψ(x)). ∀ x\,(N(x)→ (x)). x3(1)= x^(1)_3= ⟨premises⟩(1)⟨derived⟩y1(1);y2(1) premises \,P^(1) derived \,y^(1)_1;y^(1)_2 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y3(1)= y^(1)_3= ∀xI(x)∨∀xN(x). ∀ x\,I(x) ∀ x\,N(x). x4(1)= x^(1)_4= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y3(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_3 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y4(1)= y^(1)_4= ∀x(I(x)∨N(x)). ∀ x\,(I(x) N(x)). x5(1)= x^(1)_5= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y4(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_4 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y5(1)= y^(1)_5= ¬∃xI(x). ∃ x\,I(x). x6(1)= x^(1)_6= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y5(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_5 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y6(1)= y^(1)_6= ∀x¬I(x). ∀ x\, I(x). x7(1)= x^(1)_7= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y6(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_6 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y7(1)= y^(1)_7= ∀xN(x). ∀ x\,N(x). x8(1)= x^(1)_8= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y7(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_7 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y8(1)= y^(1)_8= ¬∃x¬N(x). ∃ x\, N(x). x9(1)= x^(1)_9= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y8(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_8 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y9(1)= y^(1)_9= ∀xN(x). ∀ x\,N(x). x10(1)= x^(1)_10= ⟨premises⟩(1)⟨derived⟩y1(1);⋯;y9(1) premises \,P^(1) derived \,y^(1)_1;·s;y^(1)_9 ⟨goal⟩g(1)⟨next⟩, goal \,g^(1) next , y10(1)= y^(1)_10= ∀xΨ(x). ∀ x\, (x). Sample 2 (2)= ^(2)=\ ∀xX(x)∨∀xΦ(x);¬∃xX(x),g(2)=¬∃x¬Φ(x). ∀ x\,X(x) ∀ x\, (x); ∃ x\,X(x)\, g^(2)= ∃ x\, (x). x1(2)= x^(2)_1= ⟨premises⟩(2)⟨derived⟩none premises \,P^(2) derived \, none ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y1(2)= y^(2)_1= ∀x(X(x)∨Φ(x)). ∀ x\,(X(x) (x)). x2(2)= x^(2)_2= ⟨premises⟩(2)⟨derived⟩y1(2) premises \,P^(2) derived \,y^(2)_1 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y2(2)= y^(2)_2= ∀xX(x)∨Φ(x). ∀ x\,X(x) (x). x3(2)= x^(2)_3= ⟨premises⟩(2)⟨derived⟩y1(2);y2(2) premises \,P^(2) derived \,y^(2)_1;y^(2)_2 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y3(2)= y^(2)_3= ∀x(X(x)∨Φ(x)). ∀ x\,(X(x) (x)). x4(2)= x^(2)_4= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y3(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_3 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y4(2)= y^(2)_4= ∀xX(x)∨Φ(x). ∀ x\,X(x) (x). x5(2)= x^(2)_5= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y4(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_4 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y5(2)= y^(2)_5= ∀x(X(x)∨Φ(x)). ∀ x\,(X(x) (x)). x6(2)= x^(2)_6= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y5(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_5 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y6(2)= y^(2)_6= ∀x¬X(x). ∀ x\, X(x). x7(2)= x^(2)_7= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y6(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_6 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y7(2)= y^(2)_7= ¬∃xX(x). ∃ x\,X(x). x8(2)= x^(2)_8= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y7(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_7 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y8(2)= y^(2)_8= ∀x¬X(x). ∀ x\, X(x). x9(2)= x^(2)_9= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y8(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_8 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y9(2)= y^(2)_9= ∀xΦ(x). ∀ x\, (x). x10(2)= x^(2)_10= ⟨premises⟩(2)⟨derived⟩y1(2);⋯;y9(2) premises \,P^(2) derived \,y^(2)_1;·s;y^(2)_9 ⟨goal⟩g(2)⟨next⟩, goal \,g^(2) next , y10(2)= y^(2)_10= ¬∃x¬Φ(x). ∃ x\, (x). Sample 3 (3)= ^(3)=\ ∀z(I(z)→C(z));∀z(C(z)→E(z));∀z(L(z)→I(z)); ∀ z\,(I(z)→ C(z));∀ z\,(C(z)→ E(z));∀ z\,(L(z)→ I(z)); ∃zL(z);∀z∀r((E(z)∧E(r))→z=r); ∃ z\,L(z);∀ z\,∀ r\,((E(z) E(r))→ z=r); c=w;s=w;∀l(A(l)→E(l));A(c);E(t),g(3)=s=t. c=w;s=w;∀ l\,(A(l)→ E(l));A(c);E(t)\, g^(3)=s=t. x1(3)= x^(3)_1= ⟨premises⟩(3)⟨derived⟩none premises \,P^(3) derived \, none ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y1(3)= y^(3)_1= ∃zI(z). ∃ z\,I(z). x2(3)= x^(3)_2= ⟨premises⟩(3)⟨derived⟩y1(3) premises \,P^(3) derived \,y^(3)_1 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y2(3)= y^(3)_2= ∃zE(z). ∃ z\,E(z). x3(3)= x^(3)_3= ⟨premises⟩(3)⟨derived⟩y1(3);y2(3) premises \,P^(3) derived \,y^(3)_1;y^(3)_2 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y3(3)= y^(3)_3= ∃!zE(z). ∃!z\,E(z). x4(3)= x^(3)_4= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y3(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_3 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y4(3)= y^(3)_4= ∃z(E(z)∧∀p(E(p)→p=z)). ∃ z\,(E(z) ∀ p\,(E(p)→ p=z)). x5(3)= x^(3)_5= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y4(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_4 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y5(3)= y^(3)_5= ∃!zE(z). ∃!z\,E(z). x6(3)= x^(3)_6= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y5(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_5 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y6(3)= y^(3)_6= w=s. w=s. x7(3)= x^(3)_7= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y6(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_6 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y7(3)= y^(3)_7= c=s. c=s. x8(3)= x^(3)_8= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y7(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_7 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y8(3)= y^(3)_8= E(c). E(c). x9(3)= x^(3)_9= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y8(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_8 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y9(3)= y^(3)_9= E(s). E(s). x10(3)= x^(3)_10= ⟨premises⟩(3)⟨derived⟩y1(3);⋯;y9(3) premises \,P^(3) derived \,y^(3)_1;·s;y^(3)_9 ⟨goal⟩g(3)⟨next⟩, goal \,g^(3) next , y10(3)= y^(3)_10= s=t. s=t. Appendix J Pre-pretraining Details Table 6: Hyperparameters for the three symbolic PPT conditions. All models are initialized from scratch with the same seed. Hyperparameter Logic Algorithmic Formal Language Training tasks Prop./FOL/term logic Set, sort, union Dyck, Shuffle-Dyck Task sampling Mixed dataset Balanced round-robin Balanced round-robin Tokenizer Character-level Task-specific discrete Task-specific discrete Vocabulary size 74 231 359 Training examples 6.0M total 6.0M per task 20.5M per task Maximum sequence length 2,048 128 128 Batch size 256 256 256 Gradient accumulation 1 1 1 Selected checkpoint step 32,000 84,000 80,000 Input tokens observed 2.600B 2.753B 2.621B Maximum learning rate 1×10−41× 10^-4 5×10−55× 10^-5 5×10−55× 10^-5 Learning-rate schedule Constant Constant Constant Warmup steps 100 100 100 Optimizer AdamW AdamW AdamW Adam ϵε 10−810^-8 10−810^-8 10−810^-8 Adam β1 _1 0.9 0.9 0.9 Adam β2 _2 0.999 0.999 0.999 Weight decay 0.01 0.1 0.1 Gradient clipping 1.0 1.0 1.0 Training precision BF16 BF16 BF16 Loss positions Target only Target only All non-final tokens Initialization seed 42 42 42 GPU 1× NVIDIA GH200 (96 GB) Appendix K Task Performance We report full accuracy trajectories on the ElementalTask suite and BLiMP accuracy broken down by linguistic field, to complement the aggregate results discussed above with per-task and per-field detail. Figure 10 shows accuracy versus cumulative language training tokens for the 17 elemental tasks used in our main emergence analysis, grouped into the four skill categories introduced earlier—String Operations, Morphology, Reading Comprehension, and Compositional—for all four model variants (PT, Formal-PPT, Alg-PPT, Logic-PPT). To check that this curated subset is representative rather than cherry-picked, Figures 11–15 report the same trajectories for the full 130-task elemental task suite, split across five panels for legibility; the 17 tasks in Figure 10 are the subset without a clean emergence point, used for the emergence-order analysis. Figure 16 further decomposes the overall BLiMP trajectory by field (Morphology, Syntax, Semantics), showing that the aggregate curves reported earlier mask substantial field-level variation. Table 7 reports the pairwise Spearman rank correlations between task-emergence orders for every pair of models, providing the data underlying the implicit-curriculum discussion. Pair ρ p-value n PT vs Formal-PPT 0.800 0.00058 14 PT vs Alg-PPT 0.768 0.00954 10 PT vs Logic-PPT 0.801 0.00057 14 Formal-PPT vs Alg-PPT 0.768 0.00579 11 Formal-PPT vs Logic-PPT 0.557 0.03084 15 Algo-PPT vs Logic-PPT 0.904 0.000022 13 Table 7: Pairwise Spearman correlations between task-emergence orders under different PPT conditions. Figure 10: Accuracy trajectories for the 17 elemental tasks across language training tokens. Figure 11: Accuracy trajectories for the first subset of tasks in the full 130-task ElementalTask suite. Figure 12: Accuracy trajectories for the second subset of tasks in the full 130-task ElementalTask suite. Figure 13: Accuracy trajectories for the third subset of tasks in the full 130-task ElementalTask suite. Figure 14: Accuracy trajectories for the fourth subset of tasks in the full 130-task ElementalTask suite. Figure 15: Accuracy trajectories for the fifth subset of tasks in the full 130-task ElementalTask suite. Figure 16: BLiMP accuracy trajectories by linguistic field. Category Task # Samples Example String Operations (72) copying 20 Input: gTpigTHK → Output: gTpigTHK simple_icl:lowercase 26 Input: B → Output: b simple_icl:uppercase 26 Input: b → Output: B Morphology (344) simple_icl:present_to_gerund 179 Input: run → Output: running simple_icl:singular_to_plural 165 Input: child → Output: children Reading Comprehension (1081) coreference:pronoun_hard 20 Input: “The trophy didn’t fit in the suitcase because it was too big.” What was too big? → Output: the trophy coreference:pronoun_simple 20 Input: “Alice told Bob that she would be late.” Who does “she” refer to? → Output: Alice fact_extraction:extract_entity 20 Input: Alice gave five apples to Bob at the park. Who received the apples? → Output: Bob fact_extraction:extract_number 20 Input: John gave 5 apples to Mary on Tuesday. How many apples? → Output: 5 ignoring_context 1 Input: Some text here. X=5X=5. More text. What is X? → Output: 5 ioi_task 1000 Input: Henry and Phil had a lot of fun at the harbor. Henry gave a basket to → Output: Phil Compositional (3090) blended_compositions:extract_verify 6 Input: Nora gave 3 apples to Ben; Ben gave 1 apple to Li. Claim: Ben received apples before giving any away. → Output: True compositional:extract_verify 6 Input: Ravi arrived after Mina, but before Joel. Claim: Joel arrived before Mina. → Output: False compositional:lower_first 971 Input: AFGHANISTAN → Output: a compositional:plural_first 165 Input: child → Output: c compositional:reverse_last 971 Input: Afghanistan → Output: A compositional:upper_first 971 Input: afghanistan → Output: A Table 8: Elemental tasks grouped by skill category, with the number of evaluation examples and one representative example for each task.