2512.00307

# Adversarial Signed Graph Learning with Differential Privacy **Authors**: Haobin Ke, Sen Zhang, Qingqing Ye, Xun Ran, Haibo Hu > The Hong Kong Polytechnic UniversityHung HomHong Konghaobin.ke@connect.polyu.hk > The Hong Kong Polytechnic UniversityHung HomHong Kongsenzhang@polyu.edu.hk > The Hong Kong Polytechnic UniversityHung HomHong Kongqqing.ye@polyu.edu.hk > The Hong Kong Polytechnic UniversityHung HomHong Kongqi-xun.ran@connect.polyu.hk > The Hong Kong Polytechnic UniversityResearch Centre for Privacy and Security Technologies in Future Smart Systems, PolyUHung HomHong Konghaibo.hu@polyu.edu.hk \setcctype by (2026) Abstract. Signed graphs with positive and negative edges can model complex relationships in social networks. Leveraging on balance theory that deduces edge signs from multi-hop node pairs, signed graph learning can generate node embeddings that preserve both structural and sign information. However, training on sensitive signed graphs raises significant privacy concerns, as model parameters may leak private link information. Existing protection methods with differential privacy (DP) typically rely on edge or gradient perturbation for unsigned graph protection. Yet, they are not well-suited for signed graphs, mainly because edge perturbation tends to cascading errors in edge sign inference under balance theory, while gradient perturbation increases sensitivity due to node interdependence and gradient polarity change caused by sign flips, resulting in larger noise injection. In this paper, motivated by the robustness of adversarial learning to noisy interactions, we present ASGL, a privacy-preserving adversarial signed graph learning method that preserves high utility while achieving node-level DP. We first decompose signed graphs into positive and negative subgraphs based on edge signs, and then design a gradient-perturbed adversarial module to approximate the true signed connectivity distribution. In particular, the gradient perturbation helps mitigate cascading errors, while the subgraph separation facilitates sensitivity reduction. Further, we devise a constrained breadth-first search tree strategy that fuses with balance theory to identify the edge signs between generated node pairs. This strategy also enables gradient decoupling, thereby effectively lowering gradient sensitivity. Extensive experiments on real-world datasets show that ASGL achieves favorable privacy-utility trade-offs across multiple downstream tasks. Our code and data are available in https://github.com/KHBDL/ASGL-KDD26. Differential privacy, Adversarial signed graph learning, Constrained breadth first search-trees, Balanced theory. journalyear: 2026 copyright: cc conference: Proceedings of the 32nd ACM SIGKDD Conference on Knowledge Discovery and Data Mining V.1; August 09–13, 2026; Jeju Island, Republic of Korea booktitle: Proceedings of the 32nd ACM SIGKDD Conference on Knowledge Discovery and Data Mining V.1 (KDD ’26), August 09–13, 2026, Jeju Island, Republic of Korea doi: 10.1145/3770854.3780282 isbn: 979-8-4007-2258-5/2026/08 ccs: Security and privacy Data anonymization and sanitization 1. Introduction The signed graph is a common and widely adopted graph structure that can represent both positive and negative relationships using signed edges (19; 20; 21). For example, in online social networks shown in Fig. 1, while user interactions reflect positive relationships (e.g., like, trust, friendship), negative relationships (e.g., dislike, distrust, complaint) also exist. Signed graphs provide more expressive power than unsigned graphs to capture such complex user interactions. Recently, some studies (22; 23; 24) have explored signed graph learning methods, aiming to obtain low-dimensional vector representations of nodes that preserve key signed graph properties: neighbor proximity and structural balance. These embeddings are subsequently applied to downstream tasks such as edge sign prediction, node clustering, and node classification. Among existing signed graph learning methods, balance theory (27) has proven effective in identifying the edge signs between the source node and multi-hop neighbor nodes. It is leveraged in graph neural network (GNN)-based models to guide message passing across signed edges, ensuring that information aggregation is aligned with the node proximity (36; 38; 39). Moreover, to enhance the robustness and generalization capability of deep learning models, the adversarial graph embedding model (03; 14) learns the underlying connectivity distribution of signed graphs by generating high-quality node embeddings that preserve signed node proximity. Despite their ability to effectively capture signed relationships between nodes, graph learning models remain vulnerable to link stealing attacks (25; 42; 43), which aim to infer the existence of links between arbitrary node pairs in the training graph. For instance, in online social graphs, such attacks may reveal whether two users share a friendly or adversarial relationship, compromising user privacy and damaging personal or professional reputations. <details> <summary>x1.png Details</summary>  ### Visual Description ## Social Network Diagram: User Interactions ### Overview The image is a social network diagram illustrating interactions between eight users. The diagram uses nodes to represent users and edges to represent interactions. Blue lines indicate positive interactions (like, gift), while red lines indicate negative interactions (distrust, complaint). The diagram shows the relationships and sentiments between the users. ### Components/Axes * **Nodes:** Represent individual users, labeled as User 1 through User 8. Each node is represented by a black silhouette of a person. * **Edges:** Represent interactions between users. * **Blue Lines:** Indicate positive interactions (like, gift). A "+" sign is placed near the blue lines. * **Red Lines:** Indicate negative interactions (distrust, complaint). A "-" sign is placed near the red lines. * **Legend:** Located on the right side of the diagram. * Blue line: "Positive Interaction (Like, Gift)" * Red line: "Negative Interaction (Distrust, Complaint)" ### Detailed Analysis * **User 1:** * Has a negative interaction with User 3 (red line, "-"). * Has a negative interaction with User 5 (red line, "-"). * Has a negative interaction with User 6 (red line, "-"). * Has a positive interaction with User 2 (blue line, "+"). * **User 2:** * Has a positive interaction with User 1 (blue line, "+"). * Has a positive interaction with User 4 (blue line, "+"). * Has a negative interaction with User 4 (red line, "-"). * Has a positive interaction with User 8 (blue line, "+"). * **User 3:** * Has a negative interaction with User 1 (red line, "-"). * Has a positive interaction with User 5 (blue line, "+"). * **User 4:** * Has a positive interaction with User 2 (blue line, "+"). * Has a negative interaction with User 2 (red line, "-"). * Has a negative interaction with User 8 (red line, "-"). * Has a positive interaction with User 6 (blue line, "+"). * **User 5:** * Has a negative interaction with User 1 (red line, "-"). * Has a positive interaction with User 3 (blue line, "+"). * Has a negative interaction with User 6 (red line, "-"). * **User 6:** * Has a negative interaction with User 1 (red line, "-"). * Has a positive interaction with User 4 (blue line, "+"). * Has a negative interaction with User 5 (red line, "-"). * Has a negative interaction with User 7 (red line, "-"). * **User 7:** * Has a negative interaction with User 6 (red line, "-"). * **User 8:** * Has a positive interaction with User 2 (blue line, "+"). * Has a negative interaction with User 4 (red line, "-"). ### Key Observations * User 1 has only negative interactions. * User 2 has only positive interactions. * User 4 has both positive and negative interactions. * User 6 has only negative interactions. * User 7 has only negative interactions. ### Interpretation The diagram represents a social network where interactions between users can be either positive (like, gift) or negative (distrust, complaint). The network shows a mix of positive and negative relationships, with some users having predominantly negative interactions (e.g., User 1, User 6, User 7) and others having predominantly positive interactions (e.g., User 2). User 4 seems to be in a central position, experiencing both positive and negative interactions with other users. The diagram could be used to analyze the sentiment and relationships within a social group, identify potential conflicts, or understand the flow of positive and negative influences. </details> Figure 1. A signed social graph with blue edges for positive links and red edges for negative links. Differential privacy (DP) (06) is a rigorous privacy framework that guarantees statistically indistinguishable outputs regardless of any individual data presence. Such guarantee is achieved through sufficient perturbation while maintaining provable privacy bounds and computational feasibility. Existing privacy-preserving graph learning methods with DP can be categorized into two types based on the perturbation mechanism: one applies edge perturbation (53) to protect the link information by modifying the graph structure, and the other adopts gradient perturbation (54; 52) to obscure the relationships between nodes during model training. However, these methods are not well-suited for signed graph learning due to the following two challenges: - Cascading error: As illustrated in Fig. 2, balance theory facilitates the inference of the edge sign between two unconnected nodes by computing the product of edge signs along a path. However, existing methods that use edge perturbation to protect link information may alter the sign of any edge along the path, thereby leading to incorrect inference of edge signs under balance theory. Such a local error can further propagate along the path, resulting in cascading errors in edge sign inference. - High sensitivity: While gradient perturbation methods without directly perturbing edges may mitigate cascading errors, they are still ill-suited for signed graph learning because the node interdependence in signed graphs leads to high gradient sensitivity. The presence or absence of a node affects gradient updates of itself and its neighbors. Furthermore, edge change may induce sign flips that reverse gradient polarity within the loss function (see Eq. (10) for details), resulting in higher sensitivity compared to unsigned graphs. This increased sensitivity requires larger noise for privacy protection, thereby reducing the data utility. To address these challenges, we turn to an adversarial learning-based approach for private signed graph learning. The core motivation is that this adversarial method generates node embeddings by approximating the true connectivity distribution, making it naturally robust to noisy interactions during optimization. As a result, we propose ASGL, a differentially private adversarial signed graph learning method that achieves high utility while maintaining node-level differential privacy. Within ASGL, the signed graph is first decomposed into positive and negative subgraphs based on edge signs. These subgraphs are then processed through an adversarial learning module within shared model parameters, enabling both positive and negative node pairs to be mapped into a unified embedding space while effectively preserving signed proximity. Based on this, we develop the adversarial learning module with differentially private stochastic gradient descent (DPSGD), which generates private node embeddings that closely approximate the true signed connectivity distribution. In particular, the gradient perturbation helps mitigate cascading errors, while the subgraph separation avoids gradient polarity reversals induced by edge sign flips within the loss function, thereby reducing the sensitivity to changes in edge signs. Considering that node interdependence further increases gradient sensitivity, we design a constrained breadth-first search (BFS) tree strategy within adversarial learning. This strategy integrates balance theory to identify the edge signs between generated node pairs, while also constraining the receptive fields of nodes to enable gradient decoupling, thereby effectively lowering gradient sensitivity and reducing noise injection. Our main contributions are listed as follows: - We present a privacy-preserving adversarial learning method for signed graphs, called ASGL. To our best knowledge, it is the first work that can ensure the node-level differential privacy of signed graph learning while preserving high data utility. - To mitigate cascading errors, we develop the adversarial learning module with DPSGD, which generates private node embeddings that closely approximate the true signed connectivity distribution. This approach avoids direct perturbation of the edge structure, which helps mitigate cascading errors and prevents gradient polarity reversals in the loss function. - To further reduce the sensitivity caused by complex node relationships, we design a constrained breadth-first search tree strategy that integrates balance theory to identify edge signs between generated node pairs. This strategy also constrains the receptive fields of nodes, enabling gradient decoupling and effectively lowering gradient sensitivity. - Extensive experiments demonstrate that our method achieves favorable privacy-accuracy trade-offs and significantly outperforms state-of-the-art methods in edge sign prediction and node clustering tasks. Additionally, we conduct link stealing attacks, demonstrating that ASGL exhibits stronger resistance to such attacks across all datasets. The remainder of our work is organized as follows. Section 2 describes the preliminaries of our solution. The problem statement is introduced in Section 3. Our proposed solution and its privacy analysis are presented in Section 4. The experimental results are reported in Section 5. We discuss related works in Section 6, followed by conclusion in Section 7. 2. Preliminaries In this section, we provide an overview of signed graphs, differential privacy, and DPSGD. Additionally, the vanilla adversarial graph learning is introduced in App. A, and the frequently used notations are summarized in Table 5 (See App. B). 2.1. Signed Graph with Balance Theory A signed graph is denoted as $\mathcal{G}=(V,E^{+},E^{-})$ , where $V$ is the set of nodes, and $E^{+}/E^{-}$ represent positive and negative edge sets, respectively. An edge $e_{ij}=(v_{i},v_{j})∈ E^{+}/E^{-}$ represents the positive/negative link between node pair $(v_{i},v_{j})∈ V$ , respectively. Notably, $E^{+}\cap E^{-}=\emptyset$ ensures that any node pair cannot maintain both positive and negative relationships simultaneously. The objective of signed graph embedding is to learn a mapping function $f:V→\mathbb{R}^{k}$ that projects each node $v∈ V$ into a low $k$ -dimensional vector while preserving both the structural properties of the original signed graph. In other words, node pairs connected by positive edges should be embedded closely, while those connected by negative edges should be placed farther apart in the embedding space. <details> <summary>x2.png Details</summary>  ### Visual Description ## Diagram: Graph Edge Types ### Overview The image illustrates three different types of edges in a graph: Direct Edge, Positive Indirect Edge, and Negative Indirect Edge. Each example shows a simple graph with a root node connected to two child nodes, labeled *v_r* and *v_t*. The color of the node *v_r* and *v_t* changes depending on the type of edge. ### Components/Axes * **Nodes:** Each graph consists of three nodes represented by circles. The top node is unlabeled. The bottom left node is labeled *v_r*, and the bottom right node is labeled *v_t*. * **Edges:** The edges connecting the top node to *v_r* and *v_t* are solid lines, labeled with "+" or "-". The edges between *v_r* and *v_t* are dashed lines, also labeled with "+" or "-". * **Legend:** Located at the bottom of the image, enclosed in a dashed gray box. * **Direct Edge:** Represented by a solid black line. * **Positive Indirect Edge:** Represented by a dashed green line. * **Negative Indirect Edge:** Represented by a dashed brown line. ### Detailed Analysis **Graph 1 (Left): Direct Edge** * The edge from the top node to *v_r* is labeled "+". * The edge from the top node to *v_t* is labeled "+". * Node *v_r* is colored light blue. * Node *v_t* is colored light green. * The edge between *v_r* and *v_t* is a dashed green line, labeled "+". This corresponds to the "Positive Indirect Edge" in the legend. **Graph 2 (Middle): Positive Indirect Edge** * The edge from the top node to *v_r* is labeled "-". * The edge from the top node to *v_t* is labeled "-". * Node *v_r* is colored light blue. * Node *v_t* is colored light green. * The edge between *v_r* and *v_t* is a dashed green line, labeled "+". This corresponds to the "Positive Indirect Edge" in the legend. **Graph 3 (Right): Negative Indirect Edge** * The edge from the top node to *v_r* is labeled "+". * The edge from the top node to *v_t* is labeled "-". * Node *v_r* is colored light blue. * Node *v_t* is colored light red. * The edge between *v_r* and *v_t* is a dashed brown line, labeled "-". This corresponds to the "Negative Indirect Edge" in the legend. ### Key Observations * The color of the nodes *v_r* and *v_t* changes based on the type of indirect edge. * The signs ("+" or "-") on the edges from the top node to *v_r* and *v_t* seem to influence the type of indirect edge. * The sign on the indirect edge between *v_r* and *v_t* matches the description in the legend. ### Interpretation The diagram illustrates how different combinations of direct edges (from the root node) and indirect edges (between the child nodes) can be classified. The signs on the direct edges, along with the resulting colors of the nodes *v_r* and *v_t*, determine whether the indirect edge is positive or negative. The diagram suggests a relationship between the signs of the direct edges and the type of indirect edge, potentially indicating a propagation or influence mechanism within the graph. The color of the node *v_t* seems to be an indicator of the type of indirect edge. </details> Figure 2. The signs of multi-hop connection based on balanced theory. Balance theory (27) is a well-established standard to describe the signed relationships of unconnected node pairs. It is commonly summarized by four intuitive rules: “A friend of my friend is my friend,” “A friend of my enemy is my enemy,” “An enemy of my friend is my enemy,” and “An enemy of my enemy is my friend.” Based on these rules, the balance theory can deduce signs of the multi-hop connection. As shown in Fig. 2, given a path $P_{rt}:v_{r}→ v_{t}$ from rooted node $v_{r}$ to target node $v_{t}$ , the sign of the indirect relationships between $v_{r}$ and $v_{t}$ can be inferred by iteratively applying balance theory. Specifically, the sign of the multi-hop connection corresponds to the product of the signs of the edges along the path. 2.2. Differential Privacy Differential Privacy (DP) (04) provides a rigorous mathematical framework for quantifying the privacy guarantees of algorithms operating on sensitive data. Informally, it bounds how much the output distribution of a mechanism can change in response to small changes in its input. When applying DP to signed graph data, the definition of adjacent databases typically considers two signed graphs, $\mathcal{G}$ and $\mathcal{G^{\prime}}$ , which are regarded as adjacent graphs if they differ by at most one edge or one node with its associated edges. **Definition 0 (Edge (Node)-level DP(05))** *Given $\epsilon>0$ and $\delta>0$ , a graph analysis mechanism $\mathcal{M}$ satisfies edge- or node-level $(\epsilon,\delta)$ -DP, if for any two adjacent graph datasets $\mathcal{G}$ and $\mathcal{G^{\prime}}$ that only differ by an edge or a node with its associated edges, and for any possible algorithm output $S⊂eq Range(\mathcal{M})$ , it holds that $$ \displaystyle\text{Pr}[\mathcal{M}(\mathcal{G})\in S]\leq e^{\epsilon}\text{Pr}[\mathcal{M}(\mathcal{G^{\prime}})\in S]+\delta. \tag{1} $$ Here, $\epsilon$ is the privacy budget (i.e., privacy cost), where smaller values indicate stronger privacy protection but greater utility reduction. The parameter $\delta$ denotes the probability that the privacy guarantee may not hold, and is typically set to be negligible. In other words, $\delta$ allows for a negligible probability of privacy leakage, while ensuring the privacy guarantee holds with high probability.* **Remark 1** *Note that satisfying node-level DP is much more challenging than satisfying edge-level DP, as removing a single node may, in the worst case, remove $|V|-1$ edges, where $|V|$ denotes the total number of nodes. Consequently, node-level DP requires injecting substantially more noise.* Two fundamental properties of DP are useful for the privacy analysis of complex algorithms: (1) Post-Processing Property (06): If a mechanism $\mathcal{M}(\mathcal{G})$ satisfies $(\epsilon,\delta)$ -DP, then for any function $f$ that indirectly queries the private dataset $\mathcal{G}$ , the composition $f(\mathcal{M}(\mathcal{G}))$ also satisfies $(\epsilon,\delta)$ -DP; (2) Composition Property (06): If $\mathcal{M}(\mathcal{G})$ and $f(\mathcal{G})$ satisfy $(\epsilon_{1},\delta_{1})$ -DP and $(\epsilon_{2},\delta_{2})$ -DP, respectively, then the combined mechanism $\mathcal{F}(\mathcal{G})=(\mathcal{M}(\mathcal{G}),f(\mathcal{G}))$ which outputs both results, satisfies $(\epsilon_{1}+\epsilon_{2},\delta_{1}+\delta_{2})$ -DP. 2.3. DPSGD A common approach to differentially private training combines noisy stochastic gradient descent with the Moments Accountant (MA) (02). This approach, known as DPSGD, has been widely adopted for releasing private low-dimensional representations, as MA effectively mitigates excessive privacy loss during iterative optimization. Formally, for each sample $x_{i}$ in a batch of size $B$ , we compute its gradient $∇\mathcal{L}_{i}(\theta)$ , denoted as $∇(x_{i})$ for simplicity. Gradient sensitivity refers to the maximum change in the output of the gradient function resulting from a change in a single sample. To control the sensitivity of ${∇(x_{i})}$ , the $\ell_{2}$ norm of each gradient is clipped by a threshold $C$ . These clipped gradients are then aggregated and perturbed with Gaussian noise $\mathcal{N}(0,\sigma^{2}C^{2}\mathbf{I})$ to satisfy the DP guarantee. Finally, the average noisy gradient ${\tilde{∇}_{B}}$ is used to update the model parameters $\theta$ . This process is given by: $$ \displaystyle{\tilde{\nabla}_{B}}\leftarrow\frac{1}{B}\Big(\sum_{i=1}^{B}\text{Clip}_{C}(\nabla(x_{i}))+\mathcal{N}\left(0,\sigma^{2}C^{2}\mathbf{I}\right)\Big). \tag{2} $$ Here, $\text{Clip}_{C}(∇(x_{i}))=∇(x_{i})/\max(1,\frac{||∇(x_{i})||_{2}}{C})$ . 3. Problem Definition and Existing Solutions 3.1. Problem Definition Instead of publishing a sanitized version of original node embeddings, we aim to release a privacy-preserving ASGL model trained on raw signed graph data with node-level DP guarantees, enabling data analysts to generate task-specific node embeddings. Threat Model. We consider a black-box attack (42), where the attacker can query the trained model and observe its outputs with no access to its internal architecture or parameters. The attacker attempts to infer the presence of specific nodes or edges in the training graph solely from model outputs. This setting reflects a more practical attack surface compared to the white-box scenario (11). Privacy Model. Signed graph data encodes both positive and negative relationships between nodes, which differs from tabular or image data. Therefore, it is necessary to adapt the standard definition of node-level DP (See Definition 1) to ensure black-box adversaries cannot determine whether a specific node and its associated signed edges are present in the training data. To this end, we define the differentially private adversarial signed graph learning model as follows. **Definition 0 (Adversarial signed graph learning model under node-level DP)** *The vanilla process of graph adversarial learning is illustrated in App. A, let $\theta_{D}$ denote the discriminator parameters, and its $r$ -th row element corresponds to the $k$ -dimensional vector $\mathbf{d}_{v_{r}}$ of node $v_{r}$ , that is $\mathbf{d}_{v_{r}}∈\theta_{D}$ . The discriminator module $L_{D}$ satisfies node-level ( $\epsilon,\delta$ )-DP if two adjacent signed graphs $\mathcal{G}$ and $\mathcal{G}^{\prime}$ only differ in one node with its associated signed edges, and for all possible $\theta_{s}⊂eq Range(L_{D})$ , we have $$ \displaystyle\text{Pr}[L_{D}(\mathcal{G})\in\theta_{s}]\leq e^{\epsilon}\text{Pr}[L_{D}(\mathcal{G^{\prime}})\in\theta_{s}]+\delta, \tag{3} $$ where $\theta_{s}$ denotes the set comprising all possible values of $\theta_{D}$ .* In particular, the generator $G$ is trained based on the feedback from the differentially private discriminator $D$ . According to the post-processing property of DP (08; 12), the generator module $L_{G}$ also satisfies node-level $(\epsilon,\delta)$ -DP. Leveraging the robustness to post-processing property, the privacy guarantee is preserved in the generated signed node embeddings and their downstream usage. <details> <summary>x3.png Details</summary>  ### Visual Description ## Diagram: Graph Embedding and Differential Privacy ### Overview The image is a diagram illustrating a process for graph embedding with differential privacy. It shows how an original graph is transformed into positive and negative graphs, embedded into a space, and then processed with gradient clipping and noise addition to ensure privacy. ### Components/Axes The diagram is divided into three main sections, labeled (i), (ii), and (iii). **Legend (Top-Left)** * Rooted node: Represented by a white circle. * Positive edge: Represented by a blue line. * Negative edge: Represented by a red line. **Section (i): Graph Creation** * The original graph G is shown with a mix of positive (blue) and negative (red) edges connecting nodes. One node is marked as the "Rooted node". * The original graph G is transformed into: * The positive graph G', which contains positive edges (blue). * The negative graph G', which contains negative edges (red). **Section (ii): Embedding Space and Path Generation** * Two blocks labeled G+ and G- represent transformations of the positive and negative graphs, respectively. * G+ is associated with "Positive relevance probability" denoted as p+_{E}(v_i | v_r). * G- is associated with "Negative relevance probability" denoted as p-_{E}(v_i | v_r). * An "Embedding Space (θ_E)" block sits between G+ and G-, with arrows indicating "Update" from G+ and G- and to G+ and G-. * "Downstream tasks" is written in a red box, with dashed red arrows pointing to and from the "Embedding Space (θ_E)". * Path Generation: * "(iv) Path from Constrained BFS-tree" is shown for both positive and negative graphs. * The path consists of connected nodes. * "Max path length L = 4" and "Max path amount N = 2" are specified. * "Guidance: Post-processing" is indicated. * Real and fake positive/negative edges are shown as pairs of nodes connected by either a blue or red line. **Section (iii): Differential Privacy** * Two blocks labeled D+ and D- represent differential privacy processing for positive and negative graphs, respectively. * "Gradient Clipping" is applied to both D+ and D-. * The gradients are represented as ∇v_i. * A summation formula is shown: 1/n * Σ ∇v_i. * "Gradient Average + Noise Addition" is applied. The noise is represented by a Gaussian distribution N(0, (λ(e^(λ/2)-1)/n^2) * σ^2). * "DPSGD" (Differentially Private Stochastic Gradient Descent) is indicated. * The output consists of "Real" and "Fake" nodes, colored blue and white for D+, and red and white with diagonal lines for D-. ### Detailed Analysis * **Graph Creation (i):** The original graph is split into positive and negative graphs, likely based on edge types or relationships. * **Embedding Space (ii):** The positive and negative graphs are embedded into a shared space, which is updated based on the relevance probabilities. * **Path Generation (ii):** Paths are generated from the embedded graphs using a constrained Breadth-First Search (BFS) tree. The maximum path length and amount are limited. * **Differential Privacy (iii):** Gradient clipping and noise addition are applied to the gradients to ensure differential privacy during the learning process. ### Key Observations * The diagram illustrates a process for learning graph embeddings while preserving privacy. * The use of both positive and negative graphs suggests a contrastive learning approach. * The differential privacy mechanism involves gradient clipping and noise addition, which are standard techniques for protecting sensitive information. ### Interpretation The diagram presents a method for creating graph embeddings that are both informative and privacy-preserving. The process involves transforming the original graph into positive and negative representations, embedding these representations into a shared space, and then applying differential privacy techniques to protect sensitive information during the learning process. The "Downstream tasks" element suggests that these embeddings are intended to be used for further analysis or prediction. The use of constrained BFS trees for path generation likely aims to capture relevant relationships within the graph while limiting computational complexity. The overall approach balances the need for accurate graph representations with the requirement to protect the privacy of the underlying data. </details> Figure 3. Overview of the ASGL framework: (i) The process decomposes a signed graph into positive and negative subgraphs, (ii) then maps node pairs into a unified embedding space while preserving signed proximity. To ensure privacy, (iii) adversarial learning module with DPSGD generates private node embeddings that approximate true connectivity without cascading errors. (iv) A constrained BFS-tree strategy manages node receptive field, reduces gradient noise, and improves model utility. 3.2. Existing Solutions To our best knowledge, existing differentially private graph learning methods follow two main tracks: gradient perturbation and edge perturbation. In the first category, Yang et al. (54) introduce a privacy-preserving generative model that incorporates generative adversarial networks (GAN) or variational autoencoders (VAE) with DPSGD to protect edge privacy, while Xiang et al. (52) design a node sampling mechanism that adds Laplace noise to per-subgraph gradients, achieving node-level DP. For the edge perturbation-based methods, Lin et al. (53) use randomized response to perturb the adjacency matrix for edge-level privacy, and EDGERAND (42) perturbs the graph structure while preserving sparsity by clipping the adjacency matrix according to a privacy-calibrated graph density. Limitation. The aforementioned solutions are not directly applicable to signed graphs. This is primarily because edge perturbation can lead to cascading errors when inferring edge signs under balance theory. Moreover, gradient perturbation often suffers from high sensitivity caused by complex node dependencies and gradient polarity reversal from edge sign flips, leading to excessive noise and degraded model utility. 4. Our Proposal: ASGL To tackle the above limitations, we present ASGL, a DP-based adversarial signed graph learning model that integrates a constrained BFS-tree strategy to achieve favorable utility-privacy tradeoffs. 4.1. Overview The ASGL framework, illustrated in Fig. 3, comprises three steps: - Private Adversarial Signed Graph Learning. The signed graph $\mathcal{G}$ is first split into positive and negative subgraphs, $\mathcal{G}^{+}$ and $\mathcal{G}^{-}$ , based on edge signs. Subsequently, two discriminators, $D^{+}$ and $D^{-}$ , sharing parameters $\theta_{D}$ , are trained to distinguish real from fake positive and negative edges. Guided by $D^{+}$ and $D^{-}$ , two generators $G^{+}$ and $G^{-}$ with shared parameters $\theta_{G}$ generate node embeddings that approximate the true connectivity distribution. To ensure node-level DP, we apply gradient perturbation during discriminator training instead of directly perturbing edges. This strategy mitigates cascading errors and prevents gradient polarity reversals caused by edge sign flips, thereby reducing gradient sensitivity. By the post-processing property, the generators also preserve node-level DP. - Optimization via Constrained BFS-tree. To further reduce gradient sensitivity and the required noise scale, ASGL employs a constrained BFS-tree strategy. By empirically limiting the number and length of paths, each node’s receptive field is restricted, which reduces node dependency and enables gradient decoupling. This significantly lowers gradient sensitivity and enhances model utility under differential privacy constraints. - Privacy Accounting and Complexity Analysis. The complete training process for ASGL is outlined in Algorithm 2 (see App. F.3). Based on this, we present a comprehensive privacy accounting and computational complexity analysis for ASGL. 4.2. Private Adversarial Signed Graph Learning Motivated by (03; 14), a signed graph $\mathcal{G}$ is first divided into a positive subgraph $\mathcal{G}^{+}$ and a negative subgraph $\mathcal{G}^{-}$ according to edge signs. Let $\mathcal{N}(v_{r})$ be the set of neighbor nodes directly connected to node $v_{r}$ . We denote the true positive and negative connectivity distributions of $v_{r}$ over its neighborhood $\mathcal{N}(v_{r})$ as the conditional probabilities $p_{\text{true}}^{+}(·|v_{r})$ and $p_{\text{true}}^{-}(·|v_{r})$ , which capture the preference of $v_{r}$ to connect with other nodes in $V$ . The adversarial learning for the signed graph $\mathcal{G}$ is conducted by two adversarial learning modules: Generators $G^{+}$ and $G^{-}$ : Through optimizing the shared parameters $\theta_{G}$ , generators $G^{+}$ and $G^{-}$ aim to approximate the underlying true connectivity distribution and generate the most likely but unconnected nodes $v_{t}∉\mathcal{N}(v_{r})$ that are relevant to a given node $v_{r}$ . To this end, we estimate the relevance probabilities of these fake The term “Fake” indicates that although a node $v$ selected by the generator is relevant to $v_{r}$ , there is no actual edge between them. node pairs. Specifically, for the implementation of $G^{+}$ , given the fake positive node pairs $(v_{r},v_{t})^{+}$ , we use the graph softmax function (03) to calculate the fake positive connectivity probability: $$ p^{+}_{\text{fake}}(v_{t}|v_{r})=G^{+}\left(v_{t}|v_{r};\theta_{G}\right)=\sigma(\mathbf{g}_{v_{t}}^{\top}\mathbf{g}_{v_{r}})=\frac{1}{1+\exp({-\mathbf{g}_{v_{t}}^{\top}\mathbf{g}_{v_{r}})}}, \tag{4} $$ where $\mathbf{g}_{v_{t}},\mathbf{g}_{v_{r}}∈\mathbb{R}^{k}$ are the $k$ -dimensional vectors of nodes $v_{t}$ and $v_{r}$ , respectively, and $\theta_{G}$ is the union of all $\mathbf{g}_{v}$ ’s. The output $G^{+}(v_{t}|v_{r};\theta_{G})$ increases with the decrease of the distance between $v_{r}$ and $v_{t}$ in the embedding space of the generator $G^{+}$ . Similarly, for the generator $G^{-}$ , given the fake negative node pairs $(v_{r},v_{t})^{-}$ , we estimate their fake negative connectivity probability: $$ p^{-}_{\text{fake}}(v_{t}|v_{r})=G^{-}(v_{t}|v_{r};\theta_{G})=1-\sigma(\mathbf{g}_{v_{t}}^{\top}\!\mathbf{g}_{v_{r}})=\frac{\exp{(-\mathbf{g}_{v_{t}}^{\top}\!\mathbf{g}_{v_{r}}})}{1+\exp{(-\mathbf{g}_{v_{t}}^{\top}\!\mathbf{g}_{v_{r}}})}. \tag{5} $$ Here, Eq. (5) ensures that node pairs with higher negative connectivity probabilities are mapped farther apart in the embedding space of $G^{-}$ . Since generators $G^{+}$ and $G^{-}$ share the parameters $\theta_{G}$ , they jointly learn the proximity and separation of positive and negative node pairs in a unified embedding space, respectively. Notably, the aforementioned fake node pairs $(v_{r},v_{t})^{+}$ and $(v_{r},v_{t})^{-}$ are sampled by a breadth-first search (BFS)-tree strategy (27). Compared to depth-first search (DFS) (56), BFS ensures more uniform exploration of neighboring nodes and can be integrated with random walk techniques (29) to optimize computational efficiency. Specifically, we perform BFS on the positive subgraph $\mathcal{G}^{+}$ to construct a BFS-tree $T^{+}_{v_{r}}$ rooted from node $v_{r}$ . Then, we calculate the positive relevance probability of node $v_{r}$ with its neighbors $v_{k}∈\mathcal{N}({v_{r}})$ : $$ p^{+}_{T^{+}_{v_{r}}}(v_{k}|v_{r})=\frac{\exp\left(\mathbf{g}_{v_{k}}^{\top}\mathbf{g}_{v_{r}}\right)}{\sum_{v_{k}\in\mathcal{N}({v_{r}})}\exp\left(\mathbf{g}_{v_{k}}^{\top}\mathbf{g}_{v_{r}}\right)}, \tag{6} $$ which is actually a softmax function over $\mathcal{N}({v_{r}})$ . To further sample node pairs unconnected in $T^{+}_{v_{r}}$ as fake positive edges, we perform a random walk at $T^{+}_{v_{r}}$ : Starting from the root node $v_{r}$ , a path $P_{rt}:v_{r}→ v_{t}$ is built by iteratively selecting the next node based on the transition probabilities defined in Eq. (6). The resulting unconnected node pair $(v_{r},v_{t})^{+}$ is treated as a fake positive edge, and App. E provides an example of this process. Given the node pair $(v_{r},v_{t})^{+}$ , the generator $G^{+}$ estimates $p^{+}_{\text{fake}}(v_{t}|v_{r})$ according to Eq. (4). Similarly, we also establish a BFS-tree $T^{-}_{v_{r}}$ rooted at node $v_{r}$ in the negative subgraph $\mathcal{G}^{-}$ . To obtain the negative node pair $(v_{r},v_{t})^{-}$ , we perform a random walk on $T^{-}_{v_{r}}$ according to the following transition probability (i.e., negative relevance probability): $$ p^{-}_{T^{-}_{v_{r}}}(v_{k}|v_{r})=\frac{1-\exp\left(\mathbf{g}_{v_{k}}^{\top}\mathbf{g}_{v_{r}}\right)}{\sum_{v_{k}\in\mathcal{N}({v_{r}})}\left(1-\exp\left(\mathbf{g}_{v_{k}}^{\top}\mathbf{g}_{v_{r}}\right)\right)}. \tag{7} $$ In particular, the edge sign of the negative node pair $(v_{r},v_{t})^{-}$ depends on the length of the path $P_{rt}:v_{r}→ v_{t}$ . According to the balance theory introduced in Section 2.1, the edge signs of multi-hop node pairs correspond to the product of the edge signs along the path. Accordingly, the rules for generating fake negative edges within $P_{rt}$ are defined as follows: (1) If the path length of $P_{rt}$ is odd, a node pair $(v_{r},v_{t})^{-}$ for the rooted node $v_{r}$ and the last node $v_{t}$ is selected as a fake negative pair; (2) If the path length of $P_{rt}$ is even, a node pair $(v_{r},v_{t})^{-}$ for the rooted node $v_{r}$ and the second last node $v_{t}$ is selected as a fake negative pair. The resulting node pair $(v_{r},v_{t})^{-}$ is then used to compute $p^{-}_{\text{fake}}(v_{t}|v_{r})$ according to Eq. (5). Discriminators $D^{+}$ and $D^{-}$ : This module tries to distinguish between real node pairs and fake node pairs synthesized by the generators $G^{+}$ and $G^{-}$ . Accordingly, the discriminators $D^{+}$ and $D^{-}$ estimate the likelihood that positive and negative edges exists between $v_{r}$ and $v∈ V$ , respectively, denoted as: $$ D^{+}(v_{r},v|\theta_{D})=\sigma(\mathbf{d}_{v}^{\top}\mathbf{d}_{v_{r}})=\frac{1}{1+\exp({-\mathbf{d}_{v}^{\top}\mathbf{d}_{v_{r}})}},\\ \tag{8} $$ $$ D^{-}(v,v_{r}|\theta_{D})=1-\sigma(\mathbf{d}_{v}^{\top}\mathbf{d}_{v_{r}})=\frac{\exp({-\mathbf{d}_{v}^{\top}\mathbf{d}_{v_{r}})}}{1+\exp({-\mathbf{d}_{v}^{\top}\mathbf{d}_{v_{r}})}}, \tag{9} $$ where $\mathbf{d}_{v},\mathbf{d}_{v_{r}}∈\mathbb{R}^{k}$ are vectors corresponding to the $v$ -th and $v_{r}$ -th rows of shared parameters $\theta_{D}$ , respectively. $\sigma(·)$ represents the sigmoid function of the inner product of these two vectors. In summary, given real positive and real negative edges sampled from $p_{\text{true}}^{+}(·|v_{r})$ and $p_{\text{true}}^{-}(·|v_{r})$ , along with fake positive and fake negative edges generated from generators $G^{+}/G^{-}$ , the adversarial learning pairs $(D^{+},G^{+})$ and $(D^{-},G^{-})$ , operating on the positive subgraph $\mathcal{G}^{+}$ and the negative subgraph $\mathcal{G}^{-}$ , respectively, engage in a four-player mini-max game with the joint loss function: $$ \displaystyle\min_{\theta_{G}} \displaystyle\max_{\theta_{D}}L\left(G^{+},G^{-},D^{+},D^{-}\right) \displaystyle= \displaystyle\sum_{v_{r}\in V^{+}}\left(\left(\mathbb{E}_{v\sim p_{\text{true }}^{+}\left(\cdot\mid v_{r}\right)}\right)\left[\log D^{+}\left(v,v_{r}\mid\theta_{D}\right)\right]\right. \displaystyle\left.\qquad+\left(\mathbb{E}_{v\sim G^{+}\left(\cdot\mid v_{r};\theta_{G}\right)}\right)\left[\log\left(1-D^{+}\left(v,v_{r}\mid\theta_{D}\right)\right)\right]\right) \displaystyle+ \displaystyle\sum_{v_{r}\in V^{-}}\left(\left(\mathbb{E}_{v\sim p_{\text{true }}^{-}\left(\cdot\mid v_{r}\right)}\right)\left[\log D^{-}\left(v,v_{r}\mid\theta_{D}\right)\right]\right. \displaystyle\left.\qquad+\left(\mathbb{E}_{v\sim G^{-}\left(\cdot\mid v_{r};\theta_{G}\right)}\right)\left[\log\left(1-D^{-}\left(v,v_{r}\mid\theta_{D}\right)\right)\right]\right). \tag{10} $$ Based on Eq. (10), the parameters $\theta_{D}$ and $\theta_{G}$ are updated alternately by maximizing and minimizing the joint loss function. Competition between $G$ and $D$ results in mutual improvement until the fake node pairs generated by $G$ are indistinguishable from the real ones, thus approximating the true connectivity distribution. Lastly, the learned node embeddings $\mathbf{g}_{v}∈\theta_{G}$ are used in downstream tasks. How to Achieve DP? Given real and fake positive/negative edges of the node $v_{i}$ , the corresponding node embedding $\mathbf{d}_{v_{i}}∈\theta_{D}$ is updated by ascending gradients of the joint loss function in Eq. (10): $$ \frac{\partial L_{D}}{\partial\mathbf{d}_{v_{i}}}=\left\{\begin{array}[]{l}\partial\log{D^{+}(v_{i},v_{j}|\theta_{D})}/{\partial\mathbf{d}_{v_{i}}}=[1-\sigma(\mathbf{d}_{v_{j}}^{\top}\mathbf{d}_{v_{i}})]\mathbf{d}_{v_{j}},\\ \text{if }\left(v_{i},v_{j}\right)\text{ is a real positive edge from $\mathcal{G}^{+}$};\\ \partial\log{(1-D^{+}(v_{i},v_{j}|\theta_{D}))}/{\partial\mathbf{d}_{v_{i}}}=-\sigma(\mathbf{d}_{v_{j}}^{\top}\mathbf{d}_{v_{i}})\mathbf{d}_{v_{j}},\\ \text{if }\left(v_{i},v_{j}\right)\text{ is a fake positive edge from ${G}^{+}$};\\ \partial\log{D^{-}(v_{i},v_{j}|\theta_{D})}/{\partial\mathbf{d}_{v_{i}}}=-\sigma(\mathbf{d}_{v_{j}}^{\top}\mathbf{d}_{v_{i}})\mathbf{d}_{v_{j}},\\ \text{if }\left(v_{i},v_{j}\right)\text{ is a real negative edge from $\mathcal{G}^{-}$};\\ \partial\log{(1-D^{-}(v_{i},v_{j}|\theta_{D}))}/{\partial\mathbf{d}_{v_{i}}}=[1-\sigma(\mathbf{d}_{v_{j}}^{\top}\mathbf{d}_{v_{i}})]\mathbf{d}_{v_{j}},\\ \text{if }\left(v_{i},v_{j}\right)\text{ is a fake negative edge from ${G}^{-}$}.\end{array}\right. \tag{11} $$ According to Definition 1, to achieve node-level differential privacy in adversarial signed graph learning, it is necessary to add the Gaussian noise to the sum of clipped gradients over a batch of nodes. The resulting noisy gradient $\tilde{∇}{L_{D}}$ is formulated as: $$ {\tilde{\nabla}{L_{D}}}=\frac{1}{B}\Big(\sum_{v_{i}\in V_{B}}\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v_{i}}})+\mathcal{N}\left(0,B^{2}C^{2}\sigma^{2}\mathbf{I}\right)\Big), \tag{12} $$ where $V_{B}$ denotes the batch set of nodes, with batch size $B=|V_{B}|$ . $C$ is the clipping threshold to control gradient sensitivity. The fact that the gradient sensitivity reaches $BC$ is explained in Section 4.3. **Remark 2** *To achieve node-level DP, we perturb discriminator gradients instead of signed edges, avoiding cascading errors and gradient polarity reversals from edge sign flips (see Eq. (10)), which reduces gradient sensitivity. Furthermore, generators also preserve DP under discriminator guidance via the post-processing property of DP.* 4.3. Optimization via Constrained BFS-Tree According to Eq. (11), in graph adversarial learning, the interdependence among samples implies that modifying a single node $v_{i}$ may affect the gradients of multiple other nodes $v_{j}$ within the same batch. This interdependence also exists among the fake node pairs generated along the BFS-tree paths. Consequently, in the worst-case illustrated in Fig. 4 (a), all node samples within a batch may become interrelated due to the BFS-tree, resulting in the gradient sensitivity of discriminators $D$ as high as $BC$ . Such high sensitivity necessitates injecting substantial noise to satisfy node-level DP, hindering effective optimization and reducing model utility. <details> <summary>x4.png Details</summary>  ### Visual Description ## Diagram: Constrained BFS-tree Transformation ### Overview The image illustrates the transformation of a Breadth-First Search (BFS) tree into a constrained BFS-tree. The diagram shows a network of nodes, with a central node labeled "vr". The transformation involves removing certain connections and nodes based on constraints, resulting in a modified network structure. ### Components/Axes * **Nodes:** Represented by circles. * Light Blue circles: "Nodes associated with vr" * White circles: "Nodes not associated with vr" * Central Node: Labeled "vr", colored light red. * **Edges:** Represented by black lines, indicating connections between nodes. * **Red 'X' Marks:** Indicate removed connections. * **Dashed Gray Arcs:** Indicate 1-hop and 2-hop distances from the central node "vr". * **Arrow:** A thick red arrow pointing from the left diagram to the right diagram, labeled "Constrained BFS-tree". * **Labels:** * (a): Label for the initial BFS-tree diagram (left). * (b): Label for the constrained BFS-tree diagram (right). * **Legend:** Located at the bottom-left of the image. * Light Blue circle with black outline: "Nodes associated with vr" * White circle with black outline: "Nodes not associated with vr" ### Detailed Analysis or Content Details **Left Diagram (a): Initial BFS-tree** * The central node "vr" (light red) is connected to multiple light blue nodes. * The light blue nodes are further connected to other light blue nodes, forming a tree-like structure. * All nodes in this initial tree are light blue, indicating they are all associated with "vr". **Right Diagram (b): Constrained BFS-tree** * The central node "vr" (light red) remains. * Some connections from "vr" and between other nodes have been removed, indicated by red 'X' marks. * Some nodes have changed from light blue to white, indicating they are no longer associated with "vr". * Dashed gray arcs indicate 1-hop and 2-hop distances from "vr". * The 1-hop arc shows nodes directly connected to "vr". * The 2-hop arc shows nodes two connections away from "vr". * Several white nodes are present in the constrained tree, particularly at the periphery. ### Key Observations * The transformation from the initial BFS-tree to the constrained BFS-tree involves removing connections and changing the association of some nodes with "vr". * The constraints appear to be related to hop distance from "vr", as indicated by the 1-hop and 2-hop arcs. * Nodes that are further away from "vr" are more likely to be disassociated (changed to white). ### Interpretation The diagram illustrates a process of constraining a BFS-tree, likely for optimization or to meet specific network requirements. The constraints involve removing connections and disassociating nodes from the central node "vr". The hop distance from "vr" seems to play a role in determining which connections and nodes are removed. This suggests that the constrained BFS-tree might be designed to limit the scope or reach of the network originating from "vr", possibly to improve efficiency or reduce interference. The transformation highlights the difference between a standard BFS-tree, which explores all reachable nodes, and a constrained version, which selectively limits the network based on predefined criteria. </details> Figure 4. The receptive field of node $v_{r}$ within a batch is illustrated in two cases: (a) An unconstrained BFS tree, and the receptive field size of $v_{r}$ is $B=|V_{B}|=34$ ; (b) A constrained BFS tree with path length $L=2$ , path amount $N=3$ of each node, and the receptive field size of $v_{r}$ is $\sum_{l=0}^{L}N^{l}=13$ . To address the aforementioned challenge, we introduce the constrained BFS-tree strategy: As illustrated in Algorithm 1 (see App. F.2), when performing a random walk on the BFS-tree $T^{+}_{v_{r}}$ or $T^{-}_{v_{r}}$ rooted at $v_{r}∈ V_{tr}$ to generate multiple unique paths, we also limit both the number of sampled paths and their lengths by $N$ and $L$ . Following this, the training set of subgraphs $S_{tr}$ composed of constrained paths is obtained. The rationale behind these settings is discussed below. **Theorem 1** *By constraining both the number and length of paths generated via random walks on the BFS-trees to $N$ and $L$ , respectively, the gradient sensitivity $\Delta_{{g}}$ of the discriminator can be reduced from $BC$ to $\frac{N^{L+1}-1}{N-1}C$ . Empirical results in Section 5 demonstrate that our ASGL achieves satisfactory performance even with a relatively small receptive field. Specifically, when setting $N=3$ and $L=4$ , that is, $\frac{N^{L+1}-1}{N-1}=121<B=256$ , the ASGL method still performs good model utility. Thus, the noisy gradient $\tilde{∇}{L_{D}}$ of discriminator within a mini-batch $\mathcal{B}_{t}$ is denoted as: $$ \displaystyle{\tilde{\nabla}{L_{D}}}=\frac{1}{|\mathcal{B}_{t}|}\Big(\sum_{v\in\mathcal{B}_{t}}\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v}})+\mathcal{N}\left(0,\Delta_{{g}}^{2}\sigma^{2}\mathbf{I}\right)\Big), \tag{13} $$ where the gradient sensitivity $\Delta_{{g}}=\frac{N^{L+1}-1}{N-1}C$ .* Proof of Theorem 1. Let the sum of clipped gradients of batch subgraphs be $g_{t}(\mathcal{G})=\sum_{v∈\mathcal{B}_{t}}\text{Clip}_{C}(\frac{∂ L_{D}}{∂\mathbf{d}_{v}})$ , where $\mathcal{B}_{t}$ represents any choice of batch subgraphs from $S_{tr}$ . Consider a node-level adjacent graph $\mathcal{G}^{\prime}$ formed by removing a node $v^{*}$ with its associated edges from $\mathcal{G}$ , we obtain their training sets of subgraphs $S_{tr}$ and $S_{tr}^{\prime}$ via the SAMPLE-SUBGRAPHS method in Algorithm 1, denoted as: $$ \displaystyle S_{tr} \displaystyle=\text{SAMPLE-SUBGRAPHS}(\mathcal{G},V_{tr},N,L), \displaystyle S_{tr}^{\prime} \displaystyle=\text{SAMPLE-SUBGRAPHS}(\mathcal{G}^{\prime},V_{tr},N,L). \tag{14} $$ The only subgraphs that differ between $S_{tr}$ and $S_{tr}^{\prime}$ are those that involve the node $v^{*}$ . Let $S(v^{*})$ denote the set of such subgraphs, i.e., $S(v^{*})=S_{tr}\setminus S_{tr}^{\prime}$ . According to Lemma 1 in App. G, the number of such subgraphs $S(v^{*})$ is at most $R_{N,L}$ . Thus, in any mini-batch training, the only gradient terms $\frac{∂ L_{D}}{∂\mathbf{d}_{v}}$ affected by the removal of node $v^{*}$ are those associated with the subgraphs in $(S(v^{*})\cap\mathcal{B}_{t})$ : $$ \displaystyle g_{t}(\mathcal{G})-g_{t}(\mathcal{G}^{\prime}) \displaystyle=\sum_{v\in\mathcal{B}_{t}}\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v}})-\sum_{v^{\prime}\in\mathcal{B}_{t}^{\prime}}\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v^{\prime}}}) \displaystyle=\sum_{v,v^{\prime}\in(S(v^{*})\cap\mathcal{B}_{t})}[\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v}})-\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v^{\prime}}})], \tag{15} $$ where $\mathcal{B}_{t}^{\prime}=\mathcal{B}_{t}\setminus(S(v^{*})\cap\mathcal{B}_{t})$ . Since each gradient term is clipped to have an $\ell_{2}$ -norm of at most $C$ , it holds that: $$ ||\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v}})-\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v^{\prime}}})||_{F}\leq C. \tag{16} $$ In the worst case, all subgraphs in $S(v^{*})$ appear in $\mathcal{B}_{t}$ , so we bound the $\ell_{2}$ -norm of the following quantity based on Lemma 2 in App. G: $$ ||g_{t}(\mathcal{G})-g_{t}(\mathcal{G}^{\prime})||_{F}\leq C\cdot R_{N,L}=C\cdot\frac{N^{L+1}-1}{N-1}. \tag{17} $$ The same reasoning applies when $\mathcal{G}^{\prime}$ is obtained by adding a new node $v^{*}$ to $\mathcal{G}$ . Since $\mathcal{G}$ and $\mathcal{G}^{\prime}$ are arbitrary node-level adjacent graphs, the proof is complete. 4.4. Privacy and Complexity Analysis The complete training process for ASGL is outlined in Algorithm 2 (see App. F.3). In this section, we present a comprehensive privacy analysis and computational complexity analysis for ASGL. Privacy Accounting. In this section, we adopt the functional perspective of Rényi Differential Privacy (RDP; see App. C) to analyze privacy budgets of ASGL, as summarized below: **Theorem 2** *Given the number of training set $N_{tr}$ , number of epochs $n^{epoch}$ , number of discriminators’ iterations $n^{iter}$ , batch size $B_{d}$ , maximum path length $L$ , and maximum path number $N$ , over $T=n^{epoch}n^{iter}$ iterations, Algorithm 2 satisfies node-level $(\alpha,2T\gamma)$ -RDP, where $\gamma=\frac{1}{\alpha-1}\ln\left(\sum_{i=0}^{R_{N,L}}\beta_{i}\left(\exp{\frac{\alpha(\alpha-1)i^{2}}{2\sigma^{2}R_{N,L}^{2}}}\right)\right)$ , $R_{N,L}=\frac{N^{L+1}-1}{N-1}$ and $\beta_{i}=\binom{R_{N,L}}{i}\binom{N_{tr}-R_{N,L}}{B_{d}-i}/{\binom{N_{tr}}{B_{d}}}$ . Please refer to App. I for the proof.* Complexity Analysis. To analyze the time complexity of training ASGL (App. F.3), we break down the major computations. The outer loop runs for $n^{\text{epoch}}$ epochs, and in each epoch, the discriminators $D^{+}$ and $D^{-}$ are trained for $n^{\text{iter}}$ iterations. Each iteration samples a batch of $B_{d}$ real and fake edges to update $\theta_{D}$ , with DP cost updates incurring complexity $\mathcal{O}(B_{d}k\xi)$ , where $\xi$ is the sampling probability and $k$ is the embedding dimension (08; 17). Thus, each epoch of $D^{+}$ or $D^{-}$ costs $\mathcal{O}(n^{\text{iter}}B_{d}k(1+\xi))$ . For the generators $G^{+}$ and $G^{-}$ , each iteration samples $B_{g}$ fake edges to update $\theta_{G}$ , resulting in per-epoch complexity $\mathcal{O}(n^{\text{iter}}B_{g}k)$ . In total, ASGL’s overall time complexity over $n^{\text{epoch}}$ epochs is: $\mathcal{O}\left(2n^{\text{epoch}}n^{\text{iter}}(B_{d}+B_{g})(1+\xi)k\right)$ . This complexity is linear in the number of iterations and batch size, demonstrating the scalability of ASGL for large-scale graphs. 5. Experiments In this section, some experiments are designed to answer the following questions: (1) How do key parameters affect the performance of ASGL (See Section 5.2)? (2) How much does the privacy budget affect the performance of ASGL and other private signed graph learning models in edge sign prediction (See Section 5.3)? (3) How much does the privacy budget affect the performance of ASGL and other baselines in node clustering (See Section 5.4)? (4) How resilient is ASGL to defense link stealing attacks (See Section 5.5)? Table 1. Overview of the datasets | Bitcoin-Alpha | 3,783 | 14,081 | 12,769 (90.7 $\%$ ) | 1,312 (9.3 $\%$ ) | | --- | --- | --- | --- | --- | | Bitcoin-OTC | 5,881 | 21,434 | 18,281 (85.3 $\%$ ) | 3,153 (14.7 $\%$ ) | | WikiRfA | 11,258 | 185,627 | 144,451 (77.8 $\%$ ) | 41,176 (22.2 $\%$ ) | | Slashdot | 13,182 | 36,338 | 30,914 (85.1 $\%$ ) | 5,424 (14.9 $\%$ ) | | Epinions | 131,828 | 841,372 | 717,690 (85.3 $\%$ ) | 123,682 (14.7 $\%$ ) | 5.1. Experimental Settings Datasets. To comprehensive evaluate our ASGL method, we conduct extensive experiments on five real-world datasets, namely Bitcoin-Alpha Collected in https://snap.stanford.edu/data., Bitcoin-OTC footnotemark: , WikiRfA footnotemark: , Slashdot Collected in https://www.aminer.cn. and Epinions footnotemark: . These datasets are regarded as undirected signed graphs, with their detailed statistics summarized in Table 1 and App. J.1. Competitive Methods. To the best of our knowledge, this work is the first to address the problem of differentially private signed graph learning while aiming to preserve model utility. Due to the absence of prior studies in this area, we construct baselines by integrating four state-of-the-art signed graph learning methods—SGCN (36), SiGAT (38), LSNE (37), and SDGNN (39) —with the DPSGD mechanism. Since these models primarily leverage structural information, we further include the private graph learning method GAP (40), using Truncated SVD-generated spectral features (36) as input to ensure a fair comparison involving node features. Evaluation Metrics. For edge sign prediction tasks, we follow the evaluation procedures in (14; 38; 39). Specifically, we first generate embedding vectors for all nodes in the training set using each comparative method. Then, we train a logistic regression classifier using the concatenated embeddings of node pairs as input features. Finally, we use the trained classifier to predict edge signs in the test set for each method. Considering the class imbalance between positive and negative edges (see Table 1), we adopt the area under curve (AUC) as the evaluation metric to ensure a fair comparison. For node clustering, to fairly evaluate the clustering effect of node embeddings, we compute the average cosine distance for both positive and negative node pairs: $\text{CD}^{+}=\sum_{(v_{i},v_{j})∈ E^{+}}Cos(\mathbf{Z}_{i},\mathbf{Z}_{j})/|E^{+}|$ and $\text{CD}^{-}=\sum_{(v_{n},v_{m})∈ E^{-}}Cos(\mathbf{Z}_{n},\mathbf{Z}_{m})/|E^{-}|$ , where $\mathbf{Z}_{i}$ is the node embedding generated by each comparative method, and $Cos(·)$ represents the cosine distance between node embeddings. Then we propose the symmetric separation index (SSI) to measure the clustering degree between the embeddings of positive and negative node pairs in the test set, denoted as $\text{SSI}=1/(|\text{CD}^{+}-1|+|\text{CD}^{-}+1|)$ . A higher SSI indicates better structural proximity, with positive node pairs more tightly clustered and negative pairs more clearly separated in the unified embedding space. Parameter Settings. For both edge sign prediction and node clustering tasks, we set the dimensionality of all node embeddings, $\mathbf{d}_{v}$ and $\mathbf{g}_{v}$ , to 128, following standard practice in prior work (41; 14). ASGL adopts DPSGD-based optimization, where the total number of training epochs is determined by the moments accountant (MA) (04), which offers tighter privacy tracking across multiple iterations. We set the iteration number $n^{iter}$ to 10 for Bitcoin-Alpha and Bitcoin-OTC, 15 for WikiRfA and Slashdot, and 20 for Epinions. Since all comparative methods are trained using DPSGD, their number of training epochs depends on the privacy budget. As discussed in Section 5.2, the maximum path number $N$ and path length $L$ are varied to analyze their impact on ASGL’s utility. For privacy parameters, we follow (02; 51; 08) by fixing $\delta=10^{-5}$ and $C=1$ , and vary the privacy budget $\epsilon∈\{1,2,...,6\}$ to evaluate utility under different privacy levels. To ensure fair comparison, we modify the official GitHub implementations of all baselines and adopt the best hyperparameter settings reported in their original papers. To minimize random errors, each experiment is repeated five times. 5.2. Impact of Key Parameters In this section, we perform experiments on two datasets by varying the maximum number $N$ and the maximum length $L$ of paths in the BFS-trees, providing a rationale for parameter selection. 5.2.1. The effect of the parameter $N$ As discussed in Section 4.3, the greater the number of neighbors a rooted node has, the more paths can be obtained through random walks. Therefore, the maximum number of paths $N$ also depends on the node degrees. As shown in Fig. 8 (see App. J.2), for the Bitcoin-Alpha and Slashdot datasets, most nodes in signed graphs have degrees below 3. In addition, we investigate the impact of $N$ by varying its value within $\{2,3,4,5,6\}$ . As shown by the average AUC results in Table 2, the proposed ASGL method achieves optimal edge prediction performance at $N=3$ for Bitcoin-Alpha and $N=4$ for Slashdot. Considering both gradient sensitivity and computational efficiency, we adopt $N=3$ for subsequent experiments. 5.2.2. The effect of the parameter $L$ In this experiment, we evaluate the impact of the path length $L$ on the utility of ASGL by varying its value. As shown in Table 3, ASGL achieves the best performance on both datasets when $L=4$ . This result is closely aligned with the structural characteristics of the signed graphs: As summarized in Fig. 9 (see App. J.2), most node pairs in these datasets exhibit maximum path lengths of 3 or 4. Therefore, in subsequent experiments, we set $L=4$ , as it adequately covers the receptive field of most nodes. Table 2. Summary of average AUC with different maximum path counts $N$ under $\epsilon=3$ and $L=3$ . (BOLD: Best) | Bitcoin-Alpha Slashdot | 0.8025 0.7723 | 0.8562 0.8823 | 0.8557 0.8888 | 0.8498 0.8871 | 0.8553 0.8881 | | --- | --- | --- | --- | --- | --- | Table 3. Summary of average AUC with different path lengths $L$ under $\epsilon=3$ and $N=3$ . (BOLD: Best) | Bitcoin-Alpha Slashdot | 0.7409 0.7629 | 0.8443 0.8290 | 0.8587 0.8833 | 0.8545 0.8809 | 0.8516 0.8807 | | --- | --- | --- | --- | --- | --- | <details> <summary>x5.png Details</summary>  ### Visual Description ## Multiple Line Charts: Performance Comparison of Graph Neural Networks ### Overview The image presents five line charts comparing the performance of different graph neural network (GNN) models across varying privacy budgets. Each chart corresponds to a different dataset: Bitcoin_Alpha, Bitcoin_OCT, WikiRfA, Slashdot, and Epinions. The performance metric is the Area Under the Curve (AUC), plotted against the privacy budget (epsilon). The GNN models compared are SDGNN, SiGAT, SGCN, GAP, LSNE, and ASGL (Proposed). ### Components/Axes * **Title:** Performance Comparison of Graph Neural Networks across different datasets. * **X-axis:** Privacy budget (epsilon). Scale: 1 to 6 in integer increments. * **Y-axis:** AUC (Area Under the Curve). Scale: 0.50 to 0.90 in increments of 0.05. * **Legend:** Located at the top of the image. * SDGNN: Gray line with circle markers. * SiGAT: Pink line with circle markers. * SGCN: Blue line with circle markers. * GAP: Green line with square markers. * LSNE: Yellow line with diamond markers. * ASGL (Proposed): Red line with triangle markers. * **Chart Titles:** * (a) Bitcoin\_Alpha * (b) Bitcoin\_OCT * (c) WikiRfA * (d) Slashdot * (e) Epinions ### Detailed Analysis #### (a) Bitcoin\_Alpha * **SDGNN (Gray):** Starts at approximately 0.68 AUC at privacy budget 1, gradually increases to approximately 0.78 at privacy budget 6. * **SiGAT (Pink):** Starts at approximately 0.72 AUC at privacy budget 1, gradually increases to approximately 0.80 at privacy budget 6. * **SGCN (Blue):** Starts at approximately 0.52 AUC at privacy budget 1, increases to approximately 0.75 at privacy budget 6. * **GAP (Green):** Starts at approximately 0.57 AUC at privacy budget 1, gradually increases to approximately 0.75 at privacy budget 6. * **LSNE (Yellow):** Starts at approximately 0.51 AUC at privacy budget 1, gradually increases to approximately 0.75 at privacy budget 6. * **ASGL (Proposed) (Red):** Starts at approximately 0.77 AUC at privacy budget 1, increases to approximately 0.86 at privacy budget 6. #### (b) Bitcoin\_OCT * **SDGNN (Gray):** Starts at approximately 0.78 AUC at privacy budget 1, gradually increases to approximately 0.82 at privacy budget 6. * **SiGAT (Pink):** Starts at approximately 0.75 AUC at privacy budget 1, gradually increases to approximately 0.88 at privacy budget 6. * **SGCN (Blue):** Starts at approximately 0.57 AUC at privacy budget 1, increases to approximately 0.77 at privacy budget 6. * **GAP (Green):** Starts at approximately 0.56 AUC at privacy budget 1, gradually increases to approximately 0.68 at privacy budget 6. * **LSNE (Yellow):** Starts at approximately 0.52 AUC at privacy budget 1, gradually increases to approximately 0.86 at privacy budget 6. * **ASGL (Proposed) (Red):** Starts at approximately 0.80 AUC at privacy budget 1, increases to approximately 0.88 at privacy budget 6. #### (c) WikiRfA * **SDGNN (Gray):** Starts at approximately 0.72 AUC at privacy budget 1, gradually increases to approximately 0.82 at privacy budget 6. * **SiGAT (Pink):** Starts at approximately 0.75 AUC at privacy budget 1, gradually increases to approximately 0.85 at privacy budget 6. * **SGCN (Blue):** Starts at approximately 0.68 AUC at privacy budget 1, increases to approximately 0.85 at privacy budget 6. * **GAP (Green):** Starts at approximately 0.55 AUC at privacy budget 1, gradually increases to approximately 0.60 at privacy budget 6. * **LSNE (Yellow):** Starts at approximately 0.68 AUC at privacy budget 1, gradually increases to approximately 0.80 at privacy budget 6. * **ASGL (Proposed) (Red):** Starts at approximately 0.78 AUC at privacy budget 1, increases to approximately 0.85 at privacy budget 6. #### (d) Slashdot * **SDGNN (Gray):** Starts at approximately 0.60 AUC at privacy budget 1, gradually increases to approximately 0.80 at privacy budget 6. * **SiGAT (Pink):** Starts at approximately 0.78 AUC at privacy budget 1, gradually increases to approximately 0.88 at privacy budget 6. * **SGCN (Blue):** Starts at approximately 0.60 AUC at privacy budget 1, increases to approximately 0.78 at privacy budget 6. * **GAP (Green):** Starts at approximately 0.60 AUC at privacy budget 1, gradually increases to approximately 0.72 at privacy budget 6. * **LSNE (Yellow):** Starts at approximately 0.68 AUC at privacy budget 1, gradually increases to approximately 0.82 at privacy budget 6. * **ASGL (Proposed) (Red):** Starts at approximately 0.70 AUC at privacy budget 1, increases to approximately 0.88 at privacy budget 6. #### (e) Epinions * **SDGNN (Gray):** Starts at approximately 0.68 AUC at privacy budget 1, gradually increases to approximately 0.82 at privacy budget 6. * **SiGAT (Pink):** Starts at approximately 0.68 AUC at privacy budget 1, gradually increases to approximately 0.88 at privacy budget 6. * **SGCN (Blue):** Starts at approximately 0.58 AUC at privacy budget 1, increases to approximately 0.82 at privacy budget 6. * **GAP (Green):** Starts at approximately 0.58 AUC at privacy budget 1, gradually increases to approximately 0.72 at privacy budget 6. * **LSNE (Yellow):** Starts at approximately 0.70 AUC at privacy budget 1, gradually increases to approximately 0.80 at privacy budget 6. * **ASGL (Proposed) (Red):** Starts at approximately 0.72 AUC at privacy budget 1, increases to approximately 0.88 at privacy budget 6. ### Key Observations * **ASGL (Proposed)** generally performs well across all datasets, often achieving the highest AUC values. * **GAP** consistently shows the lowest performance among the compared models. * The performance of all models generally improves as the privacy budget (epsilon) increases. * The relative performance of the models varies across different datasets. ### Interpretation The charts demonstrate the trade-off between privacy and utility (performance) in graph neural networks. As the privacy budget (epsilon) increases, the models generally achieve higher AUC scores, indicating better performance. However, higher epsilon values also imply weaker privacy guarantees. The ASGL (Proposed) model appears to strike a good balance between privacy and utility, consistently achieving high AUC scores across different datasets. The GAP model, on the other hand, consistently underperforms compared to the other models. The choice of the best model depends on the specific dataset and the desired trade-off between privacy and performance. </details> Figure 5. AUC vs. Privacy cost ( $\epsilon$ ) of private signed graph learning methods in edge sign prediction. <details> <summary>x6.png Details</summary>  ### Visual Description ## Bar Charts: SSI Comparison of Different Algorithms on Various Datasets ### Overview The image contains five bar charts comparing the SSI (likely a similarity score) achieved by different graph neural network algorithms on five different datasets: Bitcoin_Alpha, Bitcoin_OCT, WikiRfA, Slashdot, and Epinions. Each chart shows the SSI values for different algorithms (SGCN, SDGNN, SiGAT, LSNE, GAP, and ASGL) at different values of 'c' (c=1, c=2, c=4). ### Components/Axes * **Legend (Top):** * SGCN: Blue with dense diagonal lines from top-left to bottom-right * SDGNN: Light green with sparse diagonal lines from top-left to bottom-right * SiGAT: Light pink with horizontal lines * LSNE: Light yellow with dots * GAP: Purple with dense diagonal lines from top-right to bottom-left * ASGL: Red with sparse diagonal lines from top-right to bottom-left * **Y-axis:** SSI (Similarity Score Index). The scale varies between charts. * (a) Bitcoin\_Alpha: 0.40 to 0.70 * (b) Bitcoin\_OCT: 0.40 to 0.80 * (c) WikiRfA: 0.450 to 0.600 * (d) Slashdot: 0.450 to 0.600 * (e) Epinions: 0.45 to 0.70 * **X-axis:** 'c' values (c=1, c=2, c=4) * **Chart Titles:** * (a) Bitcoin\_Alpha * (b) Bitcoin\_OCT * (c) WikiRfA * (d) Slashdot * (e) Epinions ### Detailed Analysis **Chart (a) Bitcoin\_Alpha:** * **Trend:** Generally, SSI increases as 'c' increases. ASGL consistently has the highest SSI. * c=1: * SGCN: ~0.43 * SDGNN: ~0.48 * SiGAT: ~0.45 * LSNE: ~0.49 * GAP: ~0.48 * ASGL: ~0.50 * c=2: * SGCN: ~0.44 * SDGNN: ~0.49 * SiGAT: ~0.46 * LSNE: ~0.50 * GAP: ~0.49 * ASGL: ~0.51 * c=4: * SGCN: ~0.50 * SDGNN: ~0.54 * SiGAT: ~0.51 * LSNE: ~0.67 * GAP: ~0.65 * ASGL: ~0.69 **Chart (b) Bitcoin\_OCT:** * **Trend:** SSI generally increases with 'c'. ASGL performs best. * c=1: * SGCN: ~0.45 * SDGNN: ~0.50 * SiGAT: ~0.47 * LSNE: ~0.51 * GAP: ~0.50 * ASGL: ~0.52 * c=2: * SGCN: ~0.46 * SDGNN: ~0.51 * SiGAT: ~0.48 * LSNE: ~0.52 * GAP: ~0.51 * ASGL: ~0.62 * c=4: * SGCN: ~0.48 * SDGNN: ~0.53 * SiGAT: ~0.50 * LSNE: ~0.68 * GAP: ~0.66 * ASGL: ~0.78 **Chart (c) WikiRfA:** * **Trend:** SSI increases with 'c'. ASGL and LSNE show the highest values. * c=1: * SGCN: ~0.47 * SDGNN: ~0.50 * SiGAT: ~0.49 * LSNE: ~0.50 * GAP: ~0.49 * ASGL: ~0.51 * c=2: * SGCN: ~0.48 * SDGNN: ~0.51 * SiGAT: ~0.50 * LSNE: ~0.52 * GAP: ~0.51 * ASGL: ~0.55 * c=4: * SGCN: ~0.49 * SDGNN: ~0.53 * SiGAT: ~0.52 * LSNE: ~0.57 * GAP: ~0.55 * ASGL: ~0.59 **Chart (d) Slashdot:** * **Trend:** SSI increases with 'c'. ASGL and LSNE perform best. * c=1: * SGCN: ~0.47 * SDGNN: ~0.50 * SiGAT: ~0.48 * LSNE: ~0.50 * GAP: ~0.49 * ASGL: ~0.51 * c=2: * SGCN: ~0.47 * SDGNN: ~0.49 * SiGAT: ~0.48 * LSNE: ~0.51 * GAP: ~0.50 * ASGL: ~0.53 * c=4: * SGCN: ~0.48 * SDGNN: ~0.55 * SiGAT: ~0.53 * LSNE: ~0.58 * GAP: ~0.56 * ASGL: ~0.59 **Chart (e) Epinions:** * **Trend:** SSI increases with 'c'. ASGL and LSNE perform best. * c=1: * SGCN: ~0.49 * SDGNN: ~0.50 * SiGAT: ~0.48 * LSNE: ~0.50 * GAP: ~0.49 * ASGL: ~0.51 * c=2: * SGCN: ~0.50 * SDGNN: ~0.51 * SiGAT: ~0.49 * LSNE: ~0.51 * GAP: ~0.50 * ASGL: ~0.61 * c=4: * SGCN: ~0.51 * SDGNN: ~0.52 * SiGAT: ~0.50 * LSNE: ~0.67 * GAP: ~0.65 * ASGL: ~0.69 ### Key Observations * ASGL consistently achieves high SSI values across all datasets and 'c' values. * LSNE also performs well, especially at higher 'c' values. * The SSI generally increases as the value of 'c' increases, suggesting that a larger 'c' value may improve the performance of these algorithms. * The performance of SGCN and SDGNN is generally lower compared to ASGL and LSNE. ### Interpretation The charts demonstrate a comparison of different graph neural network algorithms based on their SSI scores on various datasets. The results suggest that ASGL and LSNE are generally more effective in capturing similarity information within these datasets, particularly as the parameter 'c' increases. The parameter 'c' likely represents a neighborhood size or a similar concept, and the increasing SSI with 'c' suggests that considering larger neighborhoods improves the performance of these algorithms. The choice of algorithm and the value of 'c' should be carefully considered based on the specific dataset and application. </details> Figure 6. Symmetric separation index (SSI) vs. Privacy cost ( $\epsilon$ ) of private signed graph learning methods in node clustering. 5.3. Impact of Privacy Budget on Edge Sign Prediction To evaluate the effectiveness of different private graph learning methods on edge sign prediction, we compare their AUC scores under privacy budgets $\epsilon$ ranging from 1 to 6, as shown in Fig. 5 and Table 6 (see App. J.3). The proposed ASGL consistently outperforms all baselines across all privacy levels and datasets, owing to its ability to generate node embeddings that preserve connectivity distributions while satisfying DP guarantees. Although SDGNN achieves sub-optimal performance, it exhibits a noticeable gap from ASGL under limited privacy budgets ( $\epsilon<4$ ). SiGAT, SGCN, and LSNE employ the moments accountant (MA) to mitigate excessive privacy budget consumption, yet still suffer from poor convergence and degraded utility under limited privacy budgets. GAP adopts aggregation perturbation to ensure node-level DP, but its performance is limited due to noisy neighborhood information, hindering its ability to capture structural information for edge prediction tasks. 5.4. Impact of Privacy Budget on Node Cluster To further examine the capability of ASGL in preserving signed node proximity, we conduct a fair comparison across multiple private graph learning methods using the SSI metric. As shown in Fig. 6 and Table 7 (see App. J.4), ASGL consistently outperforms all baselines across different datasets and privacy budgets, demonstrating that ASGL is capable of generating node embeddings that effectively preserve signed node proximity. Notably, GAP achieves the second-best clustering performance on most datasets (excluding Slashdot), benefiting from its ability to leverage node features for clustering nodes. Nevertheless, to guarantee node-level DP, GAP needs to repeatedly query sensitive graph information in every training iteration, resulting in significantly higher privacy costs. 5.5. Resilience Against Link Stealing Attack To assess the effectiveness of ASGL in preserving the privacy of edge information, we perform link stealing attacks (LSA) across all datasets and compare the resilience of all methods to such attacks in edge sign prediction tasks. The LSA setup is detailed in App. J.5. Attack performance is measured by the AUC score, averaged over five independent runs. Table 4 summarizes the effectiveness of LSA on various trained target models and datasets. It can be observed that as the privacy budget $\epsilon$ increases, the average AUC of LSA consistently improves, indicating the reduced privacy protection of target models and an increased success rate of the attack. Overall, the average AUC of the attack is close to 0.50 in most cases, indicating the unsuccessful edge inference and the robustness of DP against such an attack. When $\epsilon=3$ , ASGL demonstrates stronger resistance to LSA across most datasets, with AUC values consistently below 0.57. This suggests that ASGL offers defense performance comparable to other differentially private graph learning methods. Table 4. The average AUC of LSA on different comparisons and datasets. (BOLD: Best resilience against LSA) | 1 | Bitcoin-Alpha | 0.5072 | 0.7091 | 0.5079 | 0.5145 | 0.5404 | 0.5053 | | --- | --- | --- | --- | --- | --- | --- | --- | | Bitcoin-OTC | 0.5081 | 0.7118 | 0.5119 | 0.5409 | 0.5660 | 0.5466 | | | Slashdot | 0.5538 | 0.8232 | 0.5551 | 0.5609 | 0.5460 | 0.5325 | | | WikiRfA | 0.5148 | 0.5424 | 0.5427 | 0.5293 | 0.5470 | 0.5302 | | | Epinions | 0.7877 | 0.6329 | 0.5114 | 0.5129 | 0.5188 | 0.5092 | | | 3 | Bitcoin-Alpha | 0.5547 | 0.7514 | 0.5533 | 0.5542 | 0.5598 | 0.5430 | | Bitcoin-OTC | 0.5655 | 0.7273 | 0.5684 | 0.5734 | 0.5765 | 0.5612 | | | Slashdot | 0.5742 | 0.8394 | 0.6267 | 0.5730 | 0.6464 | 0.5634 | | | WikiRfA | 0.5276 | 0.5466 | 0.5542 | 0.5696 | 0.5772 | 0.5624 | | | Epinions | 0.7981 | 0.6456 | 0.5588 | 0.5629 | 0.5665 | 0.5542 | | 6. Related Work Signed graph learning. In recent years, deep learning approaches have been increasingly adopted for signed graph learning. For example, SiNE (47) extracts signed structural information based on balance theory and designs an objective function to learn signed node proximity. Furthermore, the GNN model (36) and its variants (38; 39) are used to learn signed relationships between nodes in multi-hop neighborhoods. However, these GNNs-based methods depend on the message-passing mechanism, which is sensitive to noisy interactions between nodes (49). To address this issue, Lee et al. (14) extends the adversarial framework to signed graphs by generating both positive and negative node embeddings. Still, these signed graph learning models are vulnerable to user-linkage attacks. Private graph learning. Recent works have increasingly focused on developing DP methods to address privacy leakage in GNNs. For instance, Daigavane et al. (33) propose a DP-GNN method based on gradient perturbation. However, this method fails to balance utility and privacy due to excessive noise. Furthermore, GAP (40) and DPRA (50) are proposed to ensure the privacy of sensitive node embeddings by perturbing node aggregations. Despite their success in node classification, the private node information is repeatedly queried in the training process of GAP, which consumes more privacy budgets to implement DPSGD. DPRA is not well-suited for signed graph embedding learning, as its edge perturbation strategy introduces cascading errors under balance theory. 7. Conclusion In this paper, we propose ASGL that achieves strong model utility while providing node-level DP guarantees. To address the cascading error and gradient polarity reversals from edge sign flips, ASGL separately processes positive and negative subgraphs within a shared embedding space using a DPSGD-based adversarial mechanism to learn high-quality node embeddings. To further reduce gradient sensitivity, we introduce a constrained BFS-tree strategy that limits node receptive fields and enables gradient decoupling. This effectively reduces the required noise scale and enhances model performance. Extensive experiments demonstrate that ASGL achieves a favorable privacy-utility trade-off. Our future work is to extend the ASGL framework by considering edge directions and weights. Acknowledgements. This work was supported by the National Natural Science Foundation of China (Grant No: 62372122 and 92270123), and the Research Grants Council (Grant No: 15208923, 25207224, and 15207725), Hong Kong SAR, China. Appendix A Adversarial Learning on Graph The adversarial learning model for graph embedding (03) is illustrated as follows. Let $\mathcal{N}(v_{r})$ be the node set directly connected to $v_{r}$ . We denote the underlying true connectivity distribution of node $v_{r}$ as the conditional probability $p(v|v_{r})$ , which captures the preference of $v_{r}$ to connect with other nodes $v∈ V$ . In other words, the neighbor set $\mathcal{N}(v_{r})$ can be interpreted as a set of observed nodes drawn from $p(v|v_{r})$ . The adversarial learning for the graph $\mathcal{G}$ is conducted by the following two modules: Generator $G$ : Through optimizing the generator parameters $\theta_{G}$ , this module aims to approximate the underlying true connectivity distribution and generate (or select) the most likely nodes $v∈ V$ that are relevant to $v_{r}$ . Specifically, the fake The term “Fake” indicates that although a node $v$ selected by the generator is relevant to $v_{r}$ , there is no actual edge between them. (i.e., estimated) connectivity distribution of node $v_{r}$ is calculated as: $$ p^{\prime}(v|v_{r})=G\left(v|v_{r};\theta_{G}\right)=\frac{\exp\left(\mathbf{g}_{v}^{\top}\mathbf{g}_{v_{r}}\right)}{\sum_{v\neq v_{r}}\exp\left(\mathbf{g}_{v}^{\top}\mathbf{g}_{v_{r}}\right)}, \tag{18} $$ where $\mathbf{g}_{v},\mathbf{g}_{v_{r}}∈\mathbb{R}^{k}$ are the $k$ -dimensional vectors of nodes $v$ and $v_{r}$ , respectively, and $\theta_{G}$ is the union of all $\mathbf{g}_{v}$ ’s. To update $\theta_{G}$ in each iteration, a set of node pairs $(v,v_{r})$ , not necessarily directly connected, is sampled according to $p^{\prime}(v|v_{r})$ . The key purpose of generator $G$ is to deceive the discriminator $D$ , and thus its loss function $L_{G}$ is determined as follows: $$ \displaystyle L_{G}=\min\sum_{r=1}^{|V|}\left.\mathbb{E}_{v\sim G\left(\cdot\mid v_{r};\theta_{G}\right)}\left[\log\left(1-D\left(v_{r},v\mid\theta_{D}\right)\right)\right]\right., \tag{19} $$ where the discriminant function $D(·)$ estimates the probability that a given node pairs $(v,v_{r})$ are considered real, i.e., directly connected. Discriminator $D$ : This module tries to distinguish between real node pairs and fake node pairs synthesized by the generator $G$ . Accordingly, the discriminator estimates the probability that an edge exists between $v_{r}$ and $v$ , denoted as: $$ D(v_{r},v|\theta_{D})=\sigma(\mathbf{d}_{v}^{\top}\mathbf{d}_{v_{r}})=\frac{1}{1+\exp({-\mathbf{d}_{v}^{\top}\mathbf{d}_{v_{r}})}}, \tag{20} $$ where $\mathbf{d}_{v},\mathbf{d}_{v_{r}}∈\mathbb{R}^{k}$ are the $k$ -dimensional vectors corresponding to the $v$ -th and $v_{r}$ -th rows of discriminator parameters $\theta_{D}$ , respectively. $\sigma(·)$ represents the sigmoid function of the inner product of these two vectors. Given the sets of real and fake node pairs, the loss function of $D$ can be derived as: $$ \displaystyle L_{D}= \displaystyle\max\sum_{r=1}^{|V|}\left(\mathbb{E}_{v\sim p\left(\cdot\mid v_{r}\right)}\left[\log D\left(v,v_{r}\mid\theta_{D}\right)\right]\right. \displaystyle\left.+\mathbb{E}_{v\sim G\left(\cdot\mid v_{r};\theta_{G}\right)}\left[\log\left(1-D\left(v_{r},v\mid\theta_{D}\right)\right)\right]\right). \tag{21} $$ In summary, the generator $G$ and discriminator $D$ operate as two adversarial components: the generator $G$ aims to fit the true connectivity distribution $p(v|v_{r})$ , generating candidate nodes $v$ that resemble the real neighbors of $v_{r}$ to deceive the discriminator $D$ . In contrast, the discriminator $D$ seeks to distinguish whether a given node is a true neighbor of $v_{r}$ or one generated by $G$ . Formally, $D$ and $G$ are engaged in a two-player minimax game with the following loss function: $$ \displaystyle\min_{\theta_{G}} \displaystyle\max_{\theta_{D}}L(G,D)=\sum_{r=1}^{|V|}\left(\mathbb{E}_{v\sim p\left(\cdot\mid v_{r}\right)}\left[\log D\left(v,v_{r}\mid\theta_{D}\right)\right]\right. \displaystyle\left.+\mathbb{E}_{v\sim G\left(\cdot\mid v_{r};\theta_{G}\right)}\left[\log\left(1-D\left(v_{r},v\mid\theta_{D}\right)\right)\right]\right). \tag{22} $$ Based on Eq. (22), the parameters $\theta_{D}$ and $\theta_{G}$ are updated by alternately maximizing and minimizing the loss function $L(G,D)$ . Competition between $G$ and $D$ results in mutual improvement until $G$ becomes indistinguishable from the true connectivity distribution. Appendix B Notation Introduction The frequently used notations are summarized in Table 5. Table 5. Notation Summary | $\mathcal{G},\mathcal{G^{+}},\mathcal{G^{-}}$ $V,E^{+},E^{-}$ $\mathcal{N}(v_{r})$ | Signed graph, positive subgraph, negative subgraph Node set, negative and positive edge sets Neighbor node set of node $v_{r}$ | | --- | --- | | $\theta_{D}$ | Shared parameters of discriminators $D^{+}$ and $D^{-}$ | | $\theta_{G}$ | Shared parameters of generators $G^{+}$ and $G^{-}$ | | $\mathbf{d}_{v_{r}}$ | Node embedding for node $v_{r}$ of Discriminators | | $\mathbf{g}_{v_{r}}$ | Node embedding for node $v_{r}$ of Generators | | $N,L$ | Maximum number and length of generated path | | $\epsilon,\delta$ | Privacy parameters | | $\mathcal{N}(0,\sigma^{2})$ | Gaussian distribution with standard deviation $\sigma^{2}$ | | $P_{rt}$ | A path from rooted node $v_{r}$ to target node $v_{t}$ | | $T^{+}_{v_{r}},T^{-}_{v_{r}}$ | Positive and negative BFS-trees rooted from $v_{r}$ | | $p_{\text{true}}^{+}(·|v_{r})$ | Positive connectivity distributions of $(v_{r},v)∈ E^{+}$ | | $p_{\text{true}}^{-}(·|v_{r})$ | Negative connectivity distributions of $(v_{r},v)∈ E^{-}$ | | $p^{+}_{T^{+}_{v_{r}}}(v|v_{r})$ | Positive relevance probability between $v_{r}$ and $v$ | | $p^{-}_{T^{-}_{v_{r}}}(v|v_{r})$ | Negative relevance probability between $v_{r}$ and $v$ | Appendix C Rényi Differential Privacy Since standard DP can be overly strict for deep learning, we follow prior work (30; 31) and adopt an alternative definition—Rényi Differential Privacy (RDP) (07). RDP offers tighter and more efficient composition bounds, enabling more accurate estimation of cumulative privacy cost over multiple queries on graphs. **Definition 0 (Rényi Differential Privacy(07))** *The Rényi divergence quantifies the similarity between output distributions of a mechanism and is defined as: $$ D_{\alpha}(P\|Q)=\frac{1}{\alpha-1}\log\left(\sum_{x}P(x)^{\alpha}Q(x)^{1-\alpha}\right), \tag{23} $$ where $P(x)$ and $Q(x)$ are probability distributions over the output space. $\alpha>1$ denotes the order of the divergence, and its choice allows for different levels of sensitivity to the output distribution. Accordingly, an algorithm $\mathcal{M}$ satisfies $(\alpha,\epsilon)$ -RDP if, for any two adjacent graphs $\mathcal{G}$ and $\mathcal{G}^{\prime}$ , the following condition holds $D_{\alpha}\left(\mathcal{M}(\mathcal{G})\|\mathcal{M}\left(\mathcal{G}^{\prime}\right)\right)≤\epsilon$ .* Since RDP is an extension of DP, it can be converted into ( $\epsilon$ , $\delta$ )-DP based on Proposition 3 in (07), as outlined below. **Lemma 0 (Conversion from RDP to DP(07))** *If a mechanism $\mathcal{M}$ satisfies $(\alpha,\epsilon)$ -RDP, it also satisfies $(\epsilon+\log(1/\delta)/(\alpha-1),\delta)$ -DP for any $\delta∈(0,1)$ .* Appendix D Gaussian Mechanism Let $f$ be a function that maps a graph $\mathcal{G}$ to $k$ -dimensional node vectors $\mathbf{Z}∈\mathbb{R}^{|V|× k}$ . To ensure the RDP guarantees of $f$ , it is common to inject Gaussian noise into its output (07). The noise scale depends on the sensitivity of $f$ , defined as $\Delta_{f}=\max_{\mathcal{G},\mathcal{G}^{\prime}}\left\|f(\mathcal{G})-f\left(\mathcal{G}^{\prime}\right)\right\|_{2}$ . Specifically, the privatized mechanism is defined as $\mathcal{M}(\mathcal{G})=f(\mathcal{G})+\mathcal{N}(0,\sigma^{2}\mathbf{I})$ , where $\mathcal{N}(0,\sigma^{2}\mathbf{I})$ is the Gaussian distribution with zero mean and standard deviation $\sigma^{2}$ . This results in an $(\alpha,\epsilon)$ -RDP mechanism $\mathcal{M}$ for all $\alpha>1$ with $\epsilon=\alpha\Delta_{f}^{2}/2\sigma^{2}$ . Input: Graph $\mathcal{G}=\{\mathcal{G}^{+},\mathcal{G}^{-}\}$ ; The training set of nodes $V_{tr}$ ; The maximum path length $L$ ; The maximum path number $N$ . Output: The training set of subgraphs $S_{tr}$ . 1 for $v_{r}∈ V_{tr}$ do 2 Construct BFS-trees $T^{+}_{v_{r}}$ (or $T^{-}_{v_{r}}$ ) rooted from the node $v_{r}$ on $\mathcal{G}^{+}$ (or $\mathcal{G}^{-}$ ); 3 for $n=0;n<N$ do 4 Based on the positive and negative relevance probability in Eqs. (6) and (7), conduct the random walk at $T^{+}_{v_{r}}$ (or $T^{-}_{v_{r}}$ ) to form a path $P_{rt}^{(n)+}$ (or $P_{rt}^{(n)-}$ ) of length $L$ ; 5 Add all nodes $v$ (excluding those in $\mathcal{N}(v_{r})$ ) along the path $P_{rt}^{(n)+}$ (or $P_{rt}^{(n)-}$ ) as a fake edge $(v_{r},v)$ to the corresponding subgraph set $S_{tr}^{+}$ (or $S_{tr}^{-}$ ); 6 Drop $P_{rt}^{(n)+}$ (or $P_{rt}^{(n)-}$ ) from $T^{+}_{v_{r}}$ (or $T^{-}_{v_{r}}$ ). 7 end for 8 9 end for Return $S_{tr}=\{S_{tr}^{+},S_{tr}^{-}\}$ ; Algorithm 1 SAMPLE-SUBGRAPHS by Constrained BFS-trees Appendix E BFS-tree Strategy Fig. 7 provides an illustrative example of the BFS-tree strategy: Let $v_{r_{0}}$ be the rooted node. We first compute the transition probabilities between $v_{r_{0}}$ and its neighbors $\mathcal{N}({v_{r_{0}}})$ . The next node $v_{r_{1}}$ is then sampled as the first step of the walk, in proportion to these transition probabilities. Similarly, the next node $v_{r_{2}}$ is selected based on the transition probabilities between $v_{r_{1}}$ and its neighbors $\mathcal{N}({v_{r_{1}}})$ . The random walk continues until it reaches the terminal node $v_{r_{n}}$ , and unconnected node pairs $(v_{r_{0}},v_{r_{k}})^{+}$ for $k=2,3,...,n$ are regarded as fake positive edges. <details> <summary>x7.png Details</summary>  ### Visual Description ## Graph Transformation Diagram: BFS-Tree Construction ### Overview The image illustrates the transformation of an original graph into a BFS-tree through a series of node selections based on conditional probabilities. The diagram shows the initial graph and two subsequent stages of tree construction, highlighting the selection process with probability values assigned to potential edges. ### Components/Axes * **Nodes:** Represented as circles, some filled with a light red color to indicate selected nodes. * **Edges:** Solid lines represent existing connections in the graph or tree. Dashed red lines indicate potential edges with associated probabilities. * **Labels:** * `Original Graph G`: Label for the initial graph on the left. * `BFS-tree`: Text indicating the transformation process. * `Select v₁ based on pTvr(v₁ | vr₀) = 0.6`: Label for the middle graph, indicating the selection of node v₁ based on the given conditional probability. * `Select v₂ based on pTvr(v₂ | vr₁) = 0.5`: Label for the rightmost graph, indicating the selection of node v₂ based on the given conditional probability. * `vr₀`, `vr₁`, `vr₂`: Node labels. ### Detailed Analysis **1. Original Graph G (Left)** * A complex graph with approximately 10 nodes and multiple edges. * One node, labeled `vr₀`, is highlighted in light red. **2. BFS-tree Transformation (Middle)** * The graph is transformed into a tree structure. * Node `vr₀` (light red) is the root. * Node `vr₁` is selected based on the conditional probability `pTvr(v₁ | vr₀) = 0.6`. * Probabilities are assigned to potential edges from `vr₀`: * Edge to `vr₁`: 0.6 (solid red arrow) * Two other potential edges (dashed red arrows) with probabilities 0.1 and 0.3. **3. Further BFS-tree Construction (Right)** * The tree structure is further developed. * Node `vr₂` is selected based on the conditional probability `pTvr(v₂ | vr₁) = 0.5`. * Probabilities are assigned to potential edges from `vr₁`: * Edge to `vr₂`: 0.5 (solid red arrow) * Two other potential edges (dashed red arrows) with probabilities 0.2 and 0.3. ### Key Observations * The diagram illustrates a step-by-step process of building a BFS-tree from an original graph. * Node selection is based on conditional probabilities, influencing the tree's structure. * The probabilities associated with potential edges suggest a probabilistic approach to tree construction. ### Interpretation The diagram demonstrates a method for constructing a Breadth-First Search (BFS) tree from an arbitrary graph. The process involves selecting nodes based on conditional probabilities, which likely represent the likelihood of traversing from one node to another in the original graph. The probabilities guide the formation of the tree, potentially optimizing for certain criteria or reflecting underlying relationships within the original graph structure. The use of conditional probabilities suggests a stochastic or weighted approach to BFS tree construction, deviating from the standard deterministic algorithm. The values 0.6 and 0.5 represent the probabilities of selecting `v₁` given `v₀` and `v₂` given `v₁` respectively, indicating a preference or higher likelihood for those specific connections during the tree-building process. </details> Figure 7. Random-walk-based edge generation for generator $G^{+}$ or $G^{-}$ . Red digits denote the transition probabilities (Eqs. (6) and (7)), and red arrows indicate the walk directions. Appendix F Details of Algorithm F.1. The Parameter Update of Generators Given fake positive/negative edges $(v_{r},v_{t})$ from ${G}^{+}/{G}^{-}$ , the gradient of joint loss function (Eq. (10)) with respect to $\theta_{G}$ is derived via the policy gradient (03): $$ \nabla L_{G}=\left\{\begin{array}[]{l}\sum_{r=1}^{|V^{+}|}[\nabla_{\theta_{G}}\log G^{+}\left(v_{t}|v_{r};\theta_{G}\right)\log\left(1-D^{+}\left(v_{t},v_{r}\right)\right)],\\ \text{if }\left(v_{r},v_{t}\right)\text{ is a fake positive edge};\\ \sum_{r=1}^{|V^{-}|}\nabla_{\theta_{G}}\log G^{-}\left(v_{t}|v_{r};\theta_{G}\right)\log\left(1-D^{-}\left(v_{t},v_{r}\right)\right),\\ \text{if }\left(v_{r},v_{t}\right)\text{ is a fake negative edge}.\end{array}\right. \tag{24} $$ F.2. SAMPLE-SUBGRAPHS by Constrained BFS-trees As shown in Algorithm 1, during the random walk on the BFS tree $T^{+}_{v_{r}}$ or $T^{-}_{v_{r}}$ rooted at $v_{r}∈ V_{tr}$ , we generate multiple unique paths while constraining their number and length by parameters $N$ and $L$ , respectively. This process yields a training subgraph set $S_{tr}$ composed of constrained paths. Input: Graph $\mathcal{G}$ ; Training set of nodes $V_{tr}$ ; Maximum path length $L$ ; Maximum path number $N$ ; Batch-size $B_{d}$ and $B_{g}$ of sampled edges in discrininators and generators; Number of epochs $n^{epoch}$ ; Number of iterations for generators and discriminators per epoch $n^{iter}$ ; Privacy parameters $\delta$ , $\epsilon$ , $\sigma$ . Output: Privacy-preserving node embedding $\mathbf{g}_{v}∈\theta_{G}$ for downstream tasks. 1 According to edge signs, divide $\mathcal{G}$ into $\mathcal{G}^{+}$ and $\mathcal{G}^{-}$ ; 2 Generate the training subgraph set $S_{tr}=\{S_{tr}^{+},S_{tr}^{-}\}$ based on $\text{SAMPLE-SUBGRAPHS}(\mathcal{G},V_{tr},N,L)$ in Algorithm 1; 3 for $v_{r}∈ V_{tr}$ do 4 Sample all real positive edges $(v_{r},v_{t})^{+}$ from $\mathcal{G}^{+}$ ; 5 Sample all fake positive edges $(v_{r},v_{t}^{\prime})^{+}$ from $S_{tr}^{+}$ ; 6 Sample all real negative edges $(v_{r},v_{t})^{-}$ from $\mathcal{G}^{-}$ ; 7 Sample all fake negative edges $(v_{r},v_{t}^{\prime})^{-}$ from $S_{tr}^{-}$ ; 8 $E^{+}_{D}.add((v_{r},v_{t})^{+},(v_{r},v_{t}^{\prime})^{+})$ , $E^{+}_{G}.add((v_{r},v_{t}^{\prime})^{+})$ , 9 $E^{-}_{D}.add((v_{r},v_{t})^{-},(v_{r},v_{t}^{\prime})^{-})$ , $E^{-}_{G}.add((v_{r},v_{t}^{\prime})^{-})$ ; 10 11 end for 12 for $epoch=0;epoch<n^{epoch}$ do 13 Train the discriminator $D^{+}$ : 14 for $iter=0;iter<n^{iter}$ do 15 Sample $B_{d}$ real and fake positive edges from $E^{+}_{D}$ ; 16 Update $\theta_{D}$ via Eqs. (8) and (11), and achieve gradient perturbation via Eq. (13); 17 Calculate privacy spent $\hat{\delta}$ given the target $\epsilon$ ; 18 Stop optimization if $\hat{\delta}≥\delta$ . 19 end for 20 Train the generator $G^{+}$ : 21 for $iter=0;iter<n^{iter}$ do 22 Subsample $B_{g}$ fake positive edges from $E^{+}_{G}$ ; 23 Update $\theta_{G}$ via Eqs. (4) and (24). 24 end for 25 Train the discriminator $D^{-}$ : 26 for $iter=0;iter<n^{iter}$ do 27 Subsample $B_{d}$ real and fake negative edges from $E^{-}_{D}$ ; 28 Update $\theta_{D}$ via Eqs. (9) and (11), and achieve gradient perturbation via Eq. (13); 29 Calculate privacy spent $\hat{\delta}$ given the target $\epsilon$ ; 30 Stop optimization if $\hat{\delta}≥\delta$ . 31 end for 32 Train the generator $G^{-}$ : 33 for $iter=0;iter<n^{iter}$ do 34 Subsample $B_{g}$ fake negative edges from $E^{-}_{G}$ ; 35 Update $\theta_{G}$ via Eqs. (5) and (24). 36 end for 37 38 end for 39 Return privacy-preserving node embedding $\mathbf{g}_{v}∈\theta_{G}$ ; Algorithm 2 ASGL Algorithm F.3. The training of ASGL The training process of ASGL is outlined in Algorithm 2 and consists of the following main steps: (1) Signed graph decomposition and subgraph sampling: Given an input signed graph $\mathcal{G}$ , we first divide it into a positive subgraph $\mathcal{G}^{+}$ and a negative subgraph $\mathcal{G}^{-}$ based on edge signs. Then, for each node $v_{r}∈ V_{tr}$ , constrained BFS trees are constructed from $\mathcal{G}^{+}$ and $\mathcal{G}^{-}$ , respectively, to generate a set of training subgraphs $S_{tr}=\{S_{tr}^{+},S_{tr}^{-}\}$ by limiting the maximum number of paths $N$ and the maximum path length $L$ . These subgraphs are used to sample fake edges for adversarial training. (2) Edge sampling for adversarial learning: For each node $v_{r}$ , we sample real edges from $\mathcal{G}^{+}$ and $\mathcal{G}^{-}$ , and fake edges from $S_{tr}^{+}$ and $S_{tr}^{-}$ . These edges are organized into four sets: - $E_{D}^{+}$ : real and fake positive edges for training $D^{+}$ . - $E_{G}^{+}$ : fake positive edges for training $G^{+}$ . - $E_{D}^{-}$ : real and fake negative edges for training $D^{-}$ . - $E_{G}^{-}$ : fake negative edges for training $G^{-}$ . (3) Adversarial training with DPSGD: The training is performed over $n^{epoch}$ epochs. In each epoch: - Discriminator training: For each discriminator $D^{+}$ and $D^{-}$ , we perform $n^{iter}$ iterations. In each iteration, a batch of $B_{d}$ real and fake edges is sampled. The discriminator parameters $\theta_{D}$ are updated using gradient descent with noise addition according to the DPSGD mechanism (Eq. (13)), ensuring node-level DP. The privacy budget $\hat{\delta}$ is tracked, and training stops early if $\hat{\delta}>\delta$ . - Generator training: Each generator $G^{+}$ and $G^{-}$ is trained for $n^{iter}$ iterations. In each iteration, a batch of $B_{g}$ fake edges is sampled, and the generator parameters $\theta_{G}$ are updated by maximizing the generator objective (Eq. (24)). (4) Embedding output for downstream tasks: After all epochs, the generator parameters $\theta_{G}$ encode the privacy-preserving node embeddings $\mathbf{g}_{v}∈\theta_{G}$ , which are used for downstream tasks such as edge sign prediction and node clustering. Appendix G Details of Lemma The following lemmas are used for proving Theorem 1: **Lemma 0 (Receptive field of a node)** *As shown in Fig. 4 (b), we define the receptive field of a node as the region (i.e., the set of nodes) over which it can exert influence. Accordingly, for a subgraph constructed from paths sampled on constrained BFS-trees (Fig. 4 (b)), the maximum receptive field size of $v_{r}$ is given by $R_{N,L}=\sum_{l=0}^{L}N^{l}=\frac{N^{L+1}-1}{N-1}≤ B$ .* **Lemma 0** *Let $S_{tr}$ denote the training set of subgraphs constructed from constrained BFS-tree paths, and $S(v)⊂ S_{tr}$ denote the subgraph subset that contains the node $v$ . Since $R_{N,L}$ represents the upper bound on the number of occurrences of any node in $S_{tr}$ , it follows that $|S(v)|≤ R_{N,L}$ . The proof of Lemma 2 is illustrated in App. H.* Appendix H Proof of Lemma 2 Proof. We proceed by induction (13) on the path length $L$ of the BFS-tree. Base case: When $L=0$ , each sampled subgraph $S(v)$ contains exactly the training node $v∈ V_{tr}$ itself. Thus, every node appears in one subgraph, trivially satisfying the bound $|S(v)|=R_{N,0}=1$ . Inductive hypothesis: Assume that for some fixed $L≥ 0$ , any $v∈ V_{tr}$ appears in at most $R_{N,L}$ subgraphs constructed from constrained BFS-tree paths. Let $S^{L}(v)$ denote a subgraph set with $L$ path length. Thus, the hypothesis is $|S^{L}(v)|≤ R_{N,L}$ for any $v$ . Inductive step: We further show that the above hypothesis also holds for $L+1$ path length: Let $T_{u^{\prime}}$ represent the $L$ -length BFS-tree rooted at $u^{\prime}$ . If $T_{u^{\prime}}∈ S^{L+1}(v)$ , there must exit node $u$ such that $u∈ T_{u^{\prime}}$ and $T_{u}∈ S^{L}(v)$ . According to the setting of Algorithm 1, the number of such nodes $u$ is at most $N$ . By the hypothesis, there are at most $R_{N,L}-1$ such $u^{\prime}≠ v$ such that $T_{u^{\prime}}∈ S^{L+1}(v)$ . Based on these upper bounds, we can derive the upper bound matching the inductive hypothesis for $L+1$ : $$ \left|S^{L+1}(v)\right|\leq N\cdot(R_{N,L}-1)+1=\frac{N^{L+2}-1}{N-1}=R_{N,L+1}. \tag{25} $$ By induction, the Lemma 2 holds for all $L≥ 0$ . Appendix I Proof of Theorem 2 The following lemmas are used for proving Theorem 2: **Lemma 0 (Adaptation of Lemma 5 from(34))** *Let $\mathcal{N}(\mu,\sigma^{2})$ represent the Gaussian distribution with mean $\mu$ and standard deviation $\sigma^{2}$ , it holds that: $$ \mathcal{D}_{\alpha}\left(\mathcal{N}\left(\mu,\sigma^{2}\right)\|\mathcal{N}\left(0,\sigma^{2}\right)\right)=\frac{\alpha\mu^{2}}{2\sigma^{2}} \tag{26} $$* **Lemma 0 (Adaptation of Lemma 25 from(33))** *Assume $\mu_{0},...,\mu_{n}$ and $\eta_{0},...,\eta_{n}$ are probability distributions over some domain $Z$ such that their Rényi divergences satisfy: $\mathcal{D}_{\alpha}(\mu_{0}||\eta_{0})≤\epsilon_{0},...,\mathcal{D}_{\alpha}(\mu_{n}||\eta_{n})≤\epsilon_{n}$ for some given $\epsilon_{0},...,\epsilon_{n}$ . Let $\rho$ be a probability distribution over $\{0,...,n\}$ . Denoted by $\mu_{\rho}$ ( $\eta_{\rho}$ , respectively) the probability distribution on $Z$ obtained by sampling $i$ from $\rho$ and then randomly sampling from $\mu_{i}$ and $\eta_{i}$ , we have: $$ \mathcal{D}_{\alpha}\left(\mu_{\rho}\|\eta_{\rho}\right)\leq\ln\mathbb{E}_{i\sim\rho}\left[e^{\varepsilon_{i}(\alpha-1)}\right]=\frac{1}{\alpha-1}\ln\sum_{i=0}^{n}\rho_{i}e^{\varepsilon_{i}(\alpha-1)} \tag{27} $$* Proof of Theorem 2. Consider any minibatch $\mathcal{B}_{t}$ randomly sampled from the training subgraph set $S_{tr}$ of Algorithm 2 at iteration $t$ . For a subset $S(v^{*})⊂ S_{tr}$ containing node $v^{*}$ , its size is bounded by $R_{N,L}$ (Lemma 2). Define the random variable $\beta$ as $|S(v^{*})\cap\mathcal{B}_{t}|$ , and its distribution follows the hypergeometric distribution $\mathrm{Hypergeometric}(|S_{tr}|,R_{N,L},|\mathcal{B}_{t}|)$ (32): $$ \beta_{i}=P[\beta=i]\ext@arrow 0099\arrowfill@\Relbar\Relbar\Relbar{|S_{tr}|=N_{tr}}{|\mathcal{B}_{t}|=B_{d}}\frac{\binom{R_{N,L}}{i}\binom{N_{tr}-R_{N,L}}{B_{d}-i}}{\binom{N_{tr}}{B_{d}}}. \tag{28} $$ Next, consider the training of the discriminators (Lines 12–18 and 24–30 in Algorithm 2). Let $\mathcal{G}$ and $\mathcal{G}^{\prime}$ be two adjacent graphs differing only in the presence of node $v^{*}$ and its associated signed edges. Based on the gradient perturbation applied in Lines 15 and 27 of Algorithm 2, we have: $$ \displaystyle\tilde{{g}}_{t} \displaystyle={g}_{t}+\mathcal{N}\left(0,\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)=\sum_{v\in\mathcal{B}_{t}}\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v}})+\mathcal{N}\left(0,\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right) \displaystyle\tilde{{g}}^{\prime}_{t} \displaystyle={g}^{\prime}_{t}+\mathcal{N}\left(0,\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)=\sum_{v^{\prime}\in\mathcal{B}_{tr}^{\prime}}\text{Clip}_{C}(\frac{\partial L_{D}}{\partial\mathbf{d}_{v^{\prime}}})+\mathcal{N}\left(0,\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right), \tag{29} $$ where $\Delta_{{g}}=R_{N,L}C=\frac{N^{L+1}-1}{N-1}C$ (Theorem 1). $\tilde{{g}}_{t}$ and $\tilde{{g}}^{\prime}_{t}$ denote the noisy gradients of $\mathcal{G}$ and $\mathcal{G}^{\prime}$ , respectively. When $\beta=i$ , their Rényi divergences can be upper bounded as: $$ \displaystyle\mathcal{D}_{\alpha} \displaystyle\left(\tilde{{g}}_{t,i}\|\tilde{{g}}_{t,i}^{\prime}\right) \displaystyle=\mathcal{D}_{\alpha}\left({g}_{t,i}+\mathcal{N}\left(0,\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)\|{g}_{t,i}^{\prime}+\mathcal{N}\left(0,\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)\right) \displaystyle=\mathcal{D}_{\alpha}\left(\mathcal{N}\left({{g}}_{t,i},\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)\|\mathcal{N}\left({{g}^{\prime}}{}_{t,i},\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)\right) \displaystyle\stackrel{{\scriptstyle(a)}}{{=}}\mathcal{D}_{\alpha}\left(\mathcal{N}\left(\left({{g}}_{t,i}-{{g}}_{t,i}^{\prime}\right),\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)\|\mathcal{N}\left(0,\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)\right) \displaystyle\stackrel{{\scriptstyle(b)}}{{\leq}}\sup_{\|{\Delta_{i}}\|_{2}\leq iC}\mathcal{D}\left(\mathcal{N}\left(\Delta_{i},\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)\|\mathcal{N}\left(0,\sigma^{2}\Delta_{{g}}^{2}\mathbf{I}\right)\right) \displaystyle\stackrel{{\scriptstyle(c)}}{{=}}\sup_{\|\Delta_{i}\|_{2}\leq iC}\frac{\alpha\|\Delta_{i}\|_{2}^{2}}{2\Delta_{{g}}^{2}\sigma^{2}}=\frac{\alpha i^{2}}{2R_{N,L}^{2}\sigma^{2}}, \tag{30} $$ where $\Delta_{i}={{g}}_{t,i}-{{g}}_{t,i}^{\prime}$ . (a) leverages the property that Rényi divergence remains unchanged under invertible transformations (34), while (b) and (c) are derived from Theorem 1 and Lemma 1, respectively. Based on Lemma 2 , we derive that: $$ \displaystyle\mathcal{D}_{\alpha}\left(\tilde{{g}}_{t}\|\tilde{{g}}_{t}^{\prime}\right)\leq\ln\mathbb{E}_{i\sim\beta}\left[\exp\left({\frac{\alpha i^{2}(\alpha-1)}{2R_{N,L}^{2}\sigma^{2}}}\right)\right] \displaystyle=\frac{1}{\alpha-1}\ln\left(\sum_{i=0}^{R_{N,L}}\beta_{i}\exp\left({\frac{\alpha i^{2}(\alpha-1)}{2R_{N,L}^{2}\sigma^{2}}}\right)\right)=\gamma. \tag{31} $$ Here, $\beta_{i}$ is illustrated in Eq. (28). Based on the composition property of DP, after $T=n^{epoch}· n^{iter}$ interations, the discriminators satisfy node-level $(\alpha,{2T}\gamma)$ -RDP. Moreover, owing to the post-processing property of DP, the generators $G^{+}$ and $G^{-}$ inherit the same privacy guarantee as the discriminators. Therefore, Algorithm 2 obeys node-level $(\alpha,{2T}\gamma)$ -RDP, and the proof of Theorem 2 is completed. Appendix J Additional Details of Experiments J.1. Dataset Introduction The detailed introduction of all datasets is as follows. - Bitcoin-Alpha and Bitcoin-OTC are trust networks among Bitcoin users, aimed at preventing transactions with fraudulent or high-risk users. In these networks, user relationships are represented by positive (trust) and negative (distrust) edges. - Slashdot is a social network derived from user interactions on a technology news site, where relationships are annotated as positive (friend) or negative (enemy) edges. - WikiRfA is a voting network for electing managers in Wikipedia, where edges denote positive (supporting vote) or negative (opposing vote) relationships between users. - Epinions is a product review site where users can establish both trust and distrust relationships with others. J.2. The Distribution of Node Degrees and Path Lengths The findings for the distribution of node degrees and path lengths in the Bitcoin-Alpha and Slashdot datasets are shown in Figs. 8 and 9. <details> <summary>x8.png Details</summary>  ### Visual Description ## Bar Charts: Node Degree Distribution in Bitcoin-Alpha and Slashdot Networks ### Overview The image presents two bar charts comparing the distribution of node degrees in the Bitcoin-Alpha and Slashdot networks. Each chart displays the proportion of nodes (in percentage) for each degree value, ranging from 1 to 7. A curve is overlaid on each bar chart, visually representing the trend of the distribution. ### Components/Axes **Left Chart (Bitcoin-Alpha):** * **Title:** (a) Bitcoin-Alpha * **X-axis:** Degree (values: 1, 2, 3, 4, 5, 6, 7) * **Y-axis:** Proportion of Node (%) (values: 0, 10, 20, 30, 40) * **Bars:** Represent the proportion of nodes for each degree. The bars are light blue. * **Curve:** A light blue curve overlays the bars, showing the general trend. **Right Chart (Slashdot):** * **Title:** (b) Slashdot * **X-axis:** Degree (values: 1, 2, 3, 4, 5, 6, 7) * **Y-axis:** Proportion of Node (%) (values: 0, 20, 40, 60) * **Bars:** Represent the proportion of nodes for each degree. The bars are light blue. * **Curve:** A light blue curve overlays the bars, showing the general trend. ### Detailed Analysis **Bitcoin-Alpha:** * **Degree 1:** Proportion of nodes is approximately 36%. * **Degree 2:** Proportion of nodes is approximately 17%. * **Degree 3:** Proportion of nodes is approximately 11%. * **Degree 4:** Proportion of nodes is approximately 7%. * **Degree 5:** Proportion of nodes is approximately 5%. * **Degree 6:** Proportion of nodes is approximately 3%. * **Degree 7:** Proportion of nodes is approximately 3%. The curve shows a decreasing trend, indicating that the proportion of nodes decreases as the degree increases. **Slashdot:** * **Degree 1:** Proportion of nodes is approximately 63%. * **Degree 2:** Proportion of nodes is approximately 16%. * **Degree 3:** Proportion of nodes is approximately 6%. * **Degree 4:** Proportion of nodes is approximately 3%. * **Degree 5:** Proportion of nodes is approximately 2%. * **Degree 6:** Proportion of nodes is approximately 1%. * **Degree 7:** Proportion of nodes is approximately 1%. The curve shows a decreasing trend, indicating that the proportion of nodes decreases as the degree increases. ### Key Observations * Both networks exhibit a similar trend: the proportion of nodes decreases as the degree increases. * The Slashdot network has a significantly higher proportion of nodes with degree 1 compared to the Bitcoin-Alpha network. * The Bitcoin-Alpha network has a more gradual decrease in the proportion of nodes as the degree increases, compared to Slashdot. ### Interpretation The charts illustrate the degree distribution of nodes in the Bitcoin-Alpha and Slashdot networks. The data suggests that both networks follow a power-law-like distribution, where a small number of nodes have a high degree, and a large number of nodes have a low degree. The Slashdot network appears to be more heavily skewed towards nodes with a degree of 1, indicating a more centralized structure compared to the Bitcoin-Alpha network. This could be due to differences in the network's purpose, user behavior, or underlying architecture. The decreasing trend in both networks highlights the common characteristic of many real-world networks, where most nodes have relatively few connections, and only a few nodes have many connections. </details> Figure 8. Distribution of node degrees. <details> <summary>x9.png Details</summary>  ### Visual Description ## Chart Type: Bar Charts with Overlaid Curves ### Overview The image presents two bar charts side-by-side, each displaying the distribution of path lengths between nodes in a network. The left chart represents the "Bitcoin-Alpha" network, while the right chart represents the "Slashdot" network. The y-axis represents the "Proportion of Node Pairs (%)", and the x-axis represents "Path Length". A red curve is overlaid on each bar chart, approximating the distribution. ### Components/Axes * **X-axis (Path Length):** Both charts share the same x-axis, ranging from 1 to 7. * **Y-axis (Proportion of Node Pairs (%)):** The left chart's y-axis ranges from 0 to 50%. The right chart's y-axis ranges from 0 to 60%. * **Bars:** Blue, diagonally hatched bars represent the proportion of node pairs for each path length. * **Curve:** A red curve is overlaid on each chart, approximating the distribution of path lengths. * **Titles:** The left chart is titled "(a) Bitcoin-Alpha", and the right chart is titled "(b) Slashdot". * **Grid:** Both charts have a light gray grid in the background. ### Detailed Analysis **Chart (a) Bitcoin-Alpha:** * **Path Length 1:** Proportion of node pairs is approximately 1%. * **Path Length 2:** Proportion of node pairs is approximately 8%. * **Path Length 3:** Proportion of node pairs is approximately 40%. * **Path Length 4:** Proportion of node pairs is approximately 41%. * **Path Length 5:** Proportion of node pairs is approximately 10%. * **Path Length 6:** Proportion of node pairs is approximately 2%. * **Path Length 7:** Proportion of node pairs is approximately 0%. **Trend:** The proportion of node pairs increases sharply from path length 1 to 4, then decreases gradually from path length 4 to 7. The red curve follows this trend, peaking around path length 4. **Chart (b) Slashdot:** * **Path Length 1:** Proportion of node pairs is approximately 0%. * **Path Length 2:** Proportion of node pairs is approximately 2%. * **Path Length 3:** Proportion of node pairs is approximately 23%. * **Path Length 4:** Proportion of node pairs is approximately 64%. * **Path Length 5:** Proportion of node pairs is approximately 6%. * **Path Length 6:** Proportion of node pairs is approximately 0.5%. * **Path Length 7:** Proportion of node pairs is approximately 0%. **Trend:** The proportion of node pairs increases sharply from path length 1 to 4, then decreases gradually from path length 4 to 7. The red curve follows this trend, peaking around path length 4. ### Key Observations * Both networks exhibit a similar distribution of path lengths, with the highest proportion of node pairs having a path length of 4. * The Slashdot network has a higher proportion of node pairs with a path length of 4 compared to the Bitcoin-Alpha network (approximately 64% vs. 41%). * Both networks have very few node pairs with path lengths of 1, 6, or 7. ### Interpretation The data suggests that both the Bitcoin-Alpha and Slashdot networks have a relatively small-world structure, where most nodes are within a short path length of each other. The peak at path length 4 indicates that this is the most common distance between nodes in these networks. The higher peak for Slashdot suggests that it may have a more tightly connected structure than Bitcoin-Alpha. The red curves provide a smoothed representation of the distribution, highlighting the overall trend and making it easier to compare the two networks. </details> Figure 9. Distribution of path lengths. J.3. The detailed results of Edge Sign Prediction The average AUC results under different values of $\epsilon$ and datasets for edge prediction tasks are detailed in Table 6. Table 6. Summary of average AUC with different $\epsilon$ and datasets for edge sign prediction tasks. (BOLD: Best) | Bitcoin-OTC | SDGNN | 0.7655 | 0.7872 | 0.7913 | 0.8105 | 0.8571 | | --- | --- | --- | --- | --- | --- | --- | | SiGAT | 0.7011 | 0.7282 | 0.7869 | 0.8379 | 0.8706 | | | SGCN | 0.5565 | 0.5740 | 0.6634 | 0.7516 | 0.7801 | | | GAP | 0.5763 | 0.5782 | 0.6486 | 0.6741 | 0.7411 | | | LSNE | 0.5030 | 0.5405 | 0.7041 | 0.8239 | 0.8776 | | | ASGL | 0.8004 | 0.8462 | 0.8488 | 0.8505 | 0.8801 | | | Bitcoin-Alpha | SDGNN | 0.6761 | 0.6883 | 0.7098 | 0.7308 | 0.8476 | | SiGAT | 0.7033 | 0.7215 | 0.7303 | 0.7488 | 0.8207 | | | SGCN | 0.5157 | 0.5450 | 0.6433 | 0.6930 | 0.7702 | | | GAP | 0.5664 | 0.6025 | 0.6367 | 0.7091 | 0.7320 | | | LSNE | 0.5112 | 0.5361 | 0.5959 | 0.6524 | 0.8069 | | | ASGL | 0.7505 | 0.8075 | 0.8589 | 0.8591 | 0.8592 | | | WikiRfA | SDGNN | 0.6558 | 0.7066 | 0.7142 | 0.7267 | 0.7930 | | SiGAT | 0.6313 | 0.6525 | 0.7023 | 0.7777 | 0.8099 | | | SGCN | 0.5107 | 0.6456 | 0.6515 | 0.7008 | 0.7110 | | | GAP | 0.5356 | 0.5506 | 0.5612 | 0.5717 | 0.5937 | | | LSNE | 0.5086 | 0.5253 | 0.6119 | 0.6553 | 0.7832 | | | ASGL | 0.6680 | 0.7706 | 0.7963 | 0.7986 | 0.8100 | | | Slashdot | SDGNN | 0.7547 | 0.8325 | 0.8697 | 0.8788 | 0.8862 | | SiGAT | 0.7061 | 0.7886 | 0.8392 | 0.8424 | 0.8527 | | | SGCN | 0.5662 | 0.6151 | 0.6662 | 0.7181 | 0.8093 | | | GAP | 0.6121 | 0.6389 | 0.6879 | 0.7126 | 0.7471 | | | LSNE | 0.5717 | 0.6144 | 0.7541 | 0.7753 | 0.7816 | | | ASGL | 0.7861 | 0.8539 | 0.8887 | 0.8890 | 0.8910 | | | Epinions | SDGNN | 0.6788 | 0.7180 | 0.7201 | 0.7455 | 0.8428 | | SiGAT | 0.6772 | 0.7046 | 0.7063 | 0.7702 | 0.8253 | | | SGCN | 0.6152 | 0.6487 | 0.6974 | 0.7502 | 0.8318 | | | GAP | 0.5899 | 0.6034 | 0.6288 | 0.6310 | 0.6618 | | | LSNE | 0.5033 | 0.6055 | 0.7590 | 0.8434 | 0.8585 | | | ASGL | 0.6869 | 0.8134 | 0.8513 | 0.8658 | 0.8666 | | J.4. The detailed results of node clustering The average SSI results under different values of $\epsilon$ and datasets for node clustering tasks are detailed in Table 7. Table 7. Summary of average SSI with different $\epsilon$ and datasets for node clustering tasks. (BOLD: Best) | 1 | Bitcoin-Alpha | 0.4819 | 0.4378 | 0.4877 | 0.4977 | 0.4988 | 0.5091 | | --- | --- | --- | --- | --- | --- | --- | --- | | Bitcoin-OTC | 0.4505 | 0.4677 | 0.5025 | 0.4970 | 0.5008 | 0.5160 | | | Slashdot | 0.4715 | 0.5011 | 0.5025 | 0.5052 | 0.5005 | 0.5107 | | | WikiRfA | 0.4788 | 0.4988 | 0.4968 | 0.4890 | 0.5003 | 0.5126 | | | Epinions | 0.5001 | 0.4965 | 0.5022 | 0.5013 | 0.6095 | 0.6106 | | | 2 | Bitcoin-Alpha | 0.4910 | 0.4733 | 0.4969 | 0.4985 | 0.5032 | 0.5402 | | Bitcoin-OTC | 0.4733 | 0.4968 | 0.5075 | 0.4986 | 0.5729 | 0.6810 | | | Slashdot | 0.4888 | 0.4864 | 0.4871 | 0.5134 | 0.5132 | 0.5494 | | | WikiRfA | 0.4934 | 0.5054 | 0.5117 | 0.4996 | 0.5032 | 0.5577 | | | Epinions | 0.5068 | 0.5116 | 0.5086 | 0.5463 | 0.6263 | 0.6732 | | | 4 | Bitcoin-Alpha | 0.5019 | 0.4948 | 0.5112 | 0.5049 | 0.6204 | 0.6707 | | Bitcoin-OTC | 0.5005 | 0.5325 | 0.5612 | 0.5465 | 0.6953 | 0.7713 | | | Slashdot | 0.5003 | 0.5685 | 0.5545 | 0.5671 | 0.5444 | 0.5994 | | | WikiRfA | 0.5005 | 0.5142 | 0.5538 | 0.5476 | 0.5644 | 0.5977 | | | Epinions | 0.5148 | 0.5389 | 0.5386 | 0.6255 | 0.6747 | 0.6787 | | <details> <summary>x10.png Details</summary>  ### Visual Description ## Bar Chart: AUC Comparison of ASGL Variants on Different Datasets ### Overview The image is a bar chart comparing the Area Under the Curve (AUC) performance of three variants of the ASGL algorithm (ASGL-, ASGL+, and ASGL) across four different datasets: Bitcoin-Alpha, Bitcoin-OCT, Slashdot, and WikiRfA. The chart visually represents the AUC scores for each ASGL variant on each dataset, allowing for a direct comparison of their performance. ### Components/Axes * **Y-axis:** AUC (Area Under the Curve), ranging from 0.65 to 0.90 in increments of 0.05. * **X-axis:** Datasets: Bitcoin-Alpha, Bitcoin-OCT, Slashdot, WikiRfA. * **Legend:** Located at the top of the chart. * ASGL-: Light blue bars with diagonal stripes. * ASGL+: Blue bars with diagonal stripes. * ASGL: Light red bars with a dotted pattern. * **Gridlines:** Horizontal gridlines are present at each 0.05 increment on the Y-axis. ### Detailed Analysis Here's a breakdown of the AUC values for each ASGL variant on each dataset: * **Bitcoin-Alpha:** * ASGL-: Approximately 0.835 * ASGL+: Approximately 0.84 * ASGL: Approximately 0.86 * **Bitcoin-OCT:** * ASGL-: Approximately 0.81 * ASGL+: Approximately 0.83 * ASGL: Approximately 0.85 * **Slashdot:** * ASGL-: Approximately 0.86 * ASGL+: Approximately 0.81 * ASGL: Approximately 0.89 * **WikiRfA:** * ASGL-: Approximately 0.79 * ASGL+: Approximately 0.70 * ASGL: Approximately 0.81 ### Key Observations * ASGL consistently outperforms ASGL- and ASGL+ on Bitcoin-Alpha, Bitcoin-OCT, and Slashdot datasets. * On WikiRfA, ASGL- performs better than ASGL+, but both are outperformed by ASGL. * The performance difference between ASGL variants is most pronounced on the WikiRfA dataset. * Slashdot shows the highest AUC values for ASGL, indicating it might be the most suitable dataset for this algorithm. * WikiRfA shows the lowest AUC values for ASGL+ and ASGL-, indicating it might be the least suitable dataset for these algorithms. ### Interpretation The bar chart provides a comparative analysis of the ASGL algorithm and its variants across different datasets. The data suggests that the standard ASGL algorithm generally achieves higher AUC scores compared to its ASGL- and ASGL+ variants, indicating better overall performance in most cases. However, the performance varies depending on the dataset, with WikiRfA showing a significant performance gap between ASGL and its variants. This could imply that the ASGL algorithm is more robust or better suited for certain types of network structures or data characteristics present in the Bitcoin-Alpha, Bitcoin-OCT, and Slashdot datasets compared to WikiRfA. The lower performance of ASGL+ on WikiRfA is a notable outlier, suggesting potential limitations or sensitivities of this variant to specific data properties. Further investigation into the characteristics of each dataset and the algorithmic differences between ASGL, ASGL-, and ASGL+ would be necessary to fully understand these performance variations. </details> Figure 10. Comparison between ASGL, $\text{ASGL}^{+}$ , and $\text{ASGL}^{-}$ . J.5. The Setup of Link Stealing Attack Motivated by (42), we assume that the adversary has black-box access to the node embeddings produced by the target signed graph learning model, but not to its internal parameters or gradients. The adversary also possesses an auxiliary graph dataset comprising node pairs that partially overlap in distribution with the target graph. Some of these node pairs belong to the training graph (members), while others are from the test graph (non-members). For each node pair, a feature vector is constructed by concatenating their embeddings. Finally, these feature vectors, along with their corresponding member or non-member labels, are then used to train a logistic regression classifier to infer whether an edge exists between any two nodes of the target graph. To simulate this link stealing attack, each dataset is partitioned into target training, auxiliary training, target test, and auxiliary test sets with a 5:2:2:1 ratio. J.6. Effectiveness of Adversarial Learning with Edge Signs. To verify the effectiveness of adversarial learning with signed edges, we also compare our ASGL with its variants, denoted as $\text{ASGL}^{+}$ and $\text{ASGL}^{-}$ . Specifically, $\text{ASGL}^{+}$ and $\text{ASGL}^{-}$ only operate on the positive graph $\mathcal{G}^{+}$ and the negative graph $\mathcal{G}^{-}$ , respectively. Fig. 10 presents the average AUC scores of ASGL, $\text{ASGL}^{+}$ , and $\text{ASGL}^{-}$ across all datasets. It can be observed that ASGL significantly outperforms both $\text{ASGL}^{+}$ and $\text{ASGL}^{-}$ in all cases. These results demonstrate that our privacy-preserving adversarial learning framework with edge signs is more effective in representing signed graphs compared to its variants that neglect edge sign information.