PaperlayerView exact revision on arXiv

Source-linked AI summary

SkillZip: Evaluation-Free Skill Compression for Self-Evolving Agents by Discovering Reusable Structure

Xiaofan Bai, Hongqiang Lin, Chao Liu, Yantao Zhang, Xuan Jin, Xipeng Cao, Yuhong Li

arXiv:2608.11079v1cs.AI

TL;DR

Self-evolving agents accumulate redundant, hard-to-maintain skills as successful procedures and fixes are appended rather than coherently reused. SkillZip compresses these skills through evaluation-free structural sharing, achieving 31.2% average compression while preserving or improving overall performance.

  • Problem

    Self-evolving agents often maintain accumulated instructions as append-only notebooks, causing redundant and incoherent skill representations.

  • Method

    SkillZip finds a shortest faithful explanation of a typed skill contract using MDL-based sharing, references, exceptions, and hard coverage constraints.

  • Results

    31.2% average compression preserves or improves overall performance without tasks, rollouts, or verifiers during compression.

  • Takeaways & Limitations

    SkillZip reduces skill length while retaining procedural knowledge and protecting unique requirements through structural coverage.

  • Takeaways & Limitations

    Reported runtime comparisons are optimistic lower bounds because some validation rollouts use a warm evaluation cache.

Abstract

from arXiv · show

Self-evolving agents accumulate reusable skills by appending successful procedures and failure fixes. Over time, the same requirement is often restated in several branches, examples, and warnings, while common action sequences are copied rather than reused. The resulting skill becomes expensive to inject and difficult to maintain. Generic prompt compression is ill-suited to this setting because a skill is not a flat passage: its name and description define when it applies, its workflow controls execution, its tool and output contracts constrain validity, and rare exceptions may remain essential even when no sampled task activates them. Evaluation-guided compression can test these behaviors, but it introduces rollouts, cost, and dependence on the compression-time evaluation set. We present SkillZip, an evaluation-free method that compresses a skill by finding its shortest faithful structural explanation. The intuition is explain once, reference many: state a repeated rule once at the scope where it applies, factor a repeated action sequence into a shared procedure, and keep only the differences as explicit exceptions. We formalize this intuition as a typed minimum description-length objective over a skill contract and a residual, subject to a hard coverage constraint for every extracted trigger, workflow edge, tool requirement, obligation, and output field. The formulation provides simple sharing thresholds, preserves unique rare rules by construction, and supports efficient local updates. SkillZip has a one-shot mode with one structured extraction call and deterministic optimization, and a continual Zip-on-Write mode that integrates each self-evolution patch without replaying tasks or reparsing the full history. Through comprehensive experimental evaluations, we demonstrate the effectiveness and superiority of SkillZip in compression performance, generalizability, and cost overhead.

I. Introduction … B. Prompt and Context Compression

Self-evolving skills accumulate redundant procedural text as append-only artifacts, making generic prompt compression inadequate for reusable skills whose meaning depends on structured contracts and workflow relations. SkillZip addresses this mismatch with evaluation-free structural compression, combining shortest faithful explanations, hard coverage, and one-shot or continual maintenance modes.

  • I. Introduction: Self-evolving agents append warnings, examples, and successful procedures, causing skills to grow textually even when genuinely new procedural content stabilizes.Repeated invariants, workflow branches, and validate–repair–verify sequences create redundancy in accumulated skills.
  • I. Introduction: For evolved skills, compression should consolidate repeated representations rather than filter supposedly irrelevant content.The main redundancy is repeated invariants across branches, restated workflows after failures, and general rules followed by narrower exceptions.
  • B. Prompt and Context Compression: Unlike query-conditioned prompt compressors, SkillZip preserves reusable procedural meaning encoded by triggers, action order, branch guards, tool arguments, and output fields.Future tasks are unknown, and no compression-time query may activate requirements that still must be retained.
  • I. Introduction: SkillZip models a skill as an operating manual with an interface, procedure, tool and output contracts, and globally or locally scoped rules.This typed structure exposes opportunities for scope lifting and workflow reuse that token importance cannot detect.
  • I. Introduction: Its MDL principle seeks the shortest faithful explanation by paying once for shared structure and separately for genuine differences.The formulation unifies semantic sharing, scope lifting, workflow reuse, and exception encoding while using hard coverage to preserve rare rules independently of task frequency.
  • I. Introduction: One-shot SkillZip uses one structured extraction call followed by deterministic optimization, while Zip-on-Write updates only compatible compact-state regions without replaying tasks or reparsing full history.Zip-on-Write can absorb patches, refine rules, add requirements, trigger local refactoring, and periodically repack emerging patterns.
  • A. Self-Evolving Agents and Persistent Skills: Research on self-evolving agents emphasizes acquiring procedural knowledge through persistent artifacts and execution-trace improvement, whereas SkillZip addresses their subsequent maintenance problem.Examples include ACE, SkillRL, SkillClaw, SkillRevise, and SkillGrad.

