acceptodds
Under review as a conference paper at ICLR 2027

CircuitGate: Logic-Consistent Circuit-Level Functional Modeling for And-Inverter Graphs

10 views

Abstract

And-Inverter Graphs (AIGs) are fundamental representations for logic synthesis and verification in Electronic Design Automation (EDA). As structured represen- tations of complex digital systems, AIGs require models to capture functional de- pendencies beyond local structure and remain robust to functionality-preserving transformations. In learning-based AIG representation, existing approaches are predominantly based on GNNs and rely on local gate-level message passing, lim- iting their ability to capture circuit-level functional context and making the learned representations sensitive to topology-specific patterns. Therefore, we propose Cir- cuitGate, a function-aware AIG representation learning framework that advances from gate-level semantics to circuit-level functional modeling. CircuitGate ex- plicitly encodes global primary-input (PI) support and models support-overlap- aware reconvergence between fanins, while incorporating logic-inspired Boolean constraints to encourage functionally consistent representations. We evaluate Cir- cuitGate on the large-scale ForgeEDA benchmark and further validate it on the EPFL and ITC’99 benchmarks. Across equivalent-gate identification and signal- probability prediction tasks, CircuitGate consistently outperforms existing meth- ods, achieving up to 21.7% and 14.2% reductions in MAE, respectively. Un- der direct ForgeEDA-to-OpenABC transfer without fine-tuning, CircuitGate also achieves the best equivalent-gate identification performance, demonstrating strong cross-dataset generalization. These results demonstrate the effectiveness of mod- eling circuit-level functional dependencies beyond local topology. Source code is available at https://anonymous.4open.science/r/CircuitGate/.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
And-Inverter Graphs, Circuit Representation Learning, Graph Neural Networks, Logic Synthesis, Electronic Design Automation

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_VpdFOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper learns representations of And-Inverter Graphs using input-support information, reconvergence features, and logic-based regularization. The paper reports improvements in gate similarity and signal-probability prediction across three datasets, with additional experiments on synthesis changes and transfer to another dataset.

Critical strengths
  1. The method makes good use of circuit structure: input support tracks which primary inputs can reach a gate, and fanin overlap identifies reconvergence. These features give the model useful information about shared inputs, and their benefit is supported by the ablations.

  2. The improvements are consistent across both tasks and the three main datasets, with reasonably strong gains over the baselines. The component ablations help explain where the gains come from, and splitting the data by source design makes the evaluation more convincing.

Critical weaknesses
  1. It is still unclear how much the proposed update mechanism adds beyond the extra input features. The ablations show that support and context information help, but a strong baseline given the same features would be needed to isolate the benefit of the architecture.

  2. The prediction-level robustness claim needs a more direct comparison. Without the original errors on exactly the same matched gate pairs, the reported errors after synthesis do not show how much each model degrades, so better starting accuracy could partly explain the advantage.

Questions for authors
  1. Could you compare against a strong baseline using the same support and context features? This would help establish what the proposed update mechanism adds.

  2. In the synthesis experiment, what fraction of gate pairs survives matching, and how do the original and transformed errors compare on those same pairs?

2 comments
AuthorsOpenReview ↗

Response to Reviewer VpdF (1/2): Contribution of the Update Mechanism

We sincerely thank the reviewer for recognizing the consistent performance improvements, circuit-aware design, and source-disjoint evaluation of CircuitGate. We appreciate the important concerns raised in the review and provide additional controlled experiments to address them.

W1. Contribution of the update mechanism beyond additional features

The reviewer questions whether the proposed update mechanism provides benefits beyond additional functional inputs and suggests comparing CircuitGate with strong baselines equipped with the same support and context features.

A1. Response

We agree that component-removal ablations alone cannot fully distinguish the benefits of additional functional information from those of the update mechanism. To address this concern, we conduct two complementary controlled experiments: feature- and objective-matched baseline comparisons and update-mechanism replacements within the same backbone.

1. Feature- and objective-matched strong baselines.

We augment DeepGate3 and MGVGA with the same EDA-native context attributes, parity-indexed structural PI-support sketches, support-size and coverage statistics, and six-dimensional reconvergent-fanin descriptors used by CircuitGate.

These inputs are incorporated at each propagation layer through concatenation and learned projection while preserving the baselines' original message-passing operators. Feature-projection configurations are selected using validation data. All comparisons use identical source-disjoint splits, task labels, evaluation protocols, and validation-based checkpoint selection. The "+ Logic" variants additionally incorporate the same logic-inspired regularization as CircuitGate.

Table R1. Feature- and objective-controlled ForgeEDA EQ comparison.

ModelMAE ↓
DeepGate30.0553
DeepGate3 + Same Features0.0481
DeepGate3 + Same Features + Logic0.0478
MGVGA0.0563
MGVGA + Same Features0.0492
MGVGA + Same Features + Logic0.0485
CircuitGate0.0433

Key findings. Additional functional information substantially improves both baselines. Nevertheless, CircuitGate achieves 9.4% lower MAE than augmented DeepGate3 and 10.7% lower MAE than augmented MGVGA, even after matching functional inputs and training objectives.

This remaining advantage indicates that the improvements cannot be attributed solely to additional features or logic regularization. How these dependencies are incorporated into representation updates also matters.

2. Controlled update replacements within the same backbone.

To isolate the architectural contribution more directly, we retain CircuitGate's backbone, all functional inputs, and training objective, replacing only the additional gated correction term in Equation (8).

We consider two alternatives:

  • Static MLP fusion: Replaces the gated correction with a capacity-matched MLP correction computed from local messages, PI context, and reconvergence descriptors, retaining the same information without explicit multiplicative gating.
  • Unmasked learned gate: Retains the original gate network, its inputs, and multiplicative correction, but removes the explicit reconvergence mask mvm_v. Specifically, gv(l)=mvσ(MLPg([rv∥MLPs(av(l))]))g_v^{(l)}=m_v\sigma(\mathrm{MLP}_g([r_v\parallel\mathrm{MLP}_s(a_v^{(l)})])) becomes gv(l)=σ(MLPg([rv∥MLPs(av(l))]))g_v^{(l)}=\sigma(\mathrm{MLP}_g([r_v\parallel\mathrm{MLP}_s(a_v^{(l)})])).

The unmasked gate still receives the complete reconvergence descriptor and can learn to exploit support overlap. This comparison therefore isolates the effect of explicitly restricting the correction to reconvergent nodes.

Table R2. Controlled update replacements on ForgeEDA EQ.

