Semantic Triangulation: Graph Embedding & Code

• Semantic Triangulation is a methodology that leverages nontrivial transformations to isolate invariant, robust solutions in both network embedding and neural code synthesis.
• It preserves critical local motifs such as triangles and parallelograms in multi-relational graphs, leading to improved embedding accuracy and efficient representation.
• In LLM-generated code, semantic triangulation reduces hallucinations by verifying consistency across transformed task versions, thereby enhancing program reliability.

Semantic triangulation is a principled methodology for increasing reliability in both structured network representation learning and LLM-based code generation by leveraging consistency across multiple nontrivially transformed versions of a problem or task. The concept originated in the context of multi-relational graph embedding, where it describes the explicit modeling and preservation of local triangular (three-node) and higher-order motifs in embedding spaces, and more recently has been formalized as a consensus and abstention mechanism for reducing hallucinations in neural program synthesis. In both domains, semantic triangulation exploits the idea that superficial or spurious solutions are unlikely to remain consistent across several carefully constructed, semantically linked problem variations, while truly correct or robust solutions are invariant under these transformations.

1. Semantic Triangulation in Structured Graph Embedding

In multi-relational networks, traditional embedding models such as TransE enforce a rigid “translation” constraint $\mathbf{h} + \mathbf{r} \approx \mathbf{t}$ for each triple $(h, r, t)$, effectively aligning all facts of a relation along a single geometric axis. This construction is inadequate for preserving triangular connectivity structures, since three nodes $v_i, v_j, v_k$ with the same relation $r_m$

$$v_i + r_m \approx v_j,\quad v_j + r_m \approx v_k,\quad v_i + r_m \approx v_k$$

cannot be accurately embedded in Euclidean space without distortion. Moreover, such models neglect higher-order motifs such as parallelograms or four-node cycles with edge label symmetries, which are prevalent in real world knowledge graphs (Li et al., 2018).