C. Skill Compression and Efficient Execution … C. Typed Units, Scope, and Coverage

SkillZip represents skills as typed, inspectable contracts and compresses them by sharing reusable structure while preserving every extracted operational requirement and ambiguous span. Its evaluation-free guarantee is structural: coverage is enforced over interface, workflow, tools, rules, outputs, and supporting evidence without downstream task access.

  • C. Skill Compression and Efficient Execution: SkillReducer provides the closest textual baseline, while SkillZip targets multi-round evolved skills with structured, continually maintainable compression.SkillReducer uses routing minimization, content classification, on-demand references, faithfulness checks, and task feedback; SkillZip maintains a structured sidecar but deploys an ordinary human-readable skill.
  • D. Minimum Description Length: SkillZip adapts minimum description length and grammar-style reuse to typed procedural knowledge, sharing a definition when it costs less than repeating the structure.The MDL principle minimizes the joint description of a model and the data it explains, while SEQUITUR and Re-Pair replace repeated subsequences with reusable rules.
  • A. Evaluation-Free Compression: Compression is evaluation-free because it may inspect the skill, referenced files, and continual patches, but not downstream tasks, trajectories, rewards, or behavioral verifiers.Generalization is measured only after compression, while deployment requires a shorter ordinary text artifact that preserves rare conditions and remains inspectable, versionable, and backbone-independent.
  • A. Evaluation-Free Compression: The structural guarantee preserves every extracted operational element and copies ambiguous source spans verbatim rather than claiming arbitrary behavioral equivalence.This makes the guarantee boundary explicit and treats parser uncertainty conservatively, without hiding it behind a finite evaluation suite.
  • B. The Contract Hidden Inside a Skill: The skill contract decomposes into interface, workflow, tool protocol, scoped rules, output contract, and supporting evidence, making safe compression type- and scope-dependent.These components capture triggers and exclusions; actions and control flow; tool signatures and error handling; guarded obligations; output fields and validation; and linked examples, templates, and rationale.
  • C. Typed Units, Scope, and Coverage: Typed units record type, scope, guards, modality, normalized content, and supporting spans, with workflow edges, tool signatures, and output validation represented explicitly.The parser maps source spans to typed units; additional records capture incoming and outgoing workflow edges, tool arguments, and output fields.
  • C. Typed Units, Scope, and Coverage: A compact representation covers a skill only when it accounts for all required interface conditions, workflow nodes and edges, tool requirements, scoped rules, and output requirements.Coverage may be direct or structural through common-ancestor rules and shared procedures, but remains type-sensitive: tool names do not cover arguments, and general rules do not cover conflicting guarded exceptions.
  • C. Typed Units, Scope, and Coverage: The selected representation must be shortest after accounting for definitions, references, exceptions, and unexplained residual text, rather than merging everything similar.This coverage-aware selection is the transition from contract extraction to the compact representation chosen by the optimizer.

IV. Theoretical Analysis · A. The Shortest Faithful Explanation · B. One Objective, Four Skill-Specific Decisions