Update mechanismMAE ↓
Static MLP fusion0.0471
Unmasked learned gate0.0459
Original masked, overlap-conditioned gate0.0433

Key findings. The original update reduces MAE by 8.1% relative to static fusion and 5.7% relative to unmasked gating.

Unlike the existing "w/o Reconvergence" ablation, both controls retain reconvergence information. Thus, these comparisons isolate the update mechanism more directly rather than conflating its contribution with feature removal.

Conclusion. The two experiments provide complementary evidence: CircuitGate maintains an advantage over feature- and objective-matched strong baselines, and its original overlap-conditioned update outperforms alternative correction mechanisms within the same backbone. These results support the architectural contribution beyond additional functional features and suggest that the explicit reconvergence mask provides a beneficial inductive bias.

We thank the reviewer again for this valuable suggestion, which helped us clarify the independent contribution of the proposed mechanism.

AuthorsOpenReview ↗

Response to Reviewer VpdF (2/2): Synthesis Robustness

W2. Correspondence coverage and prediction robustness under synthesis transformations

The reviewer notes that absolute post-synthesis MAE alone cannot distinguish synthesis-induced prediction degradation from differences in initial accuracy. The reviewer also asks what fraction of evaluated gate pairs can be matched and how their original errors compare with post-transformation errors.

A2. Response

We appreciate this important distinction. To directly address the concern, we report gate-pair correspondence coverage and conduct paired pre-/post-synthesis evaluations on exactly the same matched pairs, separating initial prediction accuracy from synthesis-induced degradation.

1. Correspondence coverage and evaluation protocol.

Following Appendix A.7, we evaluate the same ForgeEDA test circuits under four transformations: resyn2, dc2, rewrite, and refactor.

Whole-circuit equivalence is checked using ABC CEC. Candidate node correspondences are identified using 15,000 shared random input patterns with consistent PI ordering and subsequently verified formally.

An original evaluated EQ pair is retained for a transformation only if both endpoints have verified correspondences. We use the common intersection retained across all four transformations for the paired comparison.

All models use fixed checkpoints without retraining, identical retained pairs, and the original truth-table-distance targets. MAE is computed per circuit and then averaged across circuits.

Table R3. Gate-pair correspondence coverage.

Matching requirementRetained pairs per 10,000 original pairsCoverage
resyn27,64076.4%
dc27,91079.1%
rewrite8,87088.7%
refactor8,79087.9%
Common intersection7,16071.6%

Coverage is a pooled pair-count ratio, whereas the MAEs below are circuit-averaged.

Key finding. The common intersection retains 71.6% of the original evaluated pairs, enabling consistent paired comparisons across all four transformations.

2. Paired prediction errors before and after synthesis.

We measure the original-view MAE and post-synthesis MAE on the same retained pairs for DeepGate3 and CircuitGate.

Table R4. Paired prediction errors under synthesis transformations.

TransformationModelPre MAEPost MAEΔMAE
resyn2DeepGate30.08680.1971+0.1103
resyn2CircuitGate0.07890.1661+0.0872
dc2DeepGate30.08680.1933+0.1065
dc2CircuitGate0.07890.1630+0.0841
rewriteDeepGate30.08680.1919+0.1051
rewriteCircuitGate0.07890.1138+0.0349
refactorDeepGate30.08680.1921+0.1053
refactorCircuitGate0.07890.1152+0.0363

Here, ΔMAE=Post MAE−Pre MAE\Delta\mathrm{MAE}=\mathrm{Post\ MAE}-\mathrm{Pre\ MAE}. The Post MAEs reproduce Table 12 under the common-subset protocol described in Appendix A.7.

Key findings.

(1) The robustness advantage extends beyond initial accuracy.

Before synthesis, the MAE gap between DeepGate3 and CircuitGate is only 0.0079 (0.0868 vs. 0.0789). After synthesis, the gap increases to 0.0303–0.0781 across the four transformations.

Thus, higher initial accuracy alone cannot explain the observed post-synthesis advantage.

(2) CircuitGate consistently exhibits smaller prediction degradation.

Averaged over the four transformations, the MAE increases are:

  • DeepGate3: 0.106800
  • CircuitGate: 0.060625

This corresponds to a 43.2% reduction in average synthesis-induced MAE degradation relative to DeepGate3. Importantly, the reduction occurs under every transformation, rather than being driven by a single favorable case.

(3) Correspondence selection is controlled.

Both models are evaluated on identical matched pairs, eliminating differences in pair selection as an explanation for the observed degradation gap. The original-view MAEs differ from Table 1 because the evaluation concerns the common matched subset of 20 circuits, rather than the complete ForgeEDA test set.

Conclusion. The paired results directly address the reviewer's concern: CircuitGate achieves not only lower post-synthesis MAE but also substantially smaller prediction-error increases on identical gate pairs. Together with the matched-node CKA results in Table 5, these findings provide complementary evidence of representation consistency and task-level robustness under functionality-preserving synthesis transformations.

We sincerely thank the reviewer for this suggestion, which helped us provide a more direct evaluation of synthesis-induced prediction degradation.

Reviewer_kF3BOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

CircuitGate is a node representation learning model for And-Inverter Graphs. It adds three components to a nine-layer relation-aware message-passing backbone. Circuit-Level Context Augmentation appends normalized forward and backward logic level, log fanout, an output flag and PI-support coverage to the gate-type one-hot. Global PI-Dependency Encoding computes exact structural PI supports in one topological pass, split by inversion parity. It compresses each set into a fixed random Gaussian sketch normalized by the square root of the set size, and concatenates the MLP-encoded result into every layer update. Reconvergent-Fanin Dependency Modeling builds a six-dimensional descriptor from the support overlap of each AND node’s two fanins and uses it to gate a residual copy of the PI encoding. The training objective adds NOT-complementarity and Fréchet-bound penalties on predicted signal probabilities.

On ForgeEDA, EPFL and ITC’99, the paper reports the lowest equivalent-gate MAE (0.0433, 0.0683, 0.0622) and signal-probability MAE (0.0212, 0.0460, 0.0141) among twelve baselines. It also reports the highest linear CKA between matched node embeddings before and after resyn2, dc2, rewrite and refactor (average 0.8341), the lowest MAE under zero-shot ForgeEDA-to-OpenABC transfer, and preprocessing of about 15 s on a 525,762-node graph.

Critical strengths

S1. The core method is efficient which can be useful for large EDA designs.

S2. The proposed method consistently beats prior methods.

Critical weaknesses