The Multi-relational Network Embedding (MNE) model addresses these limitations by introducing a soft, probabilistic objective directly over observed two-edge local motifs—triangles and parallelograms—thus instantiating the principle of semantic triangulation. This is realized by introducing for each node $v_i$ distinct “source” and “target” embeddings ($\mathbf{u}_i$, $\mathbf{u}_i'$), relation vectors $\mathbf{u}_{r_s}$, and a bridge function

• MNE⁺: $$f(\mathbf{u}_i,\mathbf{u}_{r_s}) = \mathbf{u}_i + \mathbf{u}_{r_s}$$
• MNE*: $$f(\mathbf{u}_i,\mathbf{u}_{r_s}) = \mathbf{u}_{r_s}\mathbf{u}_{r_s}^T\mathbf{u}_i$$

Joint probabilities over pairs of neighbor-edges (distinguishing in/out directionality) are fit to empirical motif frequencies via KL-divergence, with the combined objective:

$$O = \sum_{i\in V} \lambda_i [\mathrm{KL}(\hat p_1 \| p_1) + \mathrm{KL}(\hat p_2 \| p_2) + \mathrm{KL}(\hat p_3 \| p_3)]$$

This objective preserves both triangular and parallelogram structures. The model is trained with stochastic gradient descent and negative sampling, scaling efficiently to large graphs.

MNE⁺ demonstrates substantial gains over baselines on real datasets rich in triangular motifs (e.g., triplet classification accuracy on FB15K: MNE⁺ 90.08% vs. TransH 71.72%) and converges to high accuracy with far lower embedding dimensions than previous methods. These results confirm that explicit motif-level (“semantic triangulation”) modeling is critical to faithfully representing real multi-relational structures (Li et al., 2018).

2. Semantic Triangulation in LLM-generated Code Evaluation

LLMs for code generation are prone to hallucinations—plausibly structured but incorrect outputs—due to reliance on surface-level token statistics rather than deep functional semantics. Standard methods such as sample consensus (plurality/majority voting, test- or spec-based RANSAC) often fail when correct solutions are rare, errors are correlated, or tasks are ill-posed with multiple non-equivalent solutions (Dai et al., 15 Nov 2025).

Semantic triangulation for code generation involves transforming the original programming task into several nontrivially different but correctness-preserving forms, each with an exact, checkable mapping between solutions. Consistency is then empirically verified not just among same-task samples, but across original and transformed tasks.

Formally, for problem $P = (I, S, V)$, a triangulation instance comprises:

• Problem transformation $T: (I, S, V) \rightarrow (I', S', V')$
• Solution mapping $M: S' \rightarrow S$

subject to:

• (Inv1) Correctness-preservation: $V(s) \Leftrightarrow V'(T(s))$
• (Inv2) Mapping-preservation: $V'(s') \implies V(M(s'))$

Empirically robust consistency across $k$ such transformations (with bijective or inclusion-based predicates $\phi_j$ linking solutions) exponentially suppresses the chance that a hallucinated incorrect program will “fool” all transformations. Theoretical analysis establishes that the posterior probability of correctness, conditional on joint agreement across $k$ transformations, satisfies:

$$\Pr[V(s) = \mathit{true} \mid A_k] \geq 1 - \frac{(1-\alpha)\varepsilon^k}{\alpha + (1-\alpha)\varepsilon^k}$$

where $\alpha$ is LLM accuracy and $\varepsilon$ is the maximum likelihood for an incorrect program to pass a consistency check. For $\varepsilon < 1$, probability of correctness tends to 1 as $k$ increases (Dai et al., 15 Nov 2025).

3. Algorithmic Formulation and Practical Considerations

The practical semantic triangulation algorithm for code, as described in (Dai et al., 15 Nov 2025), proceeds in four stages:

1. Sampling: Draw $n$ candidate programs for the original problem.
2. Transformation: For each selected transformation $T_j$, draw $n$ candidate programs for $P_j = T_j(P)$.
3. Consistency Checking: For each candidate, apply semantic predicates $\phi_j$ (e.g., answer inversion, set inclusion, enumeration) to check compatibility between original and transformed solutions.
4. Consensus/Abstention: Via a RANSAC-style search, select the largest set of mutually consistent (or semantically equivalent) candidate programs. If none is found, abstain from selection.

Sampling and evaluation complexity is $O(n^2 k\,T_{\rm check})$ plus $O(nk)$ LLM calls per problem. Key design principles include ensuring that transformations genuinely alter surface statistics while preserving a bijective or otherwise verifiable mapping, using partial inversions, and confining witness generation to tractable subsets.

4. Empirical Results and Comparative Performance

On benchmark suites LiveCodeBench v6 (175 exact tasks) and CodeElo-Inexact (31 inexact tasks with multiple valid solutions), semantic triangulation yielded marked improvements:

• Reliable accuracy (GPT-4o):
  • LCB: 0.53 (Semantic Triangulation) vs. 0.32 (Majority$\geq$0.5), an increase of 21 percentage points.
  • CEI: 0.69 (Semantic Triangulation) vs. 0.12 (Majority$\geq$0.5), an increase of 76 percentage points.
• Ability to select correct solutions with sampling probability as low as 0.14 where alternative methods abstained or chose errors.
• On conditional correctness given agreement with a transformation, triangulation reached ~0.60, compared to ~0.45 for postcondition or CodeT baselines.

Ablation revealed that omitting set-valued inversion (FWD-SINV) reduced reliable accuracy by 12%, while breaking the bijective invariants in $\phi_j$ dropped reliability by 16%. Superficial, syntactically motivated transformations offered no significant improvement (Dai et al., 15 Nov 2025).

5. Theoretical and Practical Implications

Semantic triangulation provides a robust, black-box mechanism to combat hallucination and error correlation in settings where correct solutions may be arbitrarily sparse and where equifinality (multiple valid solutions) precludes naive voting-based consensus. In graph learning, explicit motif-level modeling ensures that higher-order relational patterns—especially triangles and parallelograms—are reliably embedded for downstream knowledge graph tasks (Li et al., 2018). For code generation, triangulation acts as an abstention mechanism with statistically grounded confidence guarantees.

A plausible implication is that requiring joint consistency over an increasing number of sufficiently independent, correctness-preserving transformations can, under mild conditions, drive the probability of error arbitrarily low, even when LLM sampling accuracy is modest. This suggests a potential avenue for developing verification-centric workflows for neural code synthesis beyond standard test-based validation.

6. Limitations, Failure Modes, and Prospective Extensions

Current implementations of semantic triangulation in code synthesis incur a multiple of the standard number of LLM calls (linear in the number of triangulation steps $k$); cost can be amortized via batching and caching. The methodology is challenged by tasks demanding genuinely infinite enumeration, optimization over non-bijective mappings, or very large input domains where semantic equivalence is expensive to verify. Addressing these cases may require tighter integration with domain-specific logic, self-refinement (“cycle”) methods, and richer forms of transformation, particularly for interactive or stateful tasks.

In multi-relational network embedding, the distinction between addition-based and symmetric-product bridge functions is significant: MNE⁺ is superior when directed edges are prevalent, whereas MNE* may collapse relevant distinctions. The approach is further validated by strong performance on datasets with dense triangular and parallelogram motifs, confirming the centrality of explicit motif-level objective terms (Li et al., 2018).

Ongoing directions include exploring transformation design for maximal error decorrelation, automating transformation selection, integrating with iterative refinement procedures, and generalizing the framework to structured prediction tasks beyond code and graphs (Dai et al., 15 Nov 2025).