CERTA: Explanation & Certainty Systems

• CERTA is a dual-use research term defining both a post-hoc explanation method for deep-learning entity resolution and a certainty-enhanced RAG system.
• In entity resolution, CERTA employs open triangles, saliency, and counterfactual perturbations to reveal essential attributes that flip model predictions.
• For retrieval-augmented generation, CERTA uses the RAG Triad to calculate semantic similarity scores, guiding models to express uncertainty appropriately.

CERTA is a research term used in more than one technical sense. In deep-learning entity resolution, CERTA is a post-hoc, local, black-box, model-agnostic but task-aware explanation method that produces both saliency explanations and counterfactual explanations by evaluating perturbed copies of input record pairs (Teofili et al., 2022). In retrieval-augmented generation, CERTA denotes Certainty Enhanced RAG for Trustworthy Answers, a specialized RAG system that uses the RAG Triad—Question–Context Relevance, Context–Answer Relevance, and Answer–Question Relevance—to reflect uncertainty and support appropriate trust (Scala et al., 1 May 2026). Related papers also describe several systems as “CERTA-like” or as close conceptual matches, because they separate generation from auditing or certification through counterfactual search, deterministic verification, attested execution, or formal robustness analysis (Sharma et al., 2019).

1. Terminological scope

In the cited literature, the term appears directly in two named systems and indirectly in several certification-oriented frameworks. One line of work uses CERTA for effective explanations for entity resolution models; another uses CERTA for certainty-aware retrieval-augmented generation. Additional papers explicitly frame other systems as “CERTA-like,” including CERTIFAI, PHACT, and AGAPECert, because they use a unified procedure to audit, certify, or validate model behavior without relying on model self-assertion (Teofili et al., 2022).

Name	Research setting	Defining mechanism
CERTA	Entity resolution	Open triangles, saliency, counterfactuals
CERTA	Retrieval-augmented generation	RAG Triad and certainty-aware prompting
CERTIFAI	Black-box AI auditing	Counterfactual explanations and CERScore
PHACT	LM-assisted physical design	Propose-certify loop
AGAPECert	Privacy-preserving certification	Oblivious Smart Contracts, TEE, blockchain
CTT	Adversarial sample detection	Taboo activations and IBP
STR-Cert	Scene text recognition	DeepPoly-based robustness certification

The direct CERTA usages are not interchangeable. The entity-resolution method is centered on probability of necessity and probability of sufficiency over perturbed record pairs, whereas the RAG system is centered on certainty estimation from semantic similarity in embedding space (Teofili et al., 2022). The “CERTA-like” works are connected at the architectural level rather than by acronym identity: CERTIFAI uses counterfactual explanations to audit robustness, transparency, interpretability, and fairness; PHACT moves the authority to assert correctness out of the LLM and into a deterministic physics engine; AGAPECert automates private certification by running pre-approved Oblivious Smart Contract code in a data owner’s own environment; CTT provides certifiable adversarial detection; and STR-Cert provides robustness certification for scene text recognition (Sharma et al., 2019).

2. CERTA in entity resolution

In entity resolution, CERTA addresses the explainability of deep-learning ER systems by treating the ER model as a black-box classifier and using perturbations that are aware of ER semantics rather than generic text-classification perturbations (Teofili et al., 2022). The input is a pair of records $\langle u,v\rangle$, drawn from record sets $U$ and $V$, and the ER model predicts either match or non-match. CERTA is explicitly designed to work with any ER model, including LSTM-based systems such as DeepER and DeepMatcher and transformer-based systems such as Ditto (Teofili et al., 2022).

Its perturbation model is built around open triangles. For a prediction $M(\langle u,v\rangle)=y$, CERTA searches for another record on one side that receives the opposite prediction with the fixed record on the other side. In a left open triangle $\langle u,v,w\rangle$, the record $u$ is the free record, $v$ is the pivot record, and $w$ is the support record. A perturbation function $\psi(u,w,A)$ creates a new record $u'$ by copying into $U$0 the values of a subset of attributes $U$1 from $U$2. This yields data-driven perturbations based on actual record values rather than synthetic noise (Teofili et al., 2022).

The method produces saliency explanations through the probability of necessity. For an attribute $U$3, CERTA defines

$U$4

Here, $U$5 quantifies how often flips of the original prediction involve changing attribute $U$6. CERTA estimates this probability by counting flip-inducing perturbations over the relevant lattices of attribute subsets and support records (Teofili et al., 2022).

It produces counterfactual explanations through the probability of sufficiency. For a set of attributes $U$7,

$U$8

CERTA then selects an attribute set $U$9 that maximizes sufficiency and, among such sets, has minimal cardinality. The returned counterfactuals are perturbed record pairs that actually flip the prediction while changing only the attributes in $V$0 (Teofili et al., 2022).