SkillZip treats compression as finding the shortest representation of a typed skill contract while preserving complete coverage. One objective governs sharing equivalent requirements, scoped rules, repeated workflows, and guarded variants, with genuine exceptions retained explicitly.

  • IV. Theoretical Analysis: Shared abstractions are useful only when defining and referencing them is shorter than repeating all instances.The intuition is analogous to refactoring repeated code: explain shared structure once and retain genuine differences explicitly.
  • A. The Shortest Faithful Explanation: SkillZip represents a compressed skill with a reusable library K and residual R for unique, exceptional, or uncertain contract content.The library can contain shared rules, workflow fragments, tool contracts, output fields, and interface entries; the residual preserves exceptions that cannot be safely normalized.
  • A. The Shortest Faithful Explanation: SkillZip selects the shortest candidate representation that covers every required contract unit.Its length measure includes rendered tokens plus definition, reference, and scope-annotation overhead.
  • A. The Shortest Faithful Explanation: Compression may change how a requirement is written, but cannot remove a unique requirement merely because it is short.This minimum-description-length formulation preserves contract representation under compression.
  • B. One Objective, Four Skill-Specific Decisions: Equivalent requirements are represented once when a shared rule plus residual differences is shorter than separate copies.This is one of four reusable-structure decisions governed by the same objective.
  • B. One Objective, Four Skill-Specific Decisions: Rules move to the nearest common scope only when they apply to every relevant path; conflicting branch behavior remains an explicit exception.The scope condition prevents normalization from erasing branch-local differences.
  • B. One Objective, Four Skill-Specific Decisions: Recurring action sequences become shared procedures only when saved repetitions exceed definition and call costs, while guarded variants require faithful, shorter exception structures.These are alternative ways to cover the same typed contract, not independent rewrite heuristics.

C. Preservation and Continual Compression … B. Continual Compression: Zip-on-Write

SkillZip preserves every extracted contract requirement, including rare rules, through hard coverage, while enabling efficient continual compression through local updates and occasional global repacking. Its pipeline recovers a typed contract, selects reusable structure, renders the compact skill, and consolidates self-evolution patches through four contract-preserving operations.

  • C. Preservation and Continual Compression: Hard coverage ensures every normative source span is represented, so feasible compression preserves all extracted requirements regardless of the length model.The guarantee applies to the extracted contract; uncertain spans are retained verbatim rather than discarded.
  • C. Preservation and Continual Compression: Unique requirements remain protected independently of their frequency in compression-time tasks.Guards, tool arguments, exceptions, and output fields are preserved because they belong to the parsed contract.
  • C. Preservation and Continual Compression: Local updates optimize only a patch’s affected type–scope neighborhood, while occasional global repacking recovers reuse that accumulates across patches.Repacking restores missed cross-scope savings without rerunning over all historical prose.
  • V. SkillZip: One-shot SkillZip recovers a typed contract, applies “explain once, reference many” to repeated rules and workflows, and renders the result back into a normal skill.Unique and uncertain content remains explicit in the compact contract.
  • A. One-Shot Compression: The one-shot pipeline scans structured Markdown, extracts cited contract units, proposes only type-compatible reuse, selects a shortest covering explanation, and audits the rendered result.The renderer uses fixed templates for triggers, rules, workflows, guarded branches, tool requirements, and output schemas.
  • B. Continual Compression: Zip-on-Write: Zip-on-Write compares each patch as ABSORB, REFINE, EXTEND, or REFACTOR and chooses the feasible operation with the smallest increase in Eq. (4).The operations respectively absorb restatements, add refinements, introduce requirements, or change representation without changing coverage.
  • B. Continual Compression: Zip-on-Write: Patch candidate search retrieves O(dk) candidates rather than the complete history, and repacking triggers when recoverable savings, contract growth, or patch-count thresholds are reached.Repacking operates on the compact contract, while the evolver determines learned knowledge and SkillZip determines only its representation.

VI. Experiments … C. RQ2: Can SkillZip Preserve Skill Fidelity?

