Value-Write Association

• Value-write association is a design pattern that binds an evaluative signal (e.g., eCPM, memory worth) to write operations, influencing correctness and performance.
• It distinguishes between write feasibility (ensuring legal, decodable writes) and write valuation (prioritizing writes based on dynamic or static evaluative metrics).
• Practical applications span from token-level optimization in sponsored search to enhanced memory governance and energy-efficient persistent storage operations.

Searching arXiv for the cited papers and topic framing. Searching VALUE paper. Value-write association denotes a family of mechanisms that bind a value signal to a write operation or to the state changes induced by writing, so that subsequent computation, retrieval, or governance is conditioned not only on semantic or logical correctness but also on a measured or prescribed notion of value. Across contemporary systems, the association appears in several technically distinct forms: token-level value-aware decoding for sponsored-search query rewriting, lookup-table-driven write semantics in associative processors, key-to-location publication in persistent storage engines, outcome-linked memory governance in agent systems, learned value-to-address placement in non-volatile memory, value-guided program synthesis, and decoupled erase/write control in fast-weight linear attention. In each case, the central problem is to connect a write event with an evaluative signal—commercial value, arithmetic output, storage durability, empirical success, endurance cost, search utility, or associative fidelity—while preserving correctness under the system’s operational constraints (Zuo et al., 25 Feb 2025, Hout et al., 2021, Chursin et al., 2 Feb 2026, Simsek, 13 Apr 2026, Kargar et al., 2020, Ellis et al., 2019, Hatamizadeh et al., 21 May 2026, Barnfield et al., 6 May 2026).

1. Conceptual scope and recurring structure

A common abstraction runs through otherwise unrelated formulations. A system first defines a write domain: token continuations in a catalog, masked CAM columns, WAL-resident value bytes, memory units, NVM addresses, partial programs, or fast-weight state matrices. It then associates each admissible write with an auxiliary signal that is not identical to syntactic validity or raw storage feasibility. In sponsored search, that auxiliary signal is eCPM at decoding time; in agent memory governance, it is the empirical conditional success probability of episodes retrieving a memory; in NVM placement, it is similarity to extant contents measured through Hamming distance; in linear attention, it is the selective preservation of associative bindings under separate erase and write gates (Zuo et al., 25 Feb 2025, Simsek, 13 Apr 2026, Kargar et al., 2020, Hatamizadeh et al., 21 May 2026).

This suggests a unifying distinction between write feasibility and write valuation. Write feasibility determines which writes are legal, decodable, or durable. Write valuation determines which feasible writes should be preferred, suppressed, grouped, or redirected. In some systems these two are fused. The weighted trie in VALUE both masks invalid continuations and reweights valid ones by trie-derived value scores; the blocked methodology in the ternary associative processor both preserves write correctness and minimizes write cycles by grouping identical outputs (Zuo et al., 25 Feb 2025, Hout et al., 2021).

Another recurring distinction is between static and dynamic association. Static association is fixed at write time or by a predefined truth table. Dynamic association is updated by logs, retrieval outcomes, decays, or changing workloads. VALUE refreshes trie node statistics through momentum updates as eCPM changes; Memory Worth updates two counters per memory unit after each episode; Tidehunter atomically replaces a key’s pointer to the latest WAL position; PNW retrains its K-means model lazily as workload distributions shift (Zuo et al., 25 Feb 2025, Simsek, 13 Apr 2026, Chursin et al., 2 Feb 2026, Kargar et al., 2020).

2. Token-level commercial value association in sponsored search

In sponsored search, value-write association is formalized most explicitly by VALUE, which introduces a weighted trie into LLM decoding so that token generation is conditioned simultaneously on semantic relevance and business value (Zuo et al., 25 Feb 2025). The motivating claim is that semantic relevance alone is insufficient because two bidwords can differ by a single character yet have drastically different economic outcomes even when both are relevant. Standard SFT treats query–bidword pairs equally in the loss, and standard preference alignment methods such as DPO or PRO are described as prone to overfitting when positive and negative samples are lexically very similar (Zuo et al., 25 Feb 2025).

The system associates value with writing by attaching eCPM-derived statistics to trie nodes in tokenization space. Each node stores children, mean, max, and is_word. Leaf nodes receive leaf.mean ← eCPM(bidword), leaf.max ← eCPM(bidword), leaf.is_word ← True, and internal nodes aggregate value bottom-up with