A central algorithmic component is a lattice-based search over subsets of attributes. Each node corresponds to a subset $V$1 and is tagged by whether the perturbation built from $V$2 flips the original prediction. CERTA uses a monotonicity assumption—if a subset of attributes flips the prediction, then any superset also flips—to avoid evaluating every subset explicitly. The paper reports that this reduces the number of model calls substantially, with approximate savings of about 50% for 3 attributes, about 57–64% for 4 attributes, and about 78% for 8 attributes, while introducing at most about 4% error in the estimated probabilities (Teofili et al., 2022).

The empirical evaluation covers 12 ER datasets from the DeepMatcher repository and 3 state-of-the-art DL ER models, using saliency baselines such as Mojito, LandMark, and SHAP, and counterfactual baselines such as DiCE, LIME-C, and SHAP-C. CERTA is reported to have higher faithfulness, strong confidence indication, and better counterfactual quality in terms of proximity, sparsity, and diversity. The implementation is available at https://github.com/tteofili/certa (Teofili et al., 2022).

3. CERTA in certainty-aware retrieval-augmented generation

In retrieval-augmented generation, CERTA is Certainty Enhanced RAG for Trustworthy Answers. Its motivation is that standard RAG may still produce fluent answers even when the retrieved context is irrelevant or incomplete, and it typically does not convey epistemic uncertainty. CERTA therefore adds a certainty-aware layer to the RAG pipeline and uses it both to guide model behavior and to communicate uncertainty to users (Scala et al., 1 May 2026).

The core formalism is the RAG Triad. For a question $V$3, retrieved context $V$4, and generated answer $V$5, CERTA defines

$V$6

$V$7

$V$8

These three semantic similarity scores are then aggregated into an overall certainty score:

$V$9

CERTA uses an embedding model rather than LLM self-judgment to obtain these signals, and the paper presents this as a way to avoid the circularity of “LLM-as-judge” (Scala et al., 1 May 2026).

The framework combines NVU (Numeric Verbal Uncertainty) and LVU (Linguistic Verbal Uncertainty). Numerically, the system displays the triad scores and the aggregate certainty. Linguistically, it prompts the model to say “I don’t know”, to hedge, or to explain why the context is insufficient. The paper defines three variants in addition to baseline RAG: CERTA-0, which adds explicit uncertainty instructions without feeding numerical scores back into the prompt; CERTA-1, which adds more informed uncertainty instructions; and CERTA-2, which adds explicit use of the triad scores in the prompt or implicit decision logic (Scala et al., 1 May 2026).

The evaluation is conducted on the Certainty Benchmark, which contains 90 question-context pairs derived from 30 questions, each paired with a relevant, incomplete, and irrelevant context. The questions are divided across four categories: factuality, personal preference, sycophancy, and morality. The study uses 4 approaches, 2 LLMs, and 90 data points, for a total of 720 runs (Scala et al., 1 May 2026).

Across all 240 runs per approach, the counts of “I don’t know” answers are reported as 149 for CERTA-1, 142 for CERTA-2, 124 for CERTA-0, and 106 for baseline RAG. The paper further reports that CERTA helps identify answers that are uncertain, decreases the cases of over-agreeing, and provides cautious behavior when prompted for moral judgments. It also states that, across all 720 runs, CERTA never changes a correct, well-supported answer into a different wrong answer; it either leaves the answer unchanged or replaces an overconfident answer with “I don’t know” where appropriate (Scala et al., 1 May 2026).

4. CERTA-like certification frameworks

Several papers describe systems as “CERTA-like” or as close conceptual matches because they use an external procedure to audit or certify model behavior rather than trusting a model’s internal confidence. CERTIFAI is presented as a model-agnostic, black-box framework built around counterfactual explanations. Given a black-box classifier $M(\langle u,v\rangle)=y$0 and an input instance $M(\langle u,v\rangle)=y$1, it searches for counterfactuals $M(\langle u,v\rangle)=y$2 that minimize a distance metric while changing the model prediction:

$M(\langle u,v\rangle)=y$3

CERTIFAI uses a custom genetic algorithm, returns the top $M(\langle u,v\rangle)=y$4 diverse counterfactuals, and defines CERScore as

$M(\langle u,v\rangle)=y$5

The paper explicitly says that CERTIFAI is very close to what someone might have in mind when thinking of a certification-style framework for AI models, because it provides a single, unified procedure for robustness, transparency, interpretability, and fairness (Sharma et al., 2019).

PHACT, or Physics-Anchored Certification, uses a different mechanism but a similar trust shift. The paper states that the LLM proposes candidate designs, while a deterministic physics engine alone certifies, refuses with impossible, or abstains with unknown. The certifier is expressed as

$M(\langle u,v\rangle)=y$6

where $M(\langle u,v\rangle)=y$7 denotes bound inputs from the goal and $M(\langle u,v\rangle)=y$8 denotes free design variables. The paper emphasizes that the quantity being certified must be derived from bound inputs and free variables, not accepted as a model-supplied scalar, and reports 0/80 false certifications across impossible-goal adversarial trials under the structural contract (Vyas et al., 29 Jun 2026).

AGAPECert provides a privacy-preserving certification architecture. It defines certification as a purely functional transformation