W1. The two evaluation tasks are the training objectives. Appendix A.1 defines a separate task loss for each, and Appendix A.2 states that the tasks are trained independently on ITC’99. The paper therefore does not show a reusable representation.

W2. No downstream EDA application is evaluated. DeepGate2 did evaluate one (SAT sweeping with ABC &fraig, and SAT solving), as did DeepGate3, DeepGate4 and MGVGA (SAT solving and QoR ranking).

W3. Most of the components has a close precedent for example Reconvergence (DeepGate, DeepGate2), PI dependency (DeepGate2, DeepGate3).

Questions for authors

Q1. How does CircuitGate differ, conceptually and empirically, from DeepGate’s reconvergence skip connections and from DeepGate2’s orthogonal PI embeddings and reconvergence prediction task? What would be the impact on the QoR if you used the prior versions to inject the inductive bias instead of yours?

Q2. Have you tested the performance of the embeddings on some downstream tasks?

Q3. Since a separate model is trained for each task, can a single trained encoder transfer to an EDA task outside its supervision targets? Examples include cut-point proposal or SAT sweeping for equivalence checking between pre- and post-synthesis AIGs, or QoR prediction from the PPA reports already included in ForgeEDA.

Q4. Were DeepGate2, DeepGate3, DeepGate4 and MGVGA pretrained following their original protocols before task training, or trained from scratch on the 5% ForgeEDA split? Can you explain why DeepGate2 and PolarGate underperform GCN, and why DeepGate4 is both less accurate and slower than DeepGate3?

Q5. There are two relevant papers that you might have missed to cite: MixGate (Alignment Unlocks Complementarity: A Framework for Multiview Circuit Representation Learning) and FGNN2. Some of the ideas present seem to be similar to yours. Can you provide more details on how the signal-probability and truth-table-distance tasks differ from yours?

8 comments
AuthorsOpenReview ↗

Response to Reviewer kF3B (1/7): Summary of Response

We sincerely thank Reviewer kF3B for the thorough, constructive review and for recognizing CircuitGate's efficiency on large EDA designs (S1) and consistent accuracy gains across benchmarks and synthesis transformations (S2).

We have comprehensively addressed all concerns regarding whether a single encoder transfers beyond its original EQ/SPP training objectives (W1/Q3) through cross-benchmark stability and frozen-encoder QoR transfer evaluations (2/7), demonstrated practical downstream EDA utility (W2/Q2) via embedding-guided SAT sweeping built on ABC &fraig (3/7), clarified conceptual and empirical distinctions from prior PI and reconvergence mechanisms (W3/Q1) through feature-matched controls and orthogonal PI × Reconvergence ablations (4/7) alongside controlled update-mechanism replacements and mechanism-level downstream QoR evaluations (5/7), confirmed unified scratch-training fairness and analyzed cross-dataset baseline behaviors (Q4) (6/7), and detailed our positioning relative to MixGate and FGNN2 (Q5) (7/7).

Crucially, these controlled experiments confirm that CircuitGate's circuit-native representations transfer across downstream QoR tasks without fine-tuning (0.114 Area NMAE, 0.558 NDCG@5), accelerate end-to-end SAT sweeping by 36.4% (172.54 s vs. 271.46 s), and consistently outperform prior PI and reconvergence designs under identical data budgets.

AuthorsOpenReview ↗

Response to Reviewer kF3B (2/7): Reusable Representations and Frozen-Encoder QoR Transfer (W1/Q3)

We sincerely thank the reviewer for recognizing CircuitGate's consistent performance improvements and computational efficiency on large-scale circuits. We appreciate the opportunity to further demonstrate the transferability of its learned functional representations beyond the original EQ/SPP prediction objectives.

W1 / Q3. Can a single CircuitGate encoder transfer beyond its original EQ/SPP objectives?

A1. Response

CircuitGate learns reusable circuit-native, logic-grounded functional representations by explicitly incorporating global polarity-aware PI dependencies, reconvergent-fanin relationships, and Boolean logic consistency into neural representation learning.

To examine their applicability beyond the original functional prediction objectives, we provide two complementary forms of evidence: cross-benchmark generalization and synthesis-transformation stability, followed by frozen-encoder transfer to downstream circuit-level quality-of-results (QoR) tasks.

1. Cross-benchmark generalization and representation stability. Our original experiments demonstrate consistent functional prediction improvements across multiple circuit benchmarks (Table R1). Furthermore, our ForgeEDA-to-OpenABC zero-shot evaluation provides evidence of cross-distribution generalization, while an average matched-node linear CKA of 0.8341 across resyn2, dc2, rewrite, and refactor demonstrates representation consistency under functionality-preserving synthesis transformations.

Table R1. Original functional prediction results (MAE ↓).

DatasetBest Competing EQCircuitGate EQBest Competing SPPCircuitGate SPP
ForgeEDA0.05530.04330.02460.0212
EPFL0.08480.06830.05600.0460
ITC'990.07180.06220.01540.0141

Key findings. These results establish the cross-benchmark generalization and structural-transformation stability of CircuitGate's learned functional representations, providing a foundation for downstream QoR transfer.

2. Frozen-encoder transfer to downstream QoR prediction. We evaluate the original EQ-trained CircuitGate encoder (trained with auxiliary SPP supervision per Appendix A.1) and a separately trained CircuitGate-SPP encoder on three downstream circuit-level tasks derived from ForgeEDA synthesis reports: Area NMAE, Delay NMAE, and Area NDCG@5 (ranking functionally equivalent ABC optimization candidates mapped under an identical technology-mapping flow).

All functional encoders originate from the unified 5% ForgeEDA scratch-training protocol described in Part (6/7) without external pretrained checkpoints, and remain strictly frozen throughout downstream training under source-design-disjoint partitions, using identical graph-level pooling operations and lightweight task heads (Table R2).

Table R2. Frozen-encoder transfer results on downstream QoR prediction.

EncoderArea NMAE ↓Delay NMAE ↓Area NDCG@5 ↑
Random-init CircuitGate0.1670.1530.402
EDA-native features + MLP0.1580.1460.447
DeepGate20.1510.1440.398
DeepGate30.1360.1310.481
DeepGate40.1260.1060.518
MGVGA0.1210.1140.532
CircuitGate-SPP0.1180.1110.541
CircuitGate-EQ0.1140.1080.558

