CSBASG in AlloyASG

• CSBASG is a structurally balanced, complex-weighted multigraph that compactly encodes Alloy predicate code with merged syntactic elements.
• It employs unique angular signatures and magnitude functions to reduce redundancy, achieving an average node-compression ratio of about 27%.
• The method supports efficient predicate comparison, automated code repair, and seamless integration with graph-based machine learning techniques.

The Complex Structurally Balanced Abstract Semantic Graph (CSBASG) is a representation schema for Alloy predicate code, designed to achieve a more compact and structurally faithful encoding compared to traditional Abstract Syntax Trees (ASTs). CSBASG represents code as a complex-weighted, directed multigraph in which each unique syntactic-semantic element of the code is mapped to a single graph node, and AST links are transformed into complex-weighted edges governed by a formal notion of structural balance. This framework supports efficient predicate comparison, code repair, and graph-based machine learning integration and establishes a foundation for future program analysis and synthesis methodologies in Alloy and similar languages (Wu et al., 29 Feb 2024).

1. Formal Specification of CSBASG

CSBASG is formally constructed from the AST of an Alloy predicate. Let $T = (G, X, r, \xi, \sigma)$ denote the AST, where $G=(N, \Sigma, R, s)$ is the grammar, $X$ the AST nodes, $r$ the root, $\xi$ the child relation, and $\sigma$ the node labeling function.

The construction of a CSBASG involves the following key components:

• Vertices ($V$): The set of distinct AST labels in $N \cup \Sigma$—for example, “BinaryExpr.JOIN”, “Quantifier.ALL”, or “RelDecl”—with each label mapped to a unique node.
• Edges ($E$): Each edge is a tuple $(v_i, v_j, a_{ij})$, where $a_{ij}$ is a complex number encoding both the multiplicity and the structural ordering of AST links from parent $v_i$ to child $v_j$.
• Signature Assignment ($\varphi$): An injective mapping $\varphi: V \to (-\pi, \pi)$ assigns each node a unique “angular signature” $\theta_v$.
• Adjacency Matrix ($A$): A $|V| \times |V|$ matrix with entry $a_{ij} = |a_{ij}| e^{i(\theta_i - \theta_j)}$. Each entry sums all AST links (distinguished by child position and visitation count) from $v_i$ to $v_j$, encoded with the appropriate phase.
• Structural Balance: The matrix $A$ is structurally balanced in the sense that if $$D_\zeta = \operatorname{diag}(e^{i\theta_1}, \ldots, e^{i\theta_n})$$, then $\bar{A} = D_\zeta^{-1} A D_\zeta$ has nonnegative real entries $|a_{ij}|$.

In graph-theoretic terms, CSBASG is a complex-weighted, structurally balanced multigraph that captures the full code structure while merging repeated semantic elements (Wu et al., 29 Feb 2024).

2. Algorithmic Construction and Encoding

The construction of CSBASG from an Alloy AST employs two injective helper functions:

• $\varphi: N \cup \Sigma \rightarrow (-\pi, \pi)$ for assigning angular signatures.
• $$\mathcal{M}: \mathbb{N} \times \mathbb{N} \rightarrow \mathbb{R}_{>0}$$ for assigning unique positive magnitudes based on child position ($\omega$) and visitation count ($t$).

Key steps in the algorithm:

1. Enumerate distinct AST labels, indexing each and assigning its signature.
2. Initialize $A$ as a zero matrix and the visitation counter $t$ as zero.
3. Traverse the AST in pre-order. For the current node $x$, increment $t_i$ for its corresponding index $i$.
4. For each child $y$ (the $\omega$-th child), compute:
   • $j$: index for $\sigma(y)$
   • $m = \mathcal{M}(\omega, t_i)$
   • $\text{phase} = e^{i(\theta_i - \theta_j)}$
   • Update $A_{j,i} \leftarrow A_{j,i} + m \cdot \text{phase}$
5. Recurse on each child.

A recommended choice for $\mathcal{M}$ is $\mathcal{M}(\omega, t) = 2^{(t-1)p + \omega}$, with $p$ bounded by the AST’s maximum branching factor. This encoding is injective and recovers the AST uniquely, ensuring completeness and asymptotic optimality for repeated structures. The combination of child position and visitation count in $\mathcal{M}$, along with structurally balanced complex phases, permits faithful and compact reconstruction of the code structure (Wu et al., 29 Feb 2024).

3. Compactness and Information Reduction

CSBASG achieves succinctness by merging nodes corresponding to identical syntactic-semantic labels. Denote $|X|$ as the number of AST nodes and $|V|$ as the number of ASG nodes; always $|V| \leq |X|$, with the node-compression ratio defined as $\alpha = 1 - (|V|/|X|)$.