$M(\langle u,v\rangle)=y$9

from private data to a certification artifact, and binds outputs to data and code with hashes such as $\langle u,v,w\rangle$0 and $\langle u,v,w\rangle$1. The framework combines trusted execution environments, blockchain technologies, and a graph-based API so that a data owner can run pre-approved Oblivious Smart Contract code in their own environment on their own private data to produce Private Automated Certifications (Palacios et al., 2022).

CTT and STR-Cert bring certification into robustness analysis. Certifiable Taboo Trap augments a CNN with monitored taboo activations and uses interval bound propagation to certify adversarial detection under $\langle u,v,w\rangle$2 perturbations. STR-Cert extends the DeepPoly framework to scene text recognition and certifies that for all perturbed images in a region $\langle u,v,w\rangle$3, the decoded text remains unchanged:

$\langle u,v,w\rangle$4

These systems are not named CERTA, but they instantiate the same broader pattern: trust is grounded in explicit detection rules, formal abstractions, or deterministic certification rather than in unverified model outputs (Shumailov et al., 2020).

5. Shared technical patterns

A cross-paper synthesis suggests that CERTA and the CERTA-like systems share a recurring architectural idea: explanation or certification is delegated to a procedure external to the base predictive model. In the ER version of CERTA, the external procedure is a probabilistic perturbation framework over open triangles and lattices of attribute subsets. In the RAG version, it is an embedding-based certainty computation over the RAG Triad. In CERTIFAI, it is counterfactual search with a genetic algorithm. In PHACT, it is a deterministic engine over a fixed dependency graph of bound, free, and derived variables. In AGAPECert, it is an attested transformation of private data into a certification artifact (Teofili et al., 2022).

Another common pattern is the use of a restricted interface between an untrusted generator and a trusted evaluator. PHACT formalizes this with bound inputs, free design variables, and derived nodes that the model cannot overwrite. AGAPECert formalizes it with pre-approved Oblivious Smart Contract code, scoped access tokens, and attestation. CERTIFAI formalizes it by requiring only query access to a black-box model and defining robustness and fairness through distances to counterfactuals rather than through access to model internals (Vyas et al., 29 Jun 2026).

The papers also converge on local evidence as the basis for trust. CERTA for ER uses local perturbations of one prediction; CERTA for RAG uses local relevance among one question, one retrieved context, and one answer; CERTIFAI uses the local distance to the nearest label-flipping counterfactual; CTT uses local activation thresholds inside a CNN; STR-Cert uses local polyhedral bounds around a specific input image. This suggests a family resemblance between explanation and certification: both are framed as reasoning about what changes can or cannot alter a specific outcome (Sharma et al., 2019).

6. Limitations and open problems

The two direct CERTA systems and the related CERTA-like frameworks also expose distinct limitations. In entity resolution, CERTA relies on a monotonicity assumption, still requires many calls to the ER model, needs access to the underlying record collections $\langle u,v,w\rangle$5 and $\langle u,v,w\rangle$6 to find open triangles, and remains limited to attribute-level rather than token-level explanations (Teofili et al., 2022). In certainty-aware RAG, the benchmark includes only 30 questions and 90 question-context pairs, the experiments use static “golden” documents, the similarity-based certainty scores often remain in mid-range values, and the paper explicitly notes that there is no user study yet (Scala et al., 1 May 2026).

The broader certification-oriented systems also delimit the scope of what “certification” means. CERTIFAI provides empirical evidence of robustness and fairness, but it does not provide formal worst-case guarantees; its optimization quality depends on a genetic algorithm and on the chosen distance metric (Sharma et al., 2019). PHACT states that soundness is relative to the engine’s model of the physics, not to reality in full, and its guarantees depend on the correctness of the deterministic engine and on the immutability of bound inputs (Vyas et al., 29 Jun 2026).

AGAPECert does not solve the garbage in, garbage out problem: a data owner may still falsify private data, although the framework makes later audits and reproducibility easier. It also inherits limitations from trusted execution environments and may leak metadata at the ledger level in Trust Level 3 deployments (Palacios et al., 2022). CTT assumes that training and test data share the same distribution, provides formal guarantees only for a fixed $\langle u,v,w\rangle$7 radius, and does not fully analyze highly adaptive white-box attackers. STR-Cert is an incomplete verifier, focuses on interval-style perturbation sets such as $\langle u,v,w\rangle$8 balls, and finds larger Bi-LSTM STR models extremely challenging to certify (Shumailov et al., 2020).

Taken together, these limitations indicate that CERTA is not a single method but a cluster of research programs organized around explanation, trust calibration, and certification. In one branch, CERTA denotes an ER-specific perturbation framework grounded in necessity and sufficiency; in another, it denotes a certainty-aware RAG system grounded in the RAG Triad. In the broader certification literature, “CERTA-like” names identify systems that make trust depend on counterfactual search, deterministic certifiers, attested computation, or formal robustness proof rather than on the opaque confidence of the underlying model (Shao et al., 2023).