Key findings. CircuitGate-EQ achieves the lowest Area NMAE (0.114) and highest Area NDCG@5 (0.558), improving upon MGVGA by 5.8% and 4.9%, respectively, while remaining competitive in Delay NMAE (0.108) with DeepGate4 (0.106). Compared with the randomly initialized frozen CircuitGate encoder, functional training reduces Area NMAE by 31.7% and improves Area NDCG@5 by 38.8%. Crucially, the single frozen CircuitGate-EQ encoder supports area estimation, delay prediction, and implementation ranking without encoder fine-tuning.

Conclusion. CircuitGate learns reusable functional representations that effectively transfer across downstream EDA prediction and ranking tasks without encoder fine-tuning. We sincerely thank the reviewer for the constructive comments and valuable suggestions.

AuthorsOpenReview ↗

Response to Reviewer kF3B (3/7): Practical Downstream EDA Applications

We sincerely thank the reviewer for emphasizing the importance of practical downstream EDA evaluation. We appreciate the opportunity to demonstrate how CircuitGate's circuit-native functional representations contribute to both predictive EDA tasks and verification-oriented workflows.

W2 / Q2. Does CircuitGate provide practical benefits in downstream EDA applications?

A2. Response

CircuitGate's circuit-native, logic-grounded functional representations support downstream EDA applications through transferable QoR prediction and embedding-guided formal verification.

We evaluate two complementary applications: (1) circuit-level QoR prediction and implementation ranking, and (2) embedding-guided SAT sweeping, assessing verification workload reduction and end-to-end execution efficiency.

1. Downstream QoR prediction and implementation ranking. As detailed in Part (2/7) (Table R2), a single frozen CircuitGate-EQ encoder transfers effectively to ForgeEDA synthesis reports under source-design-disjoint partitions without fine-tuning, achieving the lowest Area NMAE (0.114) and highest Area NDCG@5 (0.558) (5.8% and 4.9% gains over MGVGA) alongside competitive Delay NMAE (0.108).

Key findings. These results confirm that a single functionally trained encoder can support multiple circuit-level QoR objectives through lightweight prediction heads.

2. Practical EDA application: embedding-guided SAT sweeping. We further evaluate CircuitGate in an SAT sweeping workflow built upon ABC &fraig. Learned gate embeddings guide the prioritization of candidate equivalence checks, while formal SAT verification remains the strict authority for all equivalence decisions. We compare DeepGate2, DeepGate3, DeepGate4, MGVGA, and CircuitGate under identical input AIGs, candidate-generation protocols, SAT solver settings, verification budgets, and stopping criteria. To account for representation computation overhead, Table R3 reports SAT solver calls, preprocessing and inference time, SAT verification and circuit-update time, and overall end-to-end runtime.

Table R3. End-to-end SAT sweeping efficiency comparison.

MethodSAT Calls ↓Prep. + Model (s) ↓SAT + Update (s) ↓Overall (s) ↓
ABC &fraig17,843—271.46271.46
Structural heuristic15,9261.37232.84234.21
DeepGate213,18715.82174.39190.21
DeepGate314,46355.18198.64253.82
DeepGate412,87631.44185.73217.17
MGVGA13,65212.96165.37178.33
CircuitGate12,09425.73146.81172.54

Key findings. CircuitGate requires the fewest SAT calls (12,094), reducing SAT solver calls by 32.2% relative to standard ABC &fraig and 11.4% relative to MGVGA. Consequently, CircuitGate achieves the shortest overall runtime (172.54 s), a 36.4% reduction relative to ABC &fraig (271.46 s). Compared with MGVGA, CircuitGate incurs 12.77 s of additional preprocessing and inference time (25.73 s vs. 12.96 s), while saving 18.56 s in SAT verification and circuit updates (165.37 s to 146.81 s), achieving a 3.2% reduction in overall runtime even after including representation computation overhead.

Conclusion. CircuitGate demonstrates practical downstream EDA utility through transferable QoR prediction and efficient embedding-guided SAT sweeping. We sincerely thank the reviewer for the constructive comments and valuable suggestions.

Reviewer_SWh3OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes CircuitGate, a function-aware representation learning framework for And-Inverter Graphs (AIGs). Existing GNN-based methods rely primarily on local gate-level message passing, limiting their ability to capture circuit-level functional dependencies and making representations sensitive to topology-specific patterns. CircuitGate explicitly encodes global primary-input (PI) support and models reconvergence between fanins, while incorporating logic-inspired Boolean constraints. Evaluations on ForgeEDA, EPFL, and ITC'99 show gains in equivalent-gate identification and signal-probability prediction, supported by additional transfer, robustness, and efficiency experiments.

Critical strengths

The paper identifies a meaningful limitation of local message passing of GNN in AIGs and provides a clear functional motivation for modeling global input dependencies and reconvergent-fanin correlations.

The proposed framework integrates global PI dependencies and reconvergence-aware modeling to enhance circuit representations, with ablation studies validating the effectiveness of these components.

CircuitGate achieves better prediction accuracy than existing methods across multiple benchmarks on both equivalent-gate identification and signal-probability prediction tasks.

Critical weaknesses

It is unclear how much of the improvement comes from the proposed architecture rather than the additional circuit-level features.

The scalability of CircuitGate on large-scale circuits remains unclear, as only preprocessing costs are evaluated on complete circuits, while inference performance is tested on smaller subcircuits.

Questions for authors

Can the authors compare CircuitGate with existing GNN baselines with the same circuit-level features, including PI-support, circuit context, and reconvergence information?

Can the authors evaluate the inference latency, memory consumption, and prediction accuracy on complete large-scale circuits?

3 comments
AuthorsOpenReview ↗

Response to Reviewer SWh3 (1/3): Summary of Response

We sincerely thank Reviewer SWh3 for recognizing the clear functional motivation of modeling global primary-input (PI) dependencies and reconvergent-fanin correlations in And-Inverter Graphs (AIGs), the effectiveness of our component ablations, and CircuitGate's consistent prediction accuracy gains across benchmarks on both equivalent-gate (EQ) identification and signal-probability prediction (SPP).

We have comprehensively addressed all concerns regarding whether performance gains stem from the proposed architecture rather than additional circuit-level features (W1/Q1) through feature- and objective-matched baseline comparisons and same-backbone update replacements (2/3), and resolved inference scalability, memory consumption, and prediction accuracy on complete large-scale circuits (W2/Q2) via full-circuit evaluations on seven untruncated OpenABC-D AIGs of up to 525,762 nodes (3/3).

Crucially, these controlled experiments confirm both claims: CircuitGate outperforms strong baselines even when supplied with identical PI-support, context, and reconvergence features, and scales to complete 525k-node AIGs with sub-second inference latency (450.17 ms) and superior full-circuit EQ accuracy.