The experiments evaluate SkillZip across controlled and model-backed protocols, showing that self-evolution causes substantial skill growth while SkillZip compresses evolved skills without reducing overall task performance. The results also contrast SkillZip’s structural consolidation with SkillReducer’s evaluation-dependent debloating regime.

  • VI. Experiments: The experimental section evaluates SkillZip’s claims about self-evolution-induced redundancy and evaluation-free compression through five research questions.The protocols cover skill growth, compression–fidelity trade-offs, compression cost, and additional research questions.
  • A. Experimental Setup: Experiments use Qwen3.7-Max, Qwen3.6-Plus, and Kimi K2.6 across three benchmarks with matched model, scaffold, prompt, tools, budgets, and decoding settings.The benchmarks test web retrieval and reasoning, theorem-grounded mathematical reasoning, and complementary procedural requirements.
  • A. Experimental Setup: Each model–benchmark pair starts from a human-authored skill, evolves it with SkillOpt on a disjoint evolution split, then freezes it for all compression comparisons.The evolved skill is the common input to the compression methods and final benchmark evaluation.
  • A. Experimental Setup: Baselines include No Skill, Human Skill, Evolved Skill, and SkillReducer, with the uncompressed evolved skill serving as the fidelity reference.These conditions distinguish the effects of having no task skill, the seed skill, the evolved skill, and an alternative reducer.
  • B. RQ1: Skill Growth in Self-Evolution?: By Round 5, skills reach approximately 5.6×, 3.1×, and 6.7× their initial sizes on BFCL-V4, LiveMath, and SpreadsheetBench, respectively, averaging about 5.2× growth.Skill length increases monotonically across benchmarks as repeated rules, overlapping workflows, and increasingly specific exceptions accumulate.
  • B. RQ1: Skill Growth in Self-Evolution?: Self-evolution expands skills to more than 5× their initial length on average, making compression necessary to limit the growing context burden.The accumulated material may be locally useful while still becoming globally bloated without consolidation.
  • C. RQ2: Can SkillZip Preserve Skill Fidelity?: SkillZip achieves 27.1%–36.9% compression, 31.2% on average, while its macro-average score is 0.577 versus 0.570 for the uncompressed evolved skill.The evolved skill outperforms no-skill and human-skill conditions in eight of nine settings, and SkillZip retains or improves overall performance.
  • C. RQ2: Can SkillZip Preserve Skill Fidelity?: Compared with SkillReducer, SkillZip delivers 31.2% versus 9.2% average compression and 0.577 versus 0.544 task performance.SkillReducer additionally uses 40–80 validation rollouts per compression, whereas SkillZip targets execution-dense evolved skills through structural consolidation rather than content filtering.

D. RQ3: Compression Efficiency … VII. Conclusion

SkillZip reduces compression cost without task rollouts, generalizes across agent backbones, and controls continual skill growth when activated from the start. Its typed-contract, shortest-faithful-explanation framework shares reusable structure while preserving explicit exceptions and rare requirements.

  • D. RQ3: Compression Efficiency: SkillZip reduces average compression time from 1331 to 207 seconds on LiveMath, from 1082 to 332 on Spreadsheet, and from 587 to 318 on BFCL-V4.Averaged across datasets, SkillZip requires 286 seconds, corresponding to a 3.5× speedup.
  • D. RQ3: Compression Efficiency: SkillZip achieves a 3.5× average speedup over SkillReducer while requiring zero task rollouts.SkillReducer additionally requires 40–80 task rollouts for candidate validation and repair, whereas SkillZip uses structured LLM calls without task rollouts.
  • E. RQ4: Cross-Model Generalization: On LiveMath, SkillZip achieves cross-model retention of 0.97 compared with 0.91 for SkillReducer.The improvement mainly comes from off-diagonal source–target pairs, while same-model results are comparable.
  • E. RQ4: Cross-Model Generalization: SkillZip transfers compressed skills across agent backbones without target-specific evaluation, improving LiveMath retention and remaining comparable to SkillReducer on BFCL-V4.Preserving explicit rules, guards, and output constraints supports a more model-independent skill representation.
  • F. RQ5: Continual Zip-on-Write Compression: Without compression, skill length grows monotonically to 2.5×, 3.1×, and 3.7× seed length across three LiveMath backbones, whereas round-1 Zip-on-Write caps growth at roughly 1.6×–1.9×.This corresponds to a 38%–50% reduction relative to the uncompressed endpoint because each write is immediately absorbed into the typed contract library and periodically repacked.
  • F. RQ5: Continual Zip-on-Write Compression: Activating compression at round 8 only partially recovers redundancy and never catches up with round-1 activation, such as 2.6× versus 1.9× on Kimi-k2.6.The round-1 configuration matches or slightly exceeds the uncompressed final held-out test accuracy, indicating no accuracy-for-compactness tradeoff.
  • VII. Conclusion: SkillZip treats skills as typed contracts and compresses them by explaining shared structure once, referencing it where needed, and keeping genuine differences explicit.Its shortest-faithful-explanation objective is evaluation-free, protects rare requirements through hard coverage, and unifies rule sharing, scope placement, workflow reuse, and exception handling.