Empirical results from the Alloy4Fun benchmark (6,307 student/oracle predicate pairs) report:

• Mean node-compression ratio: $\alpha \approx 27.3\%$ (fewer nodes compared to the AST)
• Maximum observed reduction: $38\%$ for specific problems

While the adjacency matrix $A$ stores complex values and does not necessarily reduce raw storage space, information redundancy is substantially reduced because repetitive subexpressions collapse into single graph nodes. This enables sparser representations and potentially lower memory overhead in downstream tasks. This suggests more efficient manipulation and analysis for large or repetitive models (Wu et al., 29 Feb 2024).

Metric	AST Representation	CSBASG Representation
Node count (	X	/
Node-compression ratio (α)	0	≈ 27.3 % (mean)
Edge density	Reflects AST	Sparse after merging

4. Predicate Comparison and Edit Distance

CSBASG enables direct comparison of Alloy predicates within the same context by leveraging a common node/label set $V$ and signature vector $\theta$. For predicates $P$ and $Q$, the following edge sets are computed:

• $E_{\text{common}}$: Edges present in both $A_P$ and $A_Q$
• $E_{P\text{only}}$: Edges unique to $A_P$
• $E_{Q\text{only}}$: Edges unique to $A_Q$

A similarity metric is defined as:

$$\text{sim}(P, Q) = \frac{|E_{\text{common}}|}{|E_{P\text{only}} \cup E_{\text{common}} \cup E_{Q\text{only}}|}$$

Empirical observations from student/oracle pairs indicate:

• $77.4\%$ of mutant (student) edges also appear in the oracle
• $60.7\%$ of oracle edges are shared with the mutant

This edge-based edit-graph $\Delta E = E_{P\text{only}} \cup E_{Q\text{only}}$ enables rapid calculation of syntactic distance ($O(|V|^2)$) and forms a basis for atomic AST mutations and automated repair. The metric supports both code similarity and applications in graph kernels or graph matching (Wu et al., 29 Feb 2024). A plausible implication is improved feedback and debugging workflows in program synthesis environments.

5. Structural Balance and Spectral Analysis

The structurally balanced nature of CSBASG follows that $a_{ij} = |a_{ij}| e^{i(\theta_i - \theta_j)}$ ensures compliance with the complex-structural-balance criterion of Altafini et al.: there exists $\zeta = [e^{i\theta_1}, ..., e^{i\theta_n}]^T$ such that $L \zeta = 0$ for the Laplacian $L = D - A$, with $D = \operatorname{diag}(\sum_j |a_{ij}|)$. Consequently, zero is always an eigenvalue of $L$, enabling utilization of Laplacian spectral techniques (such as spectral clustering or graph Fourier transforms) on CSBASGs.

Self-loops and multiedges in the underlying AST pose no theoretical complication, as recent extensions to Laplacian definitions incorporate appropriate handling in $D$ and $A$. This structural property suggests potential for deep analysis and robust embedding in learning algorithms sensitive to spectral features (Wu et al., 29 Feb 2024).

6. Expected Applications and Extensions

CSBASG is versatile for current and future research, supporting a variety of advanced use cases:

• Automated Repair and Hint Generation: The edit-graph $\Delta E$ maps directly to edge-add/remove operations, facilitating mutation-driven automated repair or machine learning prediction of required edits. This approach guarantees that all repairs preserve Alloy’s grammatical well-formedness.
• Code Generation and Sketching: By treating partial CSBASGs as input, algorithms may use angular proximity ($\theta$) or learned graph kernels to suggest plausible AST extensions, supporting flexible code synthesis. Optimizing $\varphi$ (the signature assignment) via gradient or dual-annealing techniques yields continuous, data-driven embeddings of Alloy code.
• Cross-Language Generalization: Any programming language defined by a context-free grammar with bounded branching may adopt the CSBASG construction, by defining node sets, using polynomial or learnable magnitude encodings, and enforcing structural balance.
• Graph-Based Machine Learning: The structurally balanced, complex-valued adjacency matrix $A$ is directly compatible with established architectures such as Graph Convolutional Networks (GCNs) and Graph Attention Networks (GATs), supporting tasks including code classification, automated repair, code generation, and structural clone detection. This naturally generalizes approaches such as code2seq or ast2vec to a declarative, logic-aware embedding suitable for learning (Wu et al., 29 Feb 2024).

In summary, CSBASG provides a rigorous, compact, and semantically meaningful alternative to AST-based code representation in Alloy, offering concrete improvements in node count, edit-based comparison, programmability for repair and generation, and compatibility with advanced machine learning paradigms.