AuthorsOpenReview ↗

Response to Reviewer SWh3 (2/3): Architectural Contribution Beyond Circuit-Level Features (W1/Q1)

We thank the reviewer for raising this important question. We agree that component-removal ablations alone cannot fully separate the benefits of additional circuit-derived features from those of the neural update mechanism.

W1 / Q1: It is unclear how much of the improvement comes from the proposed architecture rather than the additional circuit-level features. Can the authors compare CircuitGate with existing GNN baselines with the same circuit-level features, including PI-support, circuit context, and reconvergence information?

A1: To isolate the architectural contribution directly, we conduct two complementary controlled experiments on ForgeEDA: (1) feature- and objective-matched baseline comparisons, and (2) update-mechanism replacements within the exact same backbone.

1. Feature- and objective-matched strong baselines. We augment DeepGate3 and MGVGA with the exact same EDA-native circuit context attributes, parity-indexed structural PI-support sketches, support-size and coverage statistics, and six-dimensional reconvergent-fanin descriptors used by CircuitGate. These inputs are integrated at each propagation layer via concatenation and learned projection while preserving the baselines' original message-passing operators, with projection configurations selected on validation data. All models follow identical source-design-disjoint splits, task labels, evaluation protocols, and validation-based checkpoint selection. The + Logic variants further incorporate the same Boolean-inspired logic regularization as CircuitGate.

Table R1. Feature- and objective-controlled ForgeEDA EQ comparison (MAE ↓).

ModelEQ MAE ↓
DeepGate30.0553
DeepGate3 + Same Features0.0481
DeepGate3 + Same Features + Logic0.0478
MGVGA0.0563
MGVGA + Same Features0.0492
MGVGA + Same Features + Logic0.0485
CircuitGate0.0433

Key findings. Supplying identical circuit-level features and logic regularization substantially improves both baselines (0.0553 to 0.0478 for DeepGate3; 0.0563 to 0.0485 for MGVGA). Nevertheless, CircuitGate (0.0433) achieves 9.4% lower MAE than feature- and objective-matched DeepGate3 and 10.7% lower MAE than feature- and objective-matched MGVGA, confirming that how these dependencies are incorporated into representation updates matters critically.

2. Controlled update replacements within the same backbone. To isolate the update mechanism even more tightly, we retain CircuitGate's backbone, all functional inputs, and training objective, replacing only the gated correction term in Equation (8):

  • Static MLP fusion: Replaces the overlap-conditioned gate with a capacity-matched MLP computed from local messages, PI context, and reconvergence descriptors, retaining identical input information without multiplicative gating.
  • Unmasked learned gate: Retains the original gate network, inputs, and multiplicative correction, but removes the explicit structural reconvergence mask mvm_v—replacing gv(l)=mvσ(⋅)g_v^{(l)} = m_v \sigma(\cdot) with g~v(l)=σ(⋅)\tilde{g}_v^{(l)} = \sigma(\cdot)—so the gate still observes the complete reconvergence descriptor without hard structural masking.

Table R2. Controlled update replacements on ForgeEDA EQ (MAE ↓).

Update Mechanism (Identical Backbone & Features)EQ MAE ↓
Static MLP fusion0.0471
Unmasked learned gate0.0459
Original masked, overlap-conditioned gate0.0433

Key findings. CircuitGate's original update reduces MAE by 8.1% relative to static MLP fusion (0.0471) and by 5.7% relative to unmasked gating (0.0459). Unlike feature-removal ablations, both controls retain complete reconvergence descriptors, directly isolating the inductive bias of restricting global-context gating to reconvergent nodes.

Conclusion. Tables R1 and R2 confirm that CircuitGate's gains stem not merely from extra PI-support, context, and reconvergence features, but from its circuit-conditioned update architecture.

AuthorsOpenReview ↗

Response to Reviewer SWh3 (3/3): Full-Circuit Inference Scalability, Memory Consumption, and Prediction Accuracy (W2/Q2)

We thank the reviewer for highlighting the importance of evaluating full-circuit inference scalability beyond preprocessing efficiency.

W2 / Q2: The scalability of CircuitGate on large-scale circuits remains unclear, as only preprocessing costs are evaluated on complete circuits, while inference performance is tested on smaller subcircuits. Can the authors evaluate the inference latency, memory consumption, and prediction accuracy on complete large-scale circuits?

A2: We evaluate CircuitGate and five baselines on seven complete, untruncated OpenABC-D circuits (1,928 to 525,762 nodes) across forward-pass latency, equivalent-gate (EQ) MAE, host/GPU memory, and topological sensitivity.

1. Full-circuit inference efficiency. For DeepGate3, we use its official non-Transformer configuration (the Transformer variant encountered out-of-memory errors on large AIGs under the same hardware).

Table R3. Full-circuit inference latency (ms) / peak GPU reserved memory (GiB).

Modelsimple_spimaxmem_ctrltinyRocketjpeghypdft
Nodes1,9286,27931,001104,336233,573420,769525,762
CircuitGate2.62 / 0.0526.55 / 0.09329.12 / 0.42091.83 / 1.320200.98 / 2.897360.50 / 5.181450.17 / 6.476
MGVGA1.59 / 0.0422.73 / 0.06114.90 / 0.20146.59 / 0.617104.89 / 1.325186.52 / 2.409227.96 / 2.867
DeepGate334.52 / 0.064444.30 / 0.07884.21 / 0.221358.34 / 0.502488.83 / 1.135899.83 / 2.4181,130.39 / 2.965
DeepGate441.98 / 0.078401.73 / 0.238639.74 / 0.4632,102.51 / 0.6465,107.87 / 1.545251,670.21 / 2.80720,673.17 / 4.014
AIGer0.94 / 0.0342.13 / 0.05410.09 / 0.23531.58 / 0.71569.93 / 1.673126.35 / 2.876154.05 / 3.673
HOGA0.34 / 0.0430.98 / 0.0614.63 / 0.30515.35 / 0.92034.21 / 2.05559.62 / 3.68450.99 / 4.586

CircuitGate processes all seven complete AIGs without truncation in sub-second latency. On dft (525,762 nodes), inference takes 450.17 ms and 6.476 GiB peak GPU reserved memory—2.51× and 45.9× faster than DeepGate3 and DeepGate4, and only 222.21 ms slower than MGVGA with superior EQ accuracy.

2. Full-circuit prediction accuracy.

Table R4. Equivalent-gate identification MAE on complete OpenABC-D circuits (↓).