$$\text{node.mean} \leftarrow \frac{1}{N}\sum_{\text{child}\in\text{children}}\text{child.mean}, \qquad \text{node.max} \leftarrow \max_{\text{child}\in\text{children}}\text{child.max}.$$

For evolving catalogs and fluctuating eCPM, the framework uses

$$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$

These quantities are then consulted during decoding under the current prefix (Zuo et al., 25 Feb 2025).

The association is realized at the next-token level. Under the current prefix, each child continuation receives

$$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$

with $\alpha_v=\beta_v=0.5$ used in experiments, followed by per-step normalization

$$\hat v_k=\frac{\exp(v_k/\tau_v)}{\sum_{j\in C(\text{prefix})}\exp(v_j/\tau_v)}.$$

The paper gives the multiplicative reweighting form

$$p'(k\mid x,y_{<i})= \frac{p_\theta(k\mid x,y_{<i})\cdot (1+\theta_i\cdot \hat v_k)}{Z},$$

with invalid tokens masked to zero and

$$Z=\sum_{j\in C(\text{prefix})}p_\theta(j\mid x,y_{<i})\cdot (1+\theta_i\cdot \hat v_j).$$

A logit-additive formulation is also described as equivalent in effect (Zuo et al., 25 Feb 2025).

The significance of this formulation is that value is attached directly to the act of writing the next token, rather than being learned only through post hoc preference optimization. The LLM’s semantic distribution remains the backbone, while the trie constrains the space to catalog-valid continuations and biases the trajectory toward high-value subtrees. This enables what the paper terms “fine-grained, token-level control” through $\theta_i$, $\alpha_v$, and $\beta_v$ (Zuo et al., 25 Feb 2025).

