2000 character limit reached
3-Query RLDCs are Strictly Stronger than 3-Query LDCs (2512.12960v1)
Published 15 Dec 2025 in cs.CC
Abstract: We construct $3$-query relaxed locally decodable codes (RLDCs) with constant alphabet size and length $\tilde{O}(k2)$ for $k$-bit messages. Combined with the lower bound of $\tildeΩ(k3)$ of [Alrabiah, Guruswami, Kothari, Manohar, STOC 2023] on the length of locally decodable codes (LDCs) with the same parameters, we obtain a separation between RLDCs and LDCs, resolving an open problem of [Ben-Sasson, Goldreich, Harsha, Sudan and Vadhan, SICOMP 2006]. Our RLDC construction relies on two components. First, we give a new construction of probabilistically checkable proofs of proximity (PCPPs) with $3$ queries, quasi-linear size, constant alphabet size, perfect completeness, and small soundness error. This improves upon all previous PCPP constructions, which either had a much higher query complexity or soundness close to $1$. Second, we give a query-preserving transformation from PCPPs to RLDCs. At the heart of our PCPP construction is a $2$-query decodable PCP (dPCP) with matching parameters, and our construction builds on the HDX-based PCP of [Bafna, Minzer, Vyas, Yun, STOC 2025] and on the efficient composition framework of [Moshkovitz, Raz, JACM 2010] and [Dinur, Harsha, SICOMP 2013]. More specifically, we first show how to use the HDX-based construction to get a dPCP with matching parameters but a large alphabet size, and then prove an appropriate composition theorem (and related transformations) to reduce the alphabet size in dPCPs.
Sponsor
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
Overview
This paper studies special error-correcting codes and proof systems that let you check or recover information by looking at only a few places. Its main result shows that relaxed locally decodable codes (RLDCs) with 3 queries can be much shorter than standard locally decodable codes (LDCs) with 3 queries. This settles a long-standing open problem: RLDCs are strictly stronger than LDCs when you are allowed only 3 lookups.
Along the way, the authors build new, very efficient proof systems (PCPPs and dPCPs) that help construct these better codes.
What questions does the paper ask?
- Can we build 3-query RLDCs that are much shorter than any 3-query LDC?
- Can we design a 3-query PCPP (a kind of quickly-checkable proof) that is both short and hard to fool?
- Can we turn such PCPPs into RLDCs without increasing the number of queries?
How did they approach the problem?
To make this accessible, think of codes and proofs like the following:
- A code is like writing a message with built-in backups, so you can fix or find parts of it even if some pages are smudged.
- An LDC lets you recover one bit of the original message by reading only a few symbols of the codeword (say 3). An RLDC is a relaxed version: it can say “I’m not sure” (output ⊥) when the data looks too corrupted, but should never output the wrong bit when things are only mildly corrupted.
- A PCP is a proof you can check by reading just a few random locations; a PCPP checks not only correctness but also whether the input is close to a correct one.
- A dPCP (decodable PCP) is a PCP that, when it checks a constraint, also helps you locally decode a piece of the original input—so checking and decoding happen together.
Here is the strategy, simplified:
- Build a powerful 2-query dPCP: The authors create a proof system where checking any single constraint requires reading only 2 places, and it’s very hard for wrong proofs to pass. Even better, the total size (number of constraints and variables) is close to linear in the original problem size.
- Turn that dPCP into a 3-query PCPP: They use the dPCP to construct a PCPP where checking “is this input close to valid?” takes just 3 queries, stays short, and has a small chance of being fooled (small soundness).
- Convert PCPPs to RLDCs without adding queries: They introduce a new “query-preserving” transformation that takes these 3-query PCPPs and packages them into 3-query RLDCs. Previous methods added more queries; this one keeps the number at 3.
To make these constructions work, they use:
- Composition: Think of layering a big, efficient proof on top of smaller ones to reduce the alphabet (the number of possible symbols per position) while keeping checks accurate.
- High-dimensional expanders (HDXs): These are specially connected structures (like a super well-linked maze) that spread information and make random checks powerful and reliable.
- Decoding-degree reduction: A technical trick to keep the number of things each part must decode small, which keeps the alphabet small and the system efficient.
What did they find, and why does it matter?
Here are the main results, in simple terms:
- A 2-query dPCP that is short and reliable: They built a decodable proof system that reads just 2 positions per check, has very small chance to accept a bad proof, and its total size is near-linear in the input size.
- A 3-query PCPP with small soundness: They showed a PCPP that only reads 3 positions, is short, uses a small alphabet, and is hard to fool—even when inputs are only somewhat close to correct.
- A 3-query RLDC with nearly quadratic length: They constructed a 3-query RLDC over a constant-size alphabet whose codeword length is about k² times a small polylogarithmic factor (here k is the number of message bits). The code has:
- Constant decoding radius: it can handle a constant fraction of errors.
- Constant distance: two different codewords differ in a constant fraction of positions, so errors don’t make different messages look the same.
- Constant alphabet: symbols are from a small fixed set.
- A strict separation: A recent lower bound proved that any 3-query LDC with similar features must have length roughly k³ (up to log factors). Since their 3-query RLDC has length about k², it’s significantly shorter. This proves that, with 3 queries, RLDCs are strictly stronger than LDCs.
- Extra consequences: Their PCPPs also improve known hardness results for “reconfiguration” problems (questions about how hard it is to transform one solution into another through small steps). They show stronger PSPACE-hardness gaps using fewer queries or smaller alphabets than before.
Why it matters:
- It resolves a major open question from 2006: whether RLDCs are truly stronger than LDCs in the low-query regime.
- It provides new building blocks (dPCPs and PCPPs) that are both short and high-quality, which can be used in many areas of theoretical computer science.
Methods explained with everyday analogies
- Queries: The number of places you peek to make a decision. Fewer queries mean faster local checks.
- Alphabet size: How many different symbols each position can hold. Constant alphabet means a small, fixed set (like using digits 0–9 instead of huge dictionaries).
- Soundness: If a proof or code is wrong, soundness measures how often a quick checker will still be tricked. Small soundness means it’s rare to be fooled.
- Completeness: If everything is correct, the checker always accepts.
- Distance: The fraction of positions two different codewords differ on. Larger distance means errors are easier to notice.
- Decoding radius: The fraction of positions that can be wrong while still allowing local recovery with high confidence.
- Composition: Like compressing a big proof into smaller parts and re-encoding them with better, smaller alphabets, while keeping the ability to check locally.
- High-dimensional expander (HDX): Imagine a giant puzzle where every small piece connects to lots of other pieces in a balanced way; random checks reveal global structure reliably, because the network of connections is exceptionally well spread out.
Implications and impact
- Better small-query codes: We now know relaxed decoders can achieve much shorter lengths than non-relaxed ones for 3 queries. This may inform practical designs where occasional “I don’t know” answers are acceptable to avoid wrong answers.
- Stronger proof tools: The improved dPCPs and PCPPs can feed into many applications, including hardness of approximation, property testing, and cryptographic protocols that rely on short, checkable proofs.
- New directions:
- Can we make 2-query PCPPs with similarly strong guarantees?
- Can we push 3-query RLDCs below quadratic length?
- Can we combine these RLDCs with local testability in one unified code?
In short, the paper shows that allowing a decoder to sometimes refuse to answer (instead of guessing wrongly) leads to dramatically better performance when you want to read very few places. It answers a big open question, introduces powerful new proof systems, and opens the door to more efficient local algorithms across theory and practice.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
The paper advances dPCPs, PCPPs, and RLDCs but leaves several concrete directions unresolved. Future work could target the following:
- Existence of quasi-linear, small-soundness 2-query PCPPs with constant (non-Boolean) alphabet: either construct such PCPPs or prove lower bounds ruling them out.
- Reducing the query complexity of the tight proximity–soundness trade-off PCPP (currently 4 queries) to 3 or even 2 queries without sacrificing the tight relationship.
- Developing a black-box transformation from standard PCPs to PCPPs that preserves queries and works without specialized structural assumptions (the paper notes that none is known).
- Generalizing the composition theorem for decodable PCPs beyond constant decoding-degree: avoid exponential-in-decoding-degree alphabet blowup while maintaining small soundness and quasi-linear size.
- Eliminating or weakening the “agnostic decoding distributions” requirement in the decoding-degree reduction while preserving soundness; characterize when agnosticism can be enforced or replaced.
- Tightening the list size L in the dPCP list-decoding soundness (currently polynomial in 1/ε): achieve constant L for small ε or prove information-theoretic barriers for L vs. ε.
- Achieving 3-query RLDCs with sub-quadratic length (o(k2 polylog k)) or proving matching lower bounds that preclude sub-quadratic length under constant alphabet, distance, and decoding radius.
- Extending the RLDC vs. LDC separation to even query counts (e.g., q = 2, 4, 6); the companion result covers odd q ≥ 3, leaving even q open.
- Obtaining 3-query RLDCs over a binary alphabet or linear 3-query RLDCs with quadratic (or sub-quadratic) length without collapsing to non-relaxed LDCs (or, alternatively, proving impossibility results that necessitate non-binary or non-linear constructions).
- Improving the RLDC decoder’s success guarantees: reduce the (1 − 16δ − o(1)) fraction loss and raise the per-position success probability > 2/3 without increasing queries (e.g., via smarter error-detection/amplification rather than repetition).
- Providing explicit, efficiently encodable base codes C0 with the required near-1 relative distance and practical encoding/decoding time; analyzing the overall rate and computational complexity of the RLDC, and exploring alternatives to heavy repetition that preserve distance.
- Minimizing the constant alphabet size in all constructions (dPCP, PCPP, RLDC), ideally down to binary, while retaining small soundness and quasi-linear size; quantify the trade-offs and identify barriers.
- Establishing lower bounds for small-soundness, low-query PCPPs (especially 2-query), matching or constraining achievable parameters (alphabet size, proximity parameter, length).
- Certifying or designing local testability for the constructed RLDCs: prove local testability (as conjectured) or modify the PCP components to guarantee uniqueness properties sufficient for local testability.
- Strengthening PSPACE-hardness gaps for CSP reconfiguration via improved PCPPs (e.g., fewer queries, lower rejection thresholds), and pushing completeness/soundness thresholds closer to optimal regimes.
- Fully specifying the “additional technical features” required of PCPP decoders in the query-preserving PCPP-to-RLDC transformation and generalizing the transformation to PCPPs that lack those features.
- Reducing the polylogarithmic exponents in the size bounds (N logC N for dPCP/PCPP and k2 logC k for RLDC): identify which steps (HDX routing, sparse direct-product testing, composition) dominate the blow-up and optimize or replace them.
- Exploring alternative outer PCP/dPCP frameworks to HDX-based constructions that still yield quasi-linear, small-soundness 2-query dPCPs, potentially with simpler expansion or combinatorial structures.
- Investigating randomness efficiency: derandomize or use limited independence in decoders and composition steps to reduce randomness complexity while keeping 3 queries and small soundness.
Glossary
- Agnostic decoding distributions: A property of a dPCP’s decoding distributions where conditioning on the decoded index does not reveal extra information about which left vertex is tested. "We say a dPCP has agnostic decoding distributions if for all and , the marginal distribution of on is identical to ."
- Alphabet: The set of symbols from which assignments are drawn in PCP/CSP instances; its size is a critical parameter. "as well as an alphabet and a collection of constraints "
- Blow-up: The increase in size (length) of an instance under a reduction, often measured in PCP constructions. "These parameters include the blow-up of the reduction (sometimes called the length/size of the PCP)"
- Complete decoding distribution: A distribution over decoded indices and edges in a dPCP that captures the joint randomness of decoding. "The complete decoding distribution of is the distribution over "
- Composition theorem: A method to combine an outer PCP with an inner PCP to improve parameters such as alphabet size while controlling soundness and query complexity. "and then prove an appropriate composition theorem (and related transformations) to reduce the alphabet size in dPCPs."
- Constraint Satisfaction Problem (CSP): A formal framework of variables, constraints, and an alphabet, used to model PCP instances. "An instance of a constraint satisfaction problem (CSP) consists of a weighted uniform hypergraph \Sigma$ and a collection of constraints"</li> <li><strong>Decodable PCP (dPCP)</strong>: A PCP variant that allows local decoding of the target word while checking constraints, enabling list-decoding soundness. "A $q{L} \subseteq \Sigma_0^n$ consists of a CSP instance"</li> <li><strong>Decoding degree</strong>: For label-cover dPCPs, the number of decoded indices associated with a particular left vertex. "The decoding-degree of a vertex $a\in A{\sf ddeg}(a)$, is the number of indices it is in charge of decoding"</li> <li><strong>Decoding radius</strong>: The maximum fraction of corruption in a received word from which the decoder can still correctly recover (or safely reject) bits. "A code $C: \{0,1\}^k \to \Sigma_0^nq\delta$"</li> <li><strong>Direct product testing</strong>: A technique to amplify soundness by testing consistency across product structures, used in PCP/dPCP analyses. "Amplification via direct product testing"</li> <li><strong>Gap amplification</strong>: A method (due to Dinur) to increase the hardness gap in PCP reductions, often at controlled cost to other parameters. "Dinur's gap amplification technique~\cite{Dinur}"</li> <li><strong>High-dimensional expanders (HDX)</strong>: Combinatorial structures with strong expansion properties across dimensions, used as scaffolding for PCP/dPCP constructions. "the recent PCP construction of~\cite{bmv}, which is based on high-dimensional expanders."</li> <li><strong>Label-Cover</strong>: A bipartite CSP with label assignments on each side and constraints on edges, central to PCP composition frameworks. "An instance $\PsiG=(A\cup B, E, {P})"
- List-decoding soundness: A soundness guarantee where decoding is consistent with a small list of candidate codewords rather than a single one. "List-decoding soundness: for any we may find a list of words of size at most "
- Locally decodable code (LDC): A code permitting recovery of any specific message bit by querying only a few positions of a (possibly corrupted) codeword. "locally decodable codes (LDCs)"
- Manifold-versus-point test: A low-degree testing paradigm (from Reed–Muller codes) underlying many dPCP constructions. "Most known dPCP constructions are based on some variant of the manifold-versus-point test (arising from Reed-Muller codes and low-degree testing)."
- Parallel repetition theorem: A theorem (by Raz) that reduces soundness error by repeating two-query PCPs in parallel. "The parallel repetition theorem of Raz~\cite{Raz}"
- Probabilistically checkable proof (PCP): A proof system where correctness can be verified by reading only few random positions of a purported proof. "Probabilistically checkable proofs (PCPs, for short) are a central object of study in theoretical computer science"
- Probabilistically checkable proof of proximity (PCPP): A PCP variant that verifies whether an input is close to the language, using oracle access to the input. "A -query probabilistically checkable proof of proximity (PCPP) with proximity parameter and soundness $1-$"
- Projection Label-Cover: A Label-Cover instance where each edge constraint is a projection from left labels to right labels. "We say is a projection Label-Cover instance if for each edge , the constraint is projection from to ."
- Query-preserving transformation: A reduction that converts one object (e.g., a PCPP) into another (e.g., an RLDC) without increasing the number of queries. "we give a query-preserving transformation from PCPPs to RLDCs."
- Relaxed locally decodable code (RLDC): An LDC variant where the decoder may output a rejection symbol when corruption is detected, enabling better parameters. "We construct $3$-query relaxed locally decodable codes (RLDCs)"
- Robust PCP: A notion equivalent to projection Label-Cover, where constraints tolerate certain robustness properties. "The notion of projection Label-Cover is essentially equivalent to the notion of robust PCPs, which is sometimes used in the literature."
- Soundness error: The probability that a verifier accepts a false proof (or far input), a key parameter in PCP/dPCP/PCPP. "perfect completeness, and small soundness error."
- Success-rate: In RLDCs, the fraction of message positions for which the decoder succeeds with high probability when the received word is close to a valid codeword. "Success-rate: if is -close to "
- Uniform hypergraph: A hypergraph where every edge has the same cardinality, used to describe query complexity in PCP/CSP instances. "a weighted uniform hypergraph $G = (V, E, {P})"
Practical Applications
Overview
This paper delivers three core innovations with broad downstream impact:
- A 2-query decodable PCP (dPCP) with quasi-linear size, constant alphabet, and small soundness.
- A 3-query PCPP with quasi-linear size, constant alphabet, perfect completeness, and small soundness (and a 4-query variant with near-tight distance–soundness tradeoff).
- A query-preserving black-box transformation from PCPPs to RLDCs that yields 3-query RLDCs of length ~ k² polylog(k), constant alphabet, constant distance/decoding radius—giving a polynomial separation between 3-query RLDCs and 3-query LDCs.
Below are actionable real-world applications drawn from these advances. Each item lists sectors, potential tools/workflows, and key assumptions/dependencies affecting feasibility.
Immediate Applications
- Lightweight, local integrity checks for large datasets and data lakes
- Sectors: software/cloud infra, data platforms, compliance
- Tools/workflows: encode tables or object stores with a 3-query RLDC layer; auditors or background jobs spot-check individual fields/records by 3 random reads, returning the bit or “⊥” (reject) to avoid silent corruption; integrate into data quality SLAs and anomaly detection dashboards
- Assumptions/dependencies: quadratic-length overhead is acceptable for targeted/critical datasets; corruption is adversarial but not overwhelming (within decoding radius δ); practical encoders for the chosen constant alphabet; operational tolerance for “reject” outcomes in pipelines
- Fast, conservative read paths in storage systems and embedded devices
- Sectors: storage systems, embedded/edge, aerospace/automotive
- Tools/workflows: wrap critical configuration/metadata in 3-query RLDCs; on read, perform 3 probes and either return the correct bit or fail closed (⊥), reducing risk of propagating wrong state; pair with background scrub/repair using full codes
- Assumptions/dependencies: quadratic redundancy is viable for small, mission-critical regions; system design embraces “fail-safe” rejects; decoder must be constant-time (3 probes) and cache-friendly for hot paths
- Code membership, proximity, and constraint-checking data structures
- Sectors: databases, compilers/build systems, CI/CD
- Tools/workflows: use 3-query PCPPs to check proximity to satisfying assignments of configuration constraints or schema conformance, enabling “is-near-valid” checks with small soundness; integrate into pre-commit hooks, build validation, or database triggers
- Assumptions/dependencies: circuit representations of constraints available; quasi-linear proof sizes manageable; small soundness sufficient to gate releases; formal treatment of distance parameter η to calibrate reject thresholds
- Verifiable computation and succinct proof engineering (component-level)
- Sectors: blockchain/Web3, privacy-preserving systems, cloud verifiability
- Tools/workflows: plug 2-query dPCPs and 3/4-query PCPPs into modern IOP/PCP pipelines to reduce verifier queries and improve soundness at quasi-linear size; prototype modules for STARK-like systems and validity/fraud proofs; evaluate as a drop-in for circuit-local checks
- Assumptions/dependencies: translator layers from this paper’s dPCP/PCPP to specific IOP/SNARK/STARK frameworks; constants hidden in Õ(·) are practical; compatibility with batching/aggregation; careful engineering of HDX-based components
- Stronger complexity-theoretic baselines for reconfiguration hardness
- Sectors: academia (TCS/algorithms/complexity), formal methods
- Tools/workflows: adopt improved PSPACE-hard gaps for q-CSP reconfiguration (via the paper’s 4-query PCPP with tight η–ε control) to sharpen hardness-of-approximation baselines and guide algorithm design/impossibility results
- Assumptions/dependencies: research-facing; requires familiarity with CSP reconfiguration frameworks and gap-preserving reductions
- Teaching and benchmarking suites for local decoding and proximity proofs
- Sectors: education, research labs
- Tools/workflows: course modules and reference implementations comparing LDC vs RLDC behavior, PCPP soundness vs proximity, and new HDX-based dPCPs; sandbox datasets showing 3-probe read-with-reject behavior under controlled corruption
- Assumptions/dependencies: clean-room implementations of HDX-based constructions and composition frameworks; didactic simplifications may use smaller parameter regimes
Long-Term Applications
- Rollups, light-client verification, and data-availability sampling with reject-aware local checks
- Sectors: blockchain/Web3/finance, distributed ledgers
- Tools/workflows: use 3-query RLDCs to design reject-tolerant spot checks of ledger/state fragments; light clients or DA samplers perform 3 reads for inclusion/consistency and abort on “⊥,” improving safety while keeping bandwidth/touch budget minimal; couple with standard erasure coding for full availability
- Assumptions/dependencies: end-to-end protocols must treat ⊥ as non-acceptance; reconcile RLDC redundancy with DA throughput and block sizes; require provable corruption bounds matching δ; practical encoding/decoding stacks for constant alphabet; careful economic modeling of reject-induced retries
- Robust zero-knowledge and verifiable ML pipelines
- Sectors: privacy tech, AI/ML ops, regulated analytics
- Tools/workflows: embed 3/4-query PCPP components into ZK proof systems (e.g., for feature-constrained data access, fair-use attestations) and verifiable ML pipelines checking proximity to spec-compliant states; enable auditors to run few-query proximity checks with small soundness
- Assumptions/dependencies: integration with ZK-friendly arithmetization; handling large constants; aligning η (proximity) with acceptable deviation in ML artifacts; hardware acceleration for encoders/PCPP verifiers
- RLDC-coded content integrity for CDNs and archival storage
- Sectors: content delivery, digital archives, scientific repositories
- Tools/workflows: encode blobs or chunks with RLDCs to let cache nodes verify bits locally with 3 probes and reject instead of serving stale/corrupt content; archivers perform periodic micro-audits with low I/O overhead
- Assumptions/dependencies: storage overhead vs performance tradeoffs; content chunking and layout tailored to locality constraints; operational policies for reject handling (fallback, re-fetch, or quarantine)
- Tamper-evident EHR and compliance-grade data retention
- Sectors: healthcare, public sector, legal compliance
- Tools/workflows: wrap high-value records with RLDC layers; clients or auditors verify specific fields via 3 reads and treat rejects as escalation triggers; combine with immutable logs and threshold repair
- Assumptions/dependencies: regulatory acceptance of probabilistic auditing with “reject” outcomes; overhead justified for critical fields (not entire corpus); secure key management and access control around encoders
- Fault-tolerant memory and firmware (research-to-hardware)
- Sectors: hardware security, safety-critical systems, robotics
- Tools/workflows: explore memory layouts enabling 3-probe bit retrieval with reject; firmware stores critical invariants under RLDC; on read, system either uses provably correct bit or invokes redundancy/recovery
- Assumptions/dependencies: quadratic overhead unsuitable for bulk memory, but viable for small safety-critical regions; physical constraints (latency, bus accesses); formal verification of control logic under reject semantics
- Standardization of reject-aware audit protocols
- Sectors: policy/standards, auditing, certification
- Tools/workflows: codify “few-query with reject” audit primitives for data integrity and compliance (analogous to sampling-based audits) informed by PCPP/RLDC guarantees; define minimum η and ε to bound false accept rates
- Assumptions/dependencies: stakeholder education on probabilistic soundness; calibration of parameters to risk models; interoperability guidance for encodings and verifiers
- Research-driven improvements toward sub-quadratic 3-query RLDCs or tighter 2-query PCPPs
- Sectors: academia, advanced R&D groups
- Tools/workflows: pursue new decoding-degree reductions, composition theorems, and HDX primitives; if sub-quadratic 3-query RLDCs emerge, broaden viability for mainstream storage and streaming settings; if 2-query small-soundness PCPPs are found, further reduce verification touch
- Assumptions/dependencies: contingent on theoretical breakthroughs; may change practical constants materially; requires open-source, optimized implementations to translate gains into systems
Notes on Assumptions and Dependencies (cross-cutting)
- Constants and overheads: while query counts are minimal (2–4), proof/code lengths are quasi-linear (PCPP) or ~k² polylog(k) (RLDC). Practicality depends on message sizes, memory locality, and whether redundancy budgets can absorb quadratic blow-up for targeted assets.
- Alphabet size and encoders: constant alphabets aid implementation, but efficient, parallel encoders/decoders over the chosen alphabet are required; HDX-based components and composition frameworks must be implemented and optimized.
- Error model and rejection semantics: applications must explicitly treat “⊥” as a safe default (no silent acceptance). Operational policies (retry, repair, escalate) must be defined and priced.
- Integration into existing stacks: for ZK/IOP/STARK pipelines, adapters from these dPCPs/PCPPs to established arithmetizations and polynomial commitment schemes are needed. For storage, layout policies must minimize probe latency.
- Regulatory and stakeholder acceptance: for compliance-heavy domains, probabilistic guarantees and reject behaviors need standardization and formal justification.
These applications leverage the paper’s key technical advances—query-minimal dPCPs/PCPPs with small soundness and a query-preserving PCPP→RLDC transformation—enabling conservative, low-touch verification and local recovery paradigms across systems that value correctness over liveness when corruption is suspected.
Collections
Sign up for free to add this paper to one or more collections.