Modelsimple_spimaxmem_ctrltinyRocketjpeghypdftAvg.
CircuitGate0.246980.453880.012790.095960.173750.206510.098300.18402
MGVGA0.238640.457460.026830.121360.207090.193810.101110.19233
DeepGate30.279100.501200.034500.133800.218400.211500.112700.21303
DeepGate40.327470.626160.019950.112960.185450.186180.139480.22824
AIGer0.264300.407770.110680.175600.269930.213440.105010.22096
HOGA0.295960.423530.094560.146170.273470.217730.129750.22588

Note: Avg. is the unweighted mean across the seven complete circuits (distinct from the subcircuit population in Appendix A.4). CircuitGate achieves the lowest macro-averaged EQ MAE (0.18402, 4.32% lower than MGVGA's 0.19233) and ranks first on four of the seven circuits, including dft (0.09830).

3. Memory consumption and topological sensitivity. Table R5 reports host and GPU memory on dft under consistent inference-stage boundaries (separate from one-time preprocessing in Appendix A.6: 14.8853 s and 2.73 GiB host RSS).

Table R5. Memory consumption on dft (525,762 nodes).

ModelHost RSS (GiB)GPU Allocated / Reserved (GiB)
CircuitGate0.825.40 / 6.48
MGVGA0.752.15 / 2.87
DeepGate30.621.95 / 2.96
DeepGate41.662.25 / 4.01
AIGer0.991.95 / 3.67
HOGA0.903.82 / 4.59

Comparing hyp (420,769 nodes; logic depth 41,672) and dft (525,762 nodes; logic depth 83; ~502× shallower) highlights robustness to extreme logic depth: CircuitGate maintains stable latencies (360.50 ms vs. 450.17 ms), whereas DeepGate4 jumps from 20,673.17 ms on dft to 251,670.21 ms on hyp (3,269 overlapping partitions vs. 1,942 on dft).

Conclusion. CircuitGate scales to complete, untruncated AIGs up to 525,762 nodes with sub-second inference (< 6.5 GiB GPU memory) and the lowest macro-averaged EQ MAE.

Reviewer_GM6fOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies graph representation learning for And‑Inverter Graphs (AIGs) used in EDA workflows. Existing GNN‑based models for circuits mostly rely on local gate‑level message passing. They struggle to capture full‑circuit global functional information, and their representations break easily when logic synthesis rewires the graph topology without changing circuit functionality.

The authors propose CircuitGate. Its core ideas are three‑fold: first, inject native circuit‑level context features. Second, explicitly encode each gate’s primary‑input (PI) dependencies while accounting for inversion polarity, and compress variable‑size input dependencies into fixed‑length vectors. Third, specially handle reconvergent fan‑in structures common in real circuits, and use input‑overlap statistics to control how global information mixes into local message updates. Boolean‑aware regularization losses are also added to enforce NOT‑ and AND‑gate logical constraints.

Experiments are conducted on ForgeEDA, EPFL and ITC’99 for equivalent‑gate identification and signal‑probability prediction. The authors also run zero‑shot cross‑dataset transfer, representation stability tests under synthesis‑driven topology changes, component ablations, and runtime‑memory profiling for very large circuits. Compared to prior state‑of‑the‑art baselines, CircuitGate cuts MAE by up to 21.7%. It produces much more stable representations under topology rewrites and maintains reasonable inference speed.

Critical strengths
  1. The paper addresses two genuine pain‑points of existing circuit GNNs: global PI dependency and reconvergent fan‑in. Prior models hope global information will propagate through stacked message‑passing layers, which often fails for large circuits. Instead, CircuitGate pre‑computes PI dependencies and applies adaptive gating specifically for reconvergence, rather than naively aggregating all neighbours. This brings two tangible benefits: better task performance, and far more stable representations after synthesis‑driven topology changes — a highly desirable property for real‑world EDA toolchains.
  2. Experiments cover many practical dimensions beyond plain benchmark numbers. Apart from standard metrics on equivalent‑gate identification and signal probability prediction, the paper evaluates zero‑shot cross‑dataset generalization, representation robustness under real logic‑synthesis transformations, plus runtime‑memory overhead on huge circuits. Ablation studies quantify the contribution of each module. The authors consider real‑world industrial concerns instead of only chasing benchmark scores.
Critical weaknesses
  1. Limited technical novelty; many building blocks are assembled from known prior components. Explicit PI‑support analysis is a classic static EDA technique; sketch‑based set compression has been widely used in other graph‑learning domains; conditional gating modules and logic‑based regularization are also established techniques in GNN literature. This work’s main value lies in carefully combining these existing ideas and adapting them for the AIG setting, rather than introducing fundamentally new neural‑network primitives or theoretical insights.
  2. Pre‑computing PI support sets carries risk of worst‑case performance blow‑up. Preprocessing is fast for most test circuits. However, as shown in the appendix, certain circuit families yield extremely large PI‑support sets, causing steep rises in CPU runtime and memory usage. The authors do not propose sampling or approximate sketching workarounds. These pathological circuit instances could become practical show‑stoppers.
Questions for authors
  1. PI‑support sets can blow up on some circuits. Have you explored sampling‑based approximate sketching? Can we retain most performance while cutting preprocessing overhead?
  2. Regarding loss weights for logical regularizers: is there a reasonably transferable range you have observed across different circuit families, or do these hyper‑parameters always need validation‑set tuning for new datasets?
  3. Your reconvergence statistics come from pre‑computed exact PI‑support overlaps. If we remove this preprocessing step and instead let the network estimate overlap purely from learned embeddings, how much performance drop should we expect?
  4. For your robustness evaluation, you rely on simulation plus formal checking to get ground‑truth node‑level correspondences between original and transformed AIGs. Such ground‑truth mappings are unavailable in many real‑world settings. How would you evaluate representation robustness without these paired node labels?
5 comments
AuthorsOpenReview ↗

Response to Reviewer GM6f (1/5): Circuit-Informed Inductive Bias and Architectural Contribution (W1)

We sincerely thank Reviewer GM6f for the thorough, constructive review and for recognizing CircuitGate's clear presentation, circuit-aware modeling of global primary-input (PI) dependencies and reconvergent fanins, zero-shot generalization, synthesis robustness, and runtime/memory profiling.

W1 — Limited technical novelty. We thank the reviewer for this thoughtful comment. We acknowledge that PI-support analysis, sketching, conditional gating, and logic-based regularization have precedents. However, we do not claim to have independently invented these individual principles. Rather, our contribution is a circuit-aware, AIG-specific neural architecture that translates established EDA knowledge and real-world AIG properties into purpose-designed neural modules and learning mechanisms.

Its circuit-informed inductive bias shapes three aspects: (1) encoding global functional dependencies; (2) reconvergent fanin interaction during message passing; and (3) Boolean semantic constraints on learning. Thus, circuit characteristics directly shape how the network represents nodes, propagates information, and learns functional relationships—a unified treatment absent from existing AIG methods. Therefore, CircuitGate is neither a generic GNN simply applied to circuits nor a straightforward assembly of off-the-shelf components; it is purpose-built around AIG structural and functional properties. Our novelty lies in the AIG-specific neural realization and coordinated architectural integration of these principles, rather than in claiming each underlying principle as individually new.

1. Circuit properties as learnable representations. AIG nodes depend not only on local neighborhoods, but also on global PI dependencies, inversion polarity, and circuit roles. Prior AIG methods explored functionality-aware supervision and improved propagation; CircuitGate goes further by explicitly incorporating these circuit-derived properties into node representations and updates. It augments nodes with EDA-native context (logic levels, fanout, output status, PI-support coverage) and propagates even- and odd-inversion support sets S0(v),S1(v)S_0(v), S_1(v), mapping them to fixed-width representations via graph-local PI tokens, normalized sketches, and support statistics: sq(v)=∑p∈Sq(v)tpmax⁡(∣Sq(v)∣,1)s_q(v) = \frac{\sum_{p \in S_q(v)} t_p}{\sqrt{\max(|S_q(v)|, 1)}}. Injected into message-passing updates, PI-support is not merely appended as a statistic; circuit dependency analysis is transformed into a learnable neural representation.

2. Reconvergence as a circuit-conditioned interaction mechanism. Two fanins of an AIG AND gate may share upstream PIs and carry correlated functional context. CircuitGate derives a descriptor rvr_v from same- and cross-parity support overlaps, overlap ratios, shared-support size, and fanin-depth imbalance to condition a learned dependency gate: gv(l)=mvσ(MLPg([rv;MLPs(av(l))]))g_v^{(l)} = m_v \sigma(MLP_g([r_v; MLP_s(a_v^{(l)})])). Crucially, PI-support serves two connected roles: encoding global dependency context and controlling how global context contributes to local updates at reconvergent nodes. This support-overlap-conditioned gating is a purpose-designed AIG neural mechanism, rather than generic gating detached from circuit semantics.

3. Boolean semantics as learning constraints. For complemented AIG edges, CircuitGate enforces signal-probability complementarity p(¬u)=1−p(u)p(\neg u) = 1 - p(u); for AND nodes v=l1∧l2v = l_1 \land l_2 with fanin literals l1,l2l_1, l_2 (accounting for edge polarities), it enforces the Fréchet bounds max⁡(0,p(l1)+p(l2)−1)≤p(v)≤min⁡(p(l1),p(l2))\max(0, p(l_1) + p(l_2) - 1) \le p(v) \le \min(p(l_1), p(l_2)), valid without assuming fanin independence.

4. Evidence for the circuit-specific designs. ForgeEDA ablations confirm each mechanism's contribution (Table R1):

Table R1. Ablation studies on ForgeEDA (EQ MAE ↓).

VariantMAE ↓
Full CircuitGate0.0433
w/o PI-dependency encoding0.0582 (+34.4%)
w/o reconvergence modeling0.0561 (+29.6%)
w/o logic constraints0.0495 (+14.3%)

Cardinality/coverage-only (0.0536) and binary reconvergence flags (0.0454) also underperform Full CircuitGate. In feature- and objective-matched controls (Response to Reviewer VpdF, Part 1/2), equipping DeepGate3 and MGVGA with identical context, PI sketches, reconvergence descriptors, and logic regularization still leaves them at 0.0478 and 0.0485 MAE (9.4% and 10.7% worse), while static MLP (0.0471) and unmasked gating (0.0459) degrade MAE by 8.1% and 5.7% (alongside 0.8341 mean synthesis CKA). These results confirm that the gains stem from coupling circuit-derived knowledge within the neural architecture rather than supplying extra features alone.

AuthorsOpenReview ↗

Response to Reviewer GM6f (2/5): Scalability of PI-Support Preprocessing (W2/Q1)

We thank the reviewer for highlighting this scalability concern and provide targeted experiments to address it.

W2 / Q1. Preprocessing scalability on support-dense circuits and approximate support construction

The reviewer asks whether approximate sampling can reduce PI-support preprocessing overhead while preserving performance.

A2. Response

Exact PI-support construction is efficient for most AIGs but can be costly on exceptionally support-dense circuits. We investigate bounded polarity-aware PI-support sampling, retaining at most kk PI identifiers per polarity without constructing full support sets, and evaluate scalability, feature fidelity, representation consistency, and downstream accuracy.

1. Worst-case scalability and adaptive deployment.

We evaluate nine complete AIGs, including Back_End_With_Decode (658,645 nodes; average support density: 1,565.92).

Table R2. Preprocessing efficiency and adaptive deployment.

CircuitDensityExact (s) ↓Approx-128 (s) ↓Adaptive (s)† ↓Exact / Approx RSS (GiB) ↓
Back_End_With_Decode1565.92546.0440.2841.153.31 / 1.62
max378.010.430.330.360.36 / 0.37
hyp211.4116.3021.1516.540.76 / 1.16
tinyRocket80.263.725.173.910.53 / 0.60
mem_ctrl79.541.071.791.140.40 / 0.44
jpeg20.625.609.695.770.78 / 0.82
dft10.2416.5623.0616.782.62 / 1.36
idft9.9716.5520.8716.772.54 / 1.34
simple_spi8.290.080.100.090.35 / 0.35

† Adaptive uses lightweight topology/support-growth probes to select exact or bounded-sampling preprocessing.

Key findings. On Back_End_With_Decode, Approx-128 reduces preprocessing time from 546.04 s to 40.28 s (13.56×) and peak RSS from 3.31 GiB to 1.62 GiB (−51.1%). Gaussian support-sketch construction drops from 532.05 s to 8.97 s. Adaptive selection retains exact processing on typical circuits while activating sampling where beneficial, with probe overhead below 0.9 s.

2. Structural-functional fidelity of bounded sampling.

We evaluate support cardinality, Jaccard overlap, and reconvergence detection at k∈{64,128}k\in\{64,128\}.

Table R3. Support-feature fidelity at different sampling budgets.

CircuitBudgetCardinality MAPE ↓Jaccard MAE ↓Reconvergence F1 ↑
Back_End_With_Decode646.80%0.010200.9780
Back_End_With_Decode1284.10%0.006810.9910
hyp641.20%0.000310.9920
hyp1280.40%0.000120.9970
max642.70%0.003100.9080
max1281.40%0.001700.9530
dft1280.06%0.000040.9990

Key findings. Approx-128 achieves 0.9910 reconvergence F1 and 0.00681 Jaccard MAE on Back_End_With_Decode, with F1 reaching 0.9970–0.9990 on hyp and dft. Increasing kk consistently improves feature fidelity.

3. Representation and prediction consistency on the highest-density circuit.

We compare exact and approximate features on Back_End_With_Decode under identical frozen CircuitGate weights.

Table R4. Frozen-model consistency on Back_End_With_Decode.

MetricApprox-64Approx-128
Mean gate-embedding cosine ↑0.97580.9916
P5 gate-embedding cosine ↑0.91340.9642
Relative embedding L2L_2 ↓0.14210.0738
Mean absolute SPP prediction drift ↓0.00870.0041
Mean absolute EQ score drift ↓0.01260.0065

Key findings. Approx-128 achieves 0.9916 mean embedding cosine (0.9642 at P5), with prediction drift of only 0.0041 for SPP and 0.0065 for EQ, demonstrating strong frozen-model consistency.

4. Downstream EQ/SPP accuracy under frozen checkpoints.

We evaluate seven labeled OpenABC circuits using identical labels and frozen checkpoints, replacing only support-dependent features without retraining.

Table R5. Mean per-circuit EQ/SPP MAE on OpenABC.

Task (MAE ↓)ExactApprox-64Approx-128
EQ0.184030.186200.18480
SPP0.035010.036400.03550

Key findings. Approx-128 incurs only 0.42% EQ MAE and 1.40% SPP MAE relative increases, maintaining near-exact accuracy without retraining.

Conclusion. These results establish adaptive bounded sampling as an optional scalability optimization for support-dense AIGs, providing substantial preprocessing savings while preserving feature fidelity, representation stability, and near-exact predictive accuracy without changing CircuitGate's core architecture.

AuthorsOpenReview ↗

Response to Reviewer GM6f (3/5): Reconvergence Modeling without Exact PI-Overlap Statistics (Q3)

We sincerely thank the reviewer for asking whether reconvergent-fanin relationships can be inferred directly from learned embeddings without relying on precomputed PI-support overlap statistics.

Q3. Performance impact of removing precomputed PI-support overlap statistics The reviewer asks how much performance change should be expected if the precomputed PI-support overlap step is removed and the network estimates reconvergence overlap purely from learned node embeddings.

A3. Response To answer this directly, we evaluate two complementary ablation settings on ForgeEDA under the identical source-design-disjoint split, 5% training subset, EQ/SPP targets, and validation-based checkpoint selection: (1) retaining the polarity-aware PI encoder while replacing exact overlap descriptors and masks with an embedding-based overlap estimator, and (2) removing explicit PI-support-dependent features more broadly to test fully embedding-driven reconvergence estimation.

1. Replacing exact overlap with embedding-based estimation. Here, a learned estimator takes both fan-in gate embeddings to predict a continuous overlap score and a binary reconvergence indicator, replacing exact overlap inputs to CircuitGate's conditional update (Table R6).

Table R6. Reconvergence ablation on ForgeEDA.

ConfigurationEQ MAE ↓SPP MAE ↓
Full CircuitGate0.043300.02120
Embedding-estimated Overlap + CircuitGate Update0.047200.02310
Embedding-estimated Overlap + Generic Update0.050800.02510
No Reconvergence0.056100.02740

Key findings. Replacing exact PI-support overlap with embedding-estimated signals increases EQ MAE from 0.04330 to 0.04720 (9.0% relative increase) and SPP MAE from 0.02120 to 0.02310 (9.0% relative increase). Notably, pairing embedding-estimated overlap with CircuitGate's conditional update (0.04720) still substantially outperforms both a generic update (0.05080) and removing reconvergence modeling entirely (0.05610), confirming that our conditional gating remains effective even without exact overlap inputs, while exact overlap unlocks its full accuracy.

2. Isolating overlap removal from complete PI-support removal. We further separate removing exact overlap statistics from the stronger setting where explicit global PI-support encodings are also eliminated (Table R7).

Table R7. Dependence on explicit PI-support information on ForgeEDA.

ConfigurationExact PI SketchExact OverlapEQ MAE ↓
Full CircuitGateYesYes0.04330
Embedding-estimated OverlapYesNo0.04720
Fully Embedding-only ReconvergenceNoNo0.05310
No PI Dependency EncodingNoNot separately isolated0.05820

Key findings. Removing exact overlap statistics while retaining the global PI sketch accounts for a 9.0% EQ MAE difference (0.04330 vs. 0.04720), whereas eliminating explicit PI-support encodings altogether (Fully Embedding-only Reconvergence) raises EQ MAE to 0.05310 (22.6% higher than Full CircuitGate), though still improving over omitting PI dependency modeling entirely (0.05820).

3. Why learned embeddings alone cannot fully recover exact reconvergence statistics. We also evaluate how accurately learned embeddings reconstruct exact PI-support overlap on held-out test designs, strictly restricting all estimator supervision to the training split (Table R8).

Table R8. Overlap-estimation quality on held-out circuits.

Input / EstimatorJaccard MAE ↓Reconvergence F1 ↑
Local Embeddings + MLP0.03810.891
Global Context Embeddings + MLP0.02640.927
Exact PI-Support Overlap0.00001.000

Key findings. Global circuit context improves overlap reconstruction over local embeddings alone (0.0264 vs. 0.0381 Jaccard MAE; 0.927 vs. 0.891 F1). However, because message passing progressively smooths long-range path identity across deep reconvergent cones, an irreducible approximation gap (0.0264 Jaccard MAE) remains relative to exact PI-support overlap—explaining why explicit overlap statistics provide structural fidelity unrecoverable from node embeddings alone.

Conclusion. Rather than being redundant, explicit PI-support overlap delivers a 9.0% relative MAE reduction on both EQ and SPP over embedding-estimated overlap (and 22.6% on EQ over fully embedding-only reconvergence). Combined with bounded sampling in Part (2/5)—which recovers 0.9910 reconvergence F1 and preserves OpenABC EQ MAE within 0.42% at 13.56× speedup—CircuitGate captures this structural fidelity without sacrificing scalability.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.