Offline and online results tie this association to system-level outcomes. VALUE (SFT + WeightedTrie) reports hitrate@50 = 60.37%, hitrate@500 = 91.52%, Relevance = 74.55%, Spearman’s ρ = 0.46, OOVR = 0%, and eCPM = 59,803; VALUE + WDPO reports hitrate@50 = 62.67%, hitrate@500 = 91.91%, Relevance = 73.49%, Spearman’s ρ = 0.56, OOVR = 0%, and eCPM = 63,775 (Zuo et al., 25 Feb 2025). The reported online A/B test over 14 days gives Cost +1.53%, [RPM](https://www.emergentmind.com/topics/raven-s-progressive-matrices-rpm) +1.64%, and PV relevance +0.32 pt, with Tail: +2.66% RPM lift (Zuo et al., 25 Feb 2025). A plausible implication is that decoding-time value association can substitute for, or dominate, expensive retraining-centric reward alignment when the target signal is instance-specific and volatile.

3. Match–tag–write association in associative processors

In the in-memory multi-valued associative processor, value-write association has a different meaning: it is the explicit mapping from matched CAM content to the values written back into masked columns of tagged rows (Hout et al., 2021). The basic execution cycle is match–tag–write: compare a key against all rows, mark matching rows, and overwrite masked bits in those tagged rows. The contribution of the paper is to formalize how multi-valued arithmetic functions can be executed by algorithmically generated lookup-table passes and to optimize write-cycle count through a blocked strategy (Hout et al., 2021).

Correct association here is primarily a correctness problem. Each LUT pass applies a masked key, tags matching rows, and writes the corresponding output. If pass ordering is incorrect, later passes can overwrite rows in ways that create “domino” effects. The paper therefore constructs a state diagram from the function’s truth table, turns it into a directed acyclic graph where possible, and uses cycle breaking by increasing writeDim when necessary. In the ternary full adder, the cycle 101 → 120 → 101 is broken by writing A=0 for 101, yielding 020 instead of 120, while preserving the correct sum/carry overwrite for B and Cin (Hout et al., 2021).

The non-blocked method assigns passes by DFS from noAction roots, ensuring that once a state is overwritten it is not revisited by a later pass. The blocked method groups nodes with the same write action and defers the write until the end of the group. The grouping key is

$$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$0

which separates groups across write dimensions (Hout et al., 2021). Grouping is constrained by top-level DAG structure, so nodes can be merged only when they are at the current top DAG level and share the same outVal and writeDim.

This optimization changes the economics of the write operation without changing the logical function being computed. For the ternary full adder, the non-blocked approach requires 21 writes because there are 27 input triplets and 6 noAction states, whereas the blocked approach yields 9 groups and thus 9 writes (Hout et al., 2021). The architecture-level outcome is that the ternary AP adder shows a 12.25% reduction in energy and a 6.2% reduction in area relative to the binary AP adder, and a 52.64% reduction in energy with delay up to 9.5x smaller relative to a state-of-the-art ternary carry-lookahead adder (Hout et al., 2021).

This case highlights a different interpretation of value-write association: the “value” is not an external reward but the exact output vector that must be associated with a matched state, and the optimization target is the write schedule itself. The blocked methodology shows that association can be operationally restructured—via grouping and deferred writes—while preserving functional equivalence.

4. Durable key-to-value publication in persistent storage systems

In persistent key-value storage, value-write association refers to the durable binding between a logical update and the physical location that now stores the value bytes, together with the index metadata that publishes that location to future readers (Chursin et al., 2 Feb 2026, Li et al., 5 Jun 2025). The central technical issues are write amplification, publication ordering, crash consistency, and reclamation.

Tidehunter treats the WAL as permanent value storage and uses small sharded index tables to map keys to WAL positions, logically

$$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$1

Its invariant is that the index pointer for key $$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$2 always refers to the highest processed WAL position for that key, with tombstones represented explicitly (Chursin et al., 2 Feb 2026). The write path consists of atomic space reservation, mmap copy of the record into the WAL, in-memory index update, and notification that the position is “processed.” Recovery reconstructs missing associations by replaying the WAL suffix from snapshot metadata; batch-start markers ensure all-or-nothing recovery for atomic batches (Chursin et al., 2 Feb 2026).

The storage consequence is a near write-once value path. Tidehunter states that values are never overwritten and are not moved by compaction, giving value-side write amplification

$$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$3

and total amplification

$$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$4

where 40 B is the on-disk index entry size and $$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$5 is the relocation fraction (Chursin et al., 2 Feb 2026). For V = 1 KB, the paper gives WA ≈ 1.04 (Chursin et al., 2 Feb 2026). On a 1 TB dataset with 1 KB values, Tidehunter reports 830K writes/s, 8.4x RocksDB, 2.9x BlobDB, point gets of 392K ops/s, and existence checks of 3.55M ops/s (Chursin et al., 2 Feb 2026).

BVLSM addresses the same association problem in an LSM-tree setting but shifts association to the WAL phase rather than the flush phase (Li et al., 5 Jun 2025). For values above a threshold, the system first appends the value to a dedicated append-only BValue file and then writes Key + ValueOffset to the WAL and MemTable, where ValueOffset = {file_path (or file_id), offset, length} (Li et al., 5 Jun 2025). In sync WAL mode, durability depends on a strict ordering: value durable → WAL durable; if a crash occurs after value fsync but before WAL commit, the value is garbage, and if the crash occurs after WAL commit, both pointer and value exist (Li et al., 5 Jun 2025).

The reported effect is to remove big-value rewrites from compaction and to reduce MemTable pressure. Under 64 KB random writes in asynchronous WAL mode, BVLSM reports 7.6x throughput over RocksDB and 1.9x over BlobDB (Li et al., 5 Jun 2025). With 100 GB random writes and 4 KB values, it sustains 250–350 MB/s with the smallest standard deviation, outperforming BlobDB by 2× and RocksDB by 1.5× on average (Li et al., 5 Jun 2025).

These systems illustrate a storage-specific form of value-write association: a write is incomplete until a location is durably published. The “value” is literal payload data, but the association itself is metadata-driven and must survive crashes, relocation, and concurrent updates.

5. Outcome-linked memory governance and dynamic memory valuation

In memory-governed agents, value-write association is not about immediate physical placement or decoding choice but about retrospective operational value inferred from retrieval-outcome history (Simsek, 13 Apr 2026). The paper introduces Memory Worth (MW), a two-counter estimator that tracks how often a memory co-occurs with successful versus failed episodes. The target is

$$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$6

explicitly described as associational rather than causal (Simsek, 13 Apr 2026).

For each memory unit $$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$7, the system maintains

$$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$8

$$V_{\text{new}}=\max(eCPM_{\text{new}},V_{\text{old}}), \qquad W_{\text{new}}=\alpha\cdot eCPM_{\text{new}}+\beta\cdot W_{\text{old}}, \ \alpha+\beta=1.$$9

and

$$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$0

The estimate is

$$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$1

when evidence is nonzero, with MW_T(m) = 0.5 as an uninformative prior when V_m(T)=0 (Simsek, 13 Apr 2026). The paper also recommends Beta–Bernoulli smoothing with posterior mean

$$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$2

Under assumptions (A1)–(A6), the theorem states that MW_T(m) → p^{+}(m) almost surely (Simsek, 13 Apr 2026). The practical interpretation is that the value of a write is not fixed at storage time; it is revised as the memory is retrieved in episodes with known outcomes. This is a paradigmatic dynamic value-write association: the write creates a hypothesis, and subsequent use determines whether the hypothesis remains trusted.

The governance policies described in the paper operationalize the estimate. With θ_L = 0.40, θ_H = 0.60, and V_min ≈ 10, memories with low evidence are marked “uncertain,” those with MW_T(m) ≤ θ_L may be suppressed or reviewed, and those with MW_T(m) ≥ θ_H may be prioritized (Simsek, 13 Apr 2026). In the synthetic environment, after 10,000 episodes the Spearman rank-correlation between Memory Worth and true utilities reaches ρ = 0.89 ± 0.02 across 20 seeds, whereas a no-update baseline stays at ρ = 0.00 (Simsek, 13 Apr 2026). In the retrieval-realistic micro-experiment, a stale memory crosses the low-value threshold and ends at MW = 0.17, while a specialist memory remains at MW = 0.77 after 3,000 episodes (Simsek, 13 Apr 2026).

A common misconception is to read this quantity causally. The paper is explicit that $$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$3 is a conditional co-occurrence probability, not a causal effect (Simsek, 13 Apr 2026). This suggests that value-write association can be useful even when it is only associational, provided the system’s decision rule is governance rather than attribution.

6. Learned placement, synthesis guidance, and associative editing

Several additional systems instantiate value-write association by connecting the content being written to a cost, score, or preservation objective.

In Predict and Write, the write-time association is a learned mapping

$$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$4

that chooses a physical NVM address $$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$5 whose current contents $$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$6 minimize the Hamming distance to the incoming value $$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$7:

$$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$8

The K/V store’s indirection level permits redirecting PUT/UPDATE operations to any address chosen by the learned policy, replacing in-place updates with relocation that minimizes expected bit flips (Kargar et al., 2020). The core algorithm predicts a cluster for $$v_k=\alpha_v\cdot \text{mean}_k+\beta_v\cdot \text{max}_k,$$9, selects a free address from that cluster’s free-list in the Dynamic Address Pool, performs software read-before-write against $\alpha_v=\beta_v=0.5$0, writes only differing bits, and updates the hash index key → a (Kargar et al., 2020). The reported benefits are up to 85% fewer bit flips and up to 56% fewer cache lines written over baselines (Kargar et al., 2020). Here the “value” being associated to the write is not application-level utility but a hardware cost proxy: low flip count and improved endurance.

In “Write, Execute, Assess,” the association is between a proposed code write and a learned value estimate over the resulting partial program state (Ellis et al., 2019). The policy proposes the next action,

$\alpha_v=\beta_v=0.5$1

and the value function estimates

$\alpha_v=\beta_v=0.5$2

At test time, Sequential Monte Carlo uses the value function as an observation likelihood,

$\alpha_v=\beta_v=0.5$3

so branches that are promising after execution are resampled and expanded (Ellis et al., 2019). On the hard string-editing benchmark of 87 problems from 34 templates, value-guided SMC solves more tasks with roughly 10× fewer node expansions and less time than policy-only and non-REPL baselines (Ellis et al., 2019). In this case, a write has value only in relation to the executed semantics it induces.

In Gated DeltaNet-2, value-write association appears inside a recurrent fast-weight memory. The memory matrix $\alpha_v=\beta_v=0.5$4 stores compressed key-value bindings, and the central challenge is how to edit the state without scrambling existing associations (Hatamizadeh et al., 21 May 2026). The model introduces a channel-wise erase gate $\alpha_v=\beta_v=0.5$5 on the key axis and a channel-wise write gate $\alpha_v=\beta_v=0.5$6 on the value axis:

$\alpha_v=\beta_v=0.5$7

With channel-wise decay $\alpha_v=\beta_v=0.5$8, the update is

$\alpha_v=\beta_v=0.5$9

$$\hat v_k=\frac{\exp(v_k/\tau_v)}{\sum_{j\in C(\text{prefix})}\exp(v_j/\tau_v)}.$$0

The paper’s interpretation is that the erase gate controls which coordinates of the old read should be removed, while the write gate controls which value channels should be committed (Hatamizadeh et al., 21 May 2026). Empirically, the full model outperforms w-only and b-only ablations, with average recall 29.88 versus 28.92 and 29.51, respectively (Hatamizadeh et al., 21 May 2026). This suggests that value-write association can also mean preserving the fidelity of stored key→value bindings during compressed-memory updates.

A related theoretical perspective appears in the analysis of linear associative memory capacity (Barnfield et al., 6 May 2026). There, writing consists of superposing outer products

$$\hat v_k=\frac{\exp(v_k/\tau_v)}{\sum_{j\in C(\text{prefix})}\exp(v_j/\tau_v)}.$$1

and retrieval scores are

$$\hat v_k=\frac{\exp(v_k/\tau_v)}{\sum_{j\in C(\text{prefix})}\exp(v_j/\tau_v)}.$$2

The paper shows that the storage capacity depends on the retrieval criterion: top-1 winner-take-all requires the logarithmic scale $$\hat v_k=\frac{\exp(v_k/\tau_v)}{\sum_{j\in C(\text{prefix})}\exp(v_j/\tau_v)}.$$3, while listwise retrieval under Tail-Average Margin follows the quadratic scale $$\hat v_k=\frac{\exp(v_k/\tau_v)}{\sum_{j\in C(\text{prefix})}\exp(v_j/\tau_v)}.$$4 (Barnfield et al., 6 May 2026). This does not introduce a new operational mechanism, but it clarifies that the effectiveness of any value-write association in linear memory depends on how the read criterion is defined.

7. Comparative themes, trade-offs, and broader implications

The surveyed systems differ sharply in substrate, yet several technical themes recur. First is the tension between hard constraints and soft valuation. VALUE masks invalid trie continuations and softly reweights the remainder by normalized value scores; associative processors hard-select tagged rows and then optimize write ordering; storage engines enforce pointer publication invariants and then optimize relocation cadence or index layout (Zuo et al., 25 Feb 2025, Hout et al., 2021, Chursin et al., 2 Feb 2026, Li et al., 5 Jun 2025).

Second is the distinction between instance-level guidance and global retraining. VALUE argues that frequent eCPM fluctuations make retraining-centric RLHF brittle and costly, motivating decoding-time alignment instead (Zuo et al., 25 Feb 2025). Memory Worth similarly avoids global relearning by maintaining two counters per memory unit (Simsek, 13 Apr 2026). PNW retrains in the background only when a load-factor threshold is crossed, leaving existing NVM data unmoved (Kargar et al., 2020). A plausible implication is that value-write association is particularly attractive when the evaluative signal changes faster than model retraining can be justified.

Third is the role of interference management. In fast-weight memories, interference means destructive overlap among stored associations; in linear associative memory theory, it appears as competitor-score noise and extreme-value penalties; in sponsored search, it appears as the risk that value optimization will degrade semantic relevance; in multi-valued associative processors, it appears as write-after-write corruption if pass ordering is incorrect (Hatamizadeh et al., 21 May 2026, Barnfield et al., 6 May 2026, Zuo et al., 25 Feb 2025, Hout et al., 2021). The specific techniques differ—channel-wise gating, listwise criteria, depth-aware schedules, cycle-free DAG traversal—but the governing problem is shared: a valued write must not destabilize the correctness of neighboring writes.

Fourth is the question of causality versus association. Memory Worth is explicit that it estimates co-occurrence rather than causal contribution (Simsek, 13 Apr 2026). VALUE similarly leverages eCPM and RPM as statistical signals rather than intrinsic semantic properties (Zuo et al., 25 Feb 2025). In storage systems, by contrast, the association is not probabilistic but exact: the index must point to the latest committed value or tombstone (Chursin et al., 2 Feb 2026). This suggests that “value-write association” is not a single formal object but a design pattern whose semantics range from deterministic pointer publication to stochastic success estimation.

Finally, the surveyed work indicates that write operations increasingly serve as loci for online control rather than mere persistence or sequence generation. In sponsored search, the write is a token decision modulated by revenue proxies; in agent memory, it is a retrievable unit whose worth changes over time; in linear attention, it is a rank-one edit whose gates determine which associations survive; in persistent storage, it is the publication of a durable pointer that governs the observable system state (Zuo et al., 25 Feb 2025, Simsek, 13 Apr 2026, Hatamizadeh et al., 21 May 2026, Chursin et al., 2 Feb 2026). This suggests a broader research direction in which write paths become the primary site for aligning system behavior with external objectives, provided the association mechanism remains stable under drift, interference, and recovery constraints.