Appendix A Additional Theoretical Details … B. Decision-Specific Cost Tests

The appendix provides reproducibility-oriented theoretical, implementation, schema, protocol, and compression analyses. Its decision-specific tests determine when requirements, scopes, workflows, and exceptions should be structurally shared without sacrificing faithful coverage.

  • Appendix roadmap: The public appendix serves as a reproducibility companion covering theoretical proofs, implementation and continual updates, contract schemas, prompts, experiments, and compression analyses.It is explicitly presented as more than a space-constrained supplement.
  • A. Practical Length Model: The practical length model charges rendered tokens plus named-abstraction, reference, and scope costs to prevent costly proliferation of tiny abstractions.These overhead terms rule out degenerate abstractions whose notation exceeds their savings.
  • B. Decision-Specific Cost Tests: Equivalent requirements are shared when the common typed unit and residual descriptions are shorter than separately encoding both clauses.True paraphrases have nearly empty residuals, while polarity, guard, tool-argument, or output-field differences can make sharing unprofitable.
  • B. Decision-Specific Cost Tests: A rule is lifted to the closest common ancestor only when every relevant path requires it and local conflicts are represented as exceptions.Among feasible placements, the selected placement is determined by the decision-specific cost comparison.
  • B. Decision-Specific Cost Tests: A repeated non-overlapping workflow fragment becomes a shared procedure when reuse savings exceed definition and call overhead.The threshold depends on fragment length, occurrence count, and abstraction overhead.
  • B. Decision-Specific Cost Tests: Guarded clauses with a common core are consolidated only when the common representation is shorter and each guarded difference remains attached as an exception.The residual records the difference for every clause it modifies.

C. Proofs and Additional Guarantees … A. Repository and Command-Line Interface

The paper proves that SkillZip preserves required contract units and supports exact local updates under a stated condition, while clarifying guarantee boundaries and specifying an auditable implementation with transactional CLI workflows.

  • C. Proofs and Additional Guarantees: Coverage is mandatory: every required unit must be directly represented, safely shared, expanded through a workflow, or retained verbatim in the residual.Removing the sole representation of any required unit violates the feasibility constraint.
  • C. Proofs and Additional Guarantees: A shared definition is beneficial exactly when saved repetition cost exceeds definition and reference overhead.The separate form costs rL(q), while the shared form costs L(def(q)) + rL(call(q)).
  • C. Proofs and Additional Guarantees: Local optimization matches full-contract batch optimization when no profitable abstraction spans both affected and unaffected regions.Periodic global repacking can recover cross-region savings, but coverage remains enforced after every patch.
  • D. Boundary of the Guarantee: The preservation guarantee applies to the parser-produced contract, not perfect natural-language interpretation or identical behavior across every language model.Provenance, parser confidence, locked residuals, and optional structural audits support the conservative failure mode of under-compression.
  • Appendix B Implementation Details: The repository separates parsing, optimization, rendering, and evaluation so the evaluation-free claim can be audited from file access and logs.Its modules cover stable-ID scanning, schema-constrained extraction, typed retrieval, workflow mining, min-cost covering, deterministic rendering, auditing, and Zip-on-Write.
  • A. Repository and Command-Line Interface: The CLI supports one-shot compression, continual updates, structural audits, and inspection of accepted or rejected abstractions with savings.Commands operate on SKILL.md, persistent state, patches, compact output, and configuration files.
  • A. Repository and Command-Line Interface: Persistent state is replaced only after schema validation, coverage validation, and rendering succeed.The CLI writes through temporary files before committing the validated result.

B. Deterministic Scanning and Stable Provenance · C. Relation Checking Pipeline · E. Scope Optimization and Workflow Packing

The pipeline uses deterministic structural scanning and provenance, typed relation checks, explicit cost accounting, and optimization procedures for scope placement and workflow reuse. These mechanisms preserve atomic structures and conflicts while selecting only feasible, positively saving sharing candidates.

  • B. Deterministic Scanning and Stable Provenance: The scanner hashes normalized text with ancestor headings for stable block identifiers while storing line ranges separately, preserving provenance across unrelated insertions.Code fences and tables remain atomic to avoid destroying templates or schemas.
  • B. Deterministic Scanning and Stable Provenance: Markdown nesting and explicit guards define scopes, while wider-scope promotion requires universal language or structural repetition across relevant children.Guards can create child scopes even without headings.
  • C. Relation Checking Pipeline: Relation checking first filters units by hard compatibility keys, then merges exact hashes and uses keyed embeddings plus a frozen cross-encoder for remaining candidates.The cross-encoder labels equivalence, directional implication, conflict, or unrelatedness; only equivalence and implication support sharing.
  • C. Relation Checking Pipeline: Conflicts become exception edges, low-confidence pairs remain separate, and cache keys make relation checks deterministic and reusable in Zip-on-Write.Caches include normalized texts, types, scope signatures, model revision, thresholds, and prompt hashes.
  • C. Relation Checking Pipeline: The practical length model sums rendered-token cost with penalties for definitions, references, and scope depth, using delimiter costs rather than downstream-task fitting.Candidate logs separately record before, definition, reference, exception, residual, and after costs.
  • E. Scope Optimization and Workflow Packing: A bottom-up dynamic program places each normalized rule at the minimum-cost feasible scope, rejecting placements with unneeded reachable children or unencoded conflicts.The optimizer compares retaining child copies with placing one ancestor copy.
  • E. Scope Optimization and Workflow Packing: Workflow paths encode action type, tool, required arguments, and guard class; repeated adjacent pairs and branch segments become packing candidates only with compatible behavior and positive savings.Candidates require at least two non-overlapping occurrences, and selection is a weighted set-packing problem using greedy saving per covered token followed by pairwise processing.

F. Structural Audit and Conservative Recovery … D. Independent Audit Prompt

The paper combines contract-preserving extraction, independent structural auditing, conservative recovery, and transactional online updates. Its sidecar schema records triggers, scopes, workflows, rules, outputs, evidence, shared procedures, and residuals, while prompts and host checks enforce cited, valid structure.

  • F. Structural Audit and Conservative Recovery: Independent auditing reparses the rendered skill and deterministically checks triggers, guards, modalities, reachability, tool arguments, and output fields.Missing elements are recovered from the shortest original source spans and marked locked=true, preventing deletion without explicit user approval.
  • G. Atomic Online Updates: Zip-on-Write atomically validates, applies, renders, replaces, and commits each patch through a write-ahead log.A crash before commit preserves the previous skill, while repacking occurs in a separate transaction.
  • A. Core Sidecar Schema: The contract schema represents triggers, exclusions, scopes, workflow nodes, rules, outputs, termination conditions, evidence, shared procedures, and residual reasons.Workflow nodes include action kinds, tools, required arguments, successors, spans, and confidence; rules include modality, predicates, guards, locking, and confidence.
  • Appendix C Contract Schema and Prompts: The schema’s shared procedures and residual entries support reusable action sequences while retaining ambiguous, unique-evidence, or user-locked source blocks.Shared procedures record occurrences and token savings; residual reasons include AMBIGUOUS, UNIQUE_EVIDENCE, and USER_LOCKED.
  • B. One-Shot Extraction Prompt: One-shot extraction preserves negation, quantifiers, guards, action order, tools, arguments, error handling, and output fields without compressing or summarizing.The host rejects unknown source IDs, uncited units, dangling workflow edges, unsupported output fields, and unsupported required arguments.
  • C. Patch Prompt: Patch processing scopes each unit narrowly, compares only supplied existing units, and proposes ABSORB, REFINE, EXTEND, or REFACTOR while preserving conflicts as guarded exceptions.The host recomputes savings and decides whether to apply the operation.
  • D. Independent Audit Prompt: The independent audit prompt requires exact preservation of triggers, exclusions, guards, modalities, tool arguments, workflow edges, output fields, and termination conditions.It explicitly forbids using the original skill or an expected answer.

E. Prior and Post-Compressed Skill Example

The LiveMath example shows SkillZip compressing a repeatedly self-evolved competition-math skill from 936 to 638 tokens while nearly perfectly preserving performance. The compressed version consolidates duplicated validation and arithmetic-checking guidance into a structured workflow without changing the skill’s core contract.

  • Compression result: 936 to 638 tokens (32% saving) with nearly perfect preservation of performance demonstrates SkillZip’s one-shot compression on the LiveMath skill.The skill was produced through SkillOpt-based self-evolution for qwen3.6-plus.
  • Uncompressed skill: Repeated self-evolution re-appended the single-valid-value rule and intermediate-product-and-sum verification rule, creating explicit redundancy.The single-value guidance appears twice, as does the arithmetic-verification guidance; related candidate-validation instructions are also repeated.
  • Compressed skill: The compressed skill preserves the competition-math name, description, usage scope, exact-format output requirements, and core mathematical rules.Its output contract retains boxed answers, exact forms, set notation, multiple-answer formatting, and filtering of invalid candidates.
  • Compressed skill: SkillZip reorganizes the procedure into a five-step workflow that explicitly includes solving, verification, and sanity-checking.The compressed workflow restates the problem, selects and justifies a method, introduces notation and constraints, solves exactly, and verifies the result.

Appendix D Additional Theory and Analysis … D. Idempotence Under a Stable Parse

The appendix distinguishes structural minimum-description-length compression from semantic deduplication, decomposes optimization into specialized subproblems, and bounds its guarantee by parser output. Under stable parsing and deterministic choices, SkillZip is idempotent: recompression introduces no new candidates and preserves the covered contract.

  • A. Why the Objective Is More Than Semantic Deduplication: Semantic similarity alone does not justify merging clauses when shared-definition, reference, scope, and exception costs make the representation longer.The objective can reject plausible merges when exception encoding is verbose.
  • A. Why the Objective Is More Than Semantic Deduplication: Workflow abstraction can remain beneficial when occurrences are far apart but share a guarded action pattern.The optimizer also compares competing abstractions that use overlapping source units.
  • B. Optimization Decomposition: Equivalent-unit clustering, rule placement, and workflow selection reduce respectively to union–find, tree dynamic programming, and weighted set packing.Overlapping procedures cannot replace the same action occurrence simultaneously.
  • B. Optimization Decomposition: The implementation uses greedy selection with pairwise exchange, while an exact integer program measures approximation gaps on benchmark instances.The exact solver is not used in the implementation described.
  • C. Boundary of the Guarantee: Proposition IV.1 guarantees protection of the parser-produced contract, not perfect interpretation of arbitrary natural language.Cited source blocks, parser confidence, locked residuals, structural audit, and per-type parser evaluation expose this boundary.
  • D. Idempotence Under a Stable Parse: Zip(Zip(𝑆)) = Zip(𝑆) when rendering and reparsing recover the same covered contract under fixed parser output, candidates, length model, renderer, and tie breaking.A second pass then introduces no candidate absent from the first minimization; token and contract differences will be tested empirically.
Loading 2608.11079v1…