Original: I TERATIVE C IRCUIT R EPAIR A GAINST F ORMAL S PECIFICATIONS
Revised: I TERATIVE C IRCUIT R EPAIR A GAINST F ORMAL S PECIFICATIONS

Original: Anonymous authors

Original: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: We present a deep learning approach for repairing sequential circuits against formal specifications given in linear-time temporal logic (LTL).
Revised: We present a deep learning approach for repairing sequential circuits against formal specifications given in linear-time temporal logic (LTL).

Original: Given a defective circuit and its formal specification, we train Transformer models to output circuits that satisfy the corresponding specification.
Revised: Given a defective circuit and its formal specification, we train Transformer models to output circuits that satisfy the corresponding specification.

Original: We propose a separated hierarchical
Revised: We propose a separated hierarchical

Original: Transformer for multimodal representation learning of the formal specification and the circuit.
Revised: Transformer for multimodal representation learning of the formal specification and the circuit.

Original: We introduce a data generation algorithm that enables generalization to more complex specifications and out-of-distribution datasets.
Revised: We introduce a data generation algorithm that enables generalization to more complex specifications and out-of-distribution datasets.

Original: In addition, our proposed repair mechanism significantly improves the automated synthesis of circuits from LTL specifications with Transformers.
Revised: In addition, our proposed repair mechanism significantly improves the automated synthesis of circuits from LTL specifications with Transformers.

Original: It improves the state-of-theart by 6 . 8 percentage points on held-out instances and 11 .
Revised: It improves the state-of-theart by 6 . 8 percentage points on held-out instances and 11 .

Original: 8 percentage points on an out-of-distribution dataset from the annual reactive synthesis competition.
Revised: 8 percentage points on an out-of-distribution dataset from the annual reactive synthesis competition.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Sequential circuit repair (Katz & Manna, 1975) refers to the task of, given a formal specification and a defective circuit implementation, automatically computing an implementation that satisfies the formal specification.
Revised: Sequential circuit repair (Katz & Manna, 1975) refers to the task of given a formal specification and a defective circuit implementation automatically computing an implementation that satisfies the formal specification.

Original: Circuit repair finds application, especially in formal verification.
Revised: Circuit repair finds application especially in formal verification.

Original: Examples arethe automated  debuggingof circuits after model checking (Clarke, 1997) or the correction of faulty circuit implementations predicted by heuristics such as neural networks (Schmitt et al., 2021).
Revised: Examples are automated circuit debugging after model checking (Clarke, 1997) or correcting faulty circuit implementations predicted by heuristics such as neural networks (Schmitt et al., 2021b).

Original: In this paper, we design and study a deep learning approach to circuit repair for linear-time temporal logic (LTL) specifications (Pnueli, 1977) that also improves the state-of-the-art of synthesizing sequential circuits with neural networks.
Revised: In this paper, we design and study a deep learning approach to circuit repair for linear-time temporal logic (LTL) specifications (Pnueli, 1977) that also improves the state-of-the-art of synthesizing sequential circuits with neural networks.

Original: We consider sequential circuit implementations that continuously interact with their environments.
Revised: We consider sequential circuit implementations that continuously interact with their environments.

Original: For example, an arbiter that manages access to a shared resource interacts with processes by giving out mutually exclusive grants to the shared resource.
Revised: For example, an arbiter that manages access to a shared resource interacts with processes by giving out mutually exclusive grants to the shared resource.

Original: Linear-time temporal logic (LTL) and its dialects (e.g., STL Maler & Nickovic (2004) or CTL Clarke & Emerson (1981)) are widely used in academia and industry to specify the behavior of sequential circuits (e.g., Godhal et al.
Revised: Linear-time temporal logic (LTL) and its dialects (e.g., STL Maler & Nickovic (2004) or CTL Clarke & Emerson (1981)) are widely used in academia and industry to specify the behavior of sequential circuits (e.g., Godhal et al.

Original: ; IEEE (2005); Horak et al.
Revised: ; IEEE (2005); Horak et al.

Original: A typical example is the response property ( r → g ) , stating that it always ( ) holds that request r is eventually ( ) answered by grant g .
Revised: A typical example is the response property ( r → g ) , stating that it always ( ) holds that request r is eventually ( ) answered by grant g .

Original: We can specify an arbiter that manages the access to a shared resource for four processes by combining response patterns for requests r 0 , . . .
Revised: We can specify an arbiter that manages the access to a shared resource for four processes by combining response patterns for requests r 0 , . . .

Original: , r 3 and grants g 0 , . .
Revised: , r 3 and grants g 0 , . .

Original: . , g 3 with a mutual exclusion property as follows:
Revised: . , g 3 with a mutual exclusion property as follows:

Revised: [Equation]

Revised: response properties

Original: [Equation]
Revised: [Equation]

Original: mutual exclusion property
Revised: mutual exclusion property

Original: An implementation of this specification would be a circuit that gives grants based on a round-robin scheduler.
Revised: A possible implementation of this specification is a circuit that gives grants based on a round-robin scheduler.

Original: However, running neural reactive synthesis (Schmitt et al., 2021) on this specification results in a defective circuit as shown in Figure 1a.
Revised: However, running neural reactive synthesis (Schmitt et al., 2021b) on this specification results in a defective circuit as shown in Figure 1a.

Original: After model checking the implementation, we observe that the circuit is not keeping track of counting (missing an AND gate) and that the mutual exclusion property is violated (the same variable controls grants g 0 and g 1 ). 
Revised: After model checking the implementation, we observe that the circuit is not keeping track of counting (missing an AND gate) and that the mutual exclusion property is violated (the same variable controls grants g 0 and g 1 ). [Figure]

Original:  We present the first deep learning approach to repair such faulty circuits, inspired by the successful application of deep learning to the LTL trace generation (Hahn et al., 2022) and reactive synthesis problem (Schmitt et al., 2021).
Revised: [Figure] We present the first deep learning approach to repair such faulty circuits, inspired by the successful application of deep learning to the LTL trace generation (Hahn et al., 2021) and reactive synthesis problem (Schmitt et al., 2021b).

Original: We introduce a new Transformer architecture, the separated hierarchical Transformer , that accounts for the different characteristics of the problem’s input.
Revised: We introduce a new Transformer architecture, the separated hierarchical Transformer , that accounts for the different characteristics of the problem’s input.

Original: The separated hierarchical Transformer combines the advantages of the hierarchical Transformer (Li et al., 2021) with the multimodal representation learning of an LTL specification and a faulty circuit.[Figure] [Figure]
Revised: The separated hierarchical Transformer combines the advantages of the hierarchical Transformer (Li et al., 2021) with the multimodal representation learning of an LTL specification and a faulty circuit.

Original: In particular, it utilizes that LTL specifications typically consist of re-occurring patterns.
Revised: In particular, it utilizes that LTL specifications typically consist of reoccurring patterns.

Original: This architecture can successfully be trained on the circuit repair problem.
Revised: This architecture can successfully be trained on the circuit repair problem.

Original: Our model, for example, produces a correct circuit implementation of the round-robin strategy by repairing the faulty circuit in Figure 1a in only two iterations.
Revised: Our model, for example, produces a correct circuit implementation of the round-robin strategy by repairing the faulty circuit in Figure 1a in only two iterations.

Original: Each iteration predicts apotentially faulty circuit based on the specification and a faulty circuit as input.
Revised: Each iteration predicts a circuit based on the specification and a faulty circuit as input.

Original: The result of the first iteration is shown in Figure 1b.
Revised: The result of the first iteration is shown in Figure 1b.

Original: The circuit remains faulty, with two of the four grants still controlled by the same variable.
Revised: The circuit remains faulty, with two of the four grants still controlled by the same variable.

Original: Progress was made, however, towards a functioning counter: latch l 1 now consists of a combination of AND gates and inverters expressive enough to represent a counter.
Revised: Progress was made, however, towards a functioning counter: latch l 1 now consists of a combination of AND gates and inverters expressive enough to represent a counter.

Original: The second iteration finally results in a correct implementation, as shown in Figure 1c.
Revised: The second iteration finally results in a correct implementation, as shown in Figure 1c.

Original: To effectively train and enable further research on repair models, wewill provide open-source datasets and our open-source implementation1 for the supervised training of the circuit repair problem.
Revised: To effectively train and enable further research on repair models, we provide open-source datasets and our open-source implementation for the supervised training of the circuit repair problem 1 .

Original: We demonstrate that the trained separated hierarchical Transformer architecture generalizes to unseen specifications and faulty circuits.
Revised: We demonstrate that the trained separated hierarchical Transformer architecture generalizes to unseen specifications and faulty circuits.

Original: Further, we show that our approach can be combined with the existing neural method for synthesizing sequential circuits (Schmitt et al., 2021) by repairing its mispredictions, improving the overall accuracy substantially.
Revised: Further, we show that our approach can be combined with the existing neural method for synthesizing sequential circuits (Schmitt et al., 2021b) by repairing its mispredictions, improving the overall accuracy substantially.

Original: We made a significant improvement of 6 . 8 percentage points to a total of 84% on held-out-instances, while an even more significant improvement was made on out-of-distribution datasets with 11 .
Revised: We made a significant improvement of 6 . 8 percentage points to a total of 84% on held-out-instances, while an even more significant improvement was made on out-of-distribution datasets with 11 .

Original: 8 percentage points on samples from the annual reactive synthesis competition SYNTCOMP (Jacobs et al., 2022a).
Revised: 8 percentage points on samples from the annual reactive synthesis competition SYNTCOMP (Jacobs et al., 2022a).

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Circuit repair.
Revised: Circuit repair.

Original: The repair problem is an active field of research dating back to Katz & Manna (1975).
Revised: The repair problem is an active field of research dating back to Katz & Manna (1975).

Original: Jobstmann et al.
Revised: Jobstmann et al.

Original: (2005; 2012) show a game-based approach to repair programs using LTL specifications.
Revised: (2005; 2012) show a game-based approach to repair programs using LTL specifications.

Original: Baumeister et al.
Revised: Baumeister et al.

Original: (2020) propose an approach for synthesizing reactive systems from
Revised: (2020) propose an approach for synthesizing reactive systems from

Original: LTL specifications iteratively through repair steps.
Revised: LTL specifications iteratively through repair steps.

Original: Ahmad et al.
Revised: Ahmad et al.

Original: (2022) presented a framework 
Revised: (2022) presented a framework for automatically repairing defects in hardware design languages like Verilog. Staber et al. (2005) combine fault localization and correction for sequential systems with LTL specifications.

Original: Deep learning for temporal logics and hardware.
Revised: Deep learning for temporal logics and hardware.

Original: Hahn et al.
Revised: Hahn et al.

Revised: ; Schmitt et al.

Original: (2021) initiated the study of deep learning for temporal logics; showing that a Transformer can understand the semantics of temporal and propositional logics.
Revised: (2021a) initiated the study of deep learning for temporal logics; showing that a Transformer can understand the semantics of temporal and propositional logics.

Original: Schmitt et al.
Revised: Schmitt et al.

Original: (2021) successfully applied the Transformer to the reactive synthesis problem.
Revised: (2021b) successfully applied the Transformer to the reactive synthesis problem.

Original: Kreber & Hahn (2021) showed that (W)GANs equipped with Transformer encoders can generate sensible and challenging training data for LTL problems.
Revised: Kreber & Hahn (2021) showed that (W)GANs equipped with Transformer encoders can generate sensible and challenging training data for LTL problems.

Original: Luo et al.
Revised: Luo et al.

Original: apply deep learning to the LTL f satisfiability problem.
Revised: apply deep learning to the LTL f satisfiability problem.

Original: Mukherjee et al.
Revised: Mukherjee et al.

Original: (2022) present a deep learning approach to learn graph representations for LTL model checking.
Revised: (2022) present a deep learning approach to learn graph representations for LTL model checking.

Original: Vasudevan et al.
Revised: Vasudevan et al.

Original: (2021) applied deep learning to learn semantic abstractions of hardware designs. 
Revised: (2021) applied deep learning to learn semantic abstractions of hardware designs. In

Revised: Hahn et al.

Revised: (2022), the authors generate formal specifications from unstructured natural language.

Original: Reactive synthesis.
Revised: Reactive synthesis.

Original: The hardware synthesis problem traces back to Alonzo Church in 1957 (Church, 1963).
Revised: The hardware synthesis problem traces back to Alonzo Church in 1957 (Church, 1963).

Original: Buchi & Landweber (1990) provided solutions, although only theoretically, already in 1969.
Revised: Buchi & Landweber (1990) provided solutions, although only theoretically, already in 1969.

Original: Since then, significant advances in the field have been made algorithmically, e.g., with a quasi-polynomial algorithm for parity games (Calude et al., 2020), conceptually with distributed (Pneuli & Rosner, 1990) and bounded synthesis (Finkbeiner & Schewe, 2013), and on efficient fragments, e.g., GR(1) (Piterman et al., 2006) synthesis.
Revised: Since then, significant advances in the field have been made algorithmically, e.g., with a quasi-polynomial algorithm for parity games (Calude et al., 2020), conceptually with distributed (Pneuli & Rosner, 1990) and bounded synthesis (Finkbeiner & Schewe, 2013), and on efficient fragments, e.g., GR(1) (Piterman et al., 2006) synthesis.

Original: Synthesis algorithms have been developed for hyperproperties (Finkbeiner et al., 2020).
Revised: Synthesis algorithms have been developed for hyperproperties (Finkbeiner et al., 2020).

Original: Recently, deep learning has been successfully applied to the hardware synthesis problem (Schmitt et al., 2021).
Revised: Recently, deep learning has been successfully applied to the hardware synthesis problem (Schmitt et al., 2021b).

Original: Compared to classical synthesis, a deep learning approach is more efficient, with the tradeoff of being inherently incomplete.
Revised: Compared to classical synthesis, a deep learning approach can be more efficient, with the tradeoff of being inherently incomplete.

Original: The field can build on a rich supply of tools (e.g. (Bohy et al., 2012; Faymonville et al., 2017; Meyer et al., 2018a)).
Revised: The field can build on a rich supply of tools (e.g. (Bohy et al., 2012; Faymonville et al., 2017; Meyer et al., 2018a)).

Original: A yearlysynthesis competition (SYNTCOMP) (Jacobs & P ´ erez) is held at CAV.
Revised: A yearly competition (SYNTCOMP) (Jacobs & P ´ erez) is held at CAV.

Original:  D ATASETS
Revised:  D ATASETS

Original: We build on the reactive synthesis dataset from Schmitt et al.
Revised: We build on the reactive synthesis dataset from Schmitt et al.

Original: (2021), where each sample consists of two entries: a formal specification in LTL and a target circuit that implements the specification given in the AIGER format.
Revised: (2021b), where each sample consists of two entries: a formal specification in LTL and a target circuit that implements the specification given in the AIGER format.

Original: We construct a dataset for the circuit repair problem that consists of three entries: a formal specification in LTL, a defective circuit, and the corrected target circuit.
Revised: We construct a dataset for the circuit repair problem that consists of three entries: a formal specification in LTL, a defective circuit, and the corrected target circuit.

Original: In Section 3.1, we give details of the domain-specific languages for the circuit repair problem’s input.
Revised: In Section 3.1, we give details of the domain-specific languages for the circuit repair problem’s input.

Original: Section 3.2 describes the data generation process and summarizes the dataset that resulted in the best-performing model (see Section 6 for ablations).
Revised: Section 3.2 describes the data generation process and summarizes the dataset that resulted in the best-performing model (see Section 6 for ablations).

Original: We approach the generation of the dataset from two angles: 1) we collect mispredictions, i.e., faulty circuits predicted by a neural model, and 2) we introduce semantic errors to correct circuits in a way that they mimic human mistakes.
Revised: We approach the generation of the dataset from two angles: 1) we collect mispredictions, i.e., faulty circuits predicted by a neural model, and 2) we introduce semantic errors to correct circuits in a way that they mimic human mistakes.

Original: 3. L INEAR - TIME T EMPORAL L OGIC (LTL) AND A ND -I NVERTER G RAPHS (AIGER)
Revised: 3. L INEAR - TIME T EMPORAL L OGIC (LTL) AND A ND -I NVERTER G RAPHS (AIGER)

Original: LTL specifications.
Revised: LTL specifications.

Original: The specification consists of two lists of sub-specifications: assumptions and guarantees .
Revised: The specification consists of two lists of sub-specifications: assumptions and guarantees .

Original: Assumptions pose restrictions on the environment behavior, while guarantees describe how the circuit has to react to the environment.
Revised: Assumptions pose restrictions on the environment behavior, while guarantees describe how the circuit has to react to the environment.

Original: They jointly build an LTL specification as follows: spec :
Revised: They jointly build an LTL specification as follows: spec :

Original: = ( assumption 1 ∧ · · · ∧ assumption n ) → ( guarantee 1 ∧ · · · ∧ guarantee m ) .
Revised: = ( assumption 1 ∧ · · · ∧ assumption n ) → ( guarantee 1 ∧ · · · ∧ guarantee m ) .

Original: A specification is called realizabile if there exists a circuit implementing the required behavior and called unrealizable if no such circuit exists.
Revised: A specification is called realizabile if there exists a circuit implementing the required behavior and called unrealizable if no such circuit exists.

Original: For example, an implementation can be unrealizable if there are contradictions in the required behavior, or if the environment assumptions are not restrictive enough.
Revised: For example, an implementation can be unrealizable if there are contradictions in the required behavior, or if the environment assumptions are not restrictive enough.

Original: Formally, an LTL specification is defined over traces through the circuit.
Revised: Formally, an LTL specification is defined over traces through the circuit.

Original: A circuit C satisfies an LTL specification φ if all possible traces through the circuit Traces C satisfy the specification, i.e., if ∀ t ∈ Traces C .
Revised: A circuit C satisfies an LTL specification φ if all possible traces through the circuit Traces C satisfy the specification, i.e., if ∀ t ∈ Traces C .

Original: t | = φ .
Revised: t | = φ .

Original: For example, the LTL formula ( ¬ g 0 ∨¬ g 1 ) from the arbiter example in Section 3.1 requires all traces through the circuit to respect mutual exclusive behavior between gand g 1 .
Revised: For example, the LTL formula ( ¬ g 0 ∨¬ g 1 ) from the arbiter example in Section 3.1 requires all traces through the circuit to respect mutual exclusive behavior between gand g 1 .

Original: If a specification is realizable, the target circuit represents the implementation, and if a specification is unrealizable, the target circuit represents the counter-strategy of the environment showing that no such implementation exists.
Revised: If a specification is realizable, the target circuit represents the implementation, and if a specification is unrealizable, the target circuit represents the counter-strategy of the environment showing that no such implementation exists.

Original: The formal semantics of LTL can be found in Appendix A. 
Revised: The formal semantics of LTL can be found in Appendix A. probability do 6: l U C ▷

Revised: Remove line l of C 8: else 9: pos ∼ U number positions in C )

Original:  AIGER format.
Revised: ▷ position uniformly 10: var ′ ← var ← variable number at position pos C 11: while var = var ′ do 12: var ′ ∼ N d σ v 2 , 0 , 61) ▷ from truncated Gaussian 13: replace variable number at position pos in C with var ′ AIGER format.

Original: The defective and target circuits, are in a text-based representation of And-Inverter
Revised: The defective and target circuits, are in a text-based representation of And-Inverter

Original: Graphs called AIGER Format (Brummayer et al., 2007); see, for example, bottom-right of Figure 1.
Revised: Graphs called AIGER Format (Brummayer et al., 2007); see, for example, bottom-right of Figure 1.

Original: A line in the AIGER format defines nodes such as latches (flip-flops) and AND-gates by defining the inputs and outputs of the respective node.
Revised: A line in the AIGER format defines nodes such as latches (flip-flops) and AND-gates by defining the inputs and outputs of the respective node.

Original: Connections between nodes are described by the variable numbers used as the input and output of nodes.
Revised: Connections between nodes are described by the variable numbers used as the input and output of nodes.

Original: A latch is defined by one input and one output connection, whereas two inputs and one output connection define an AND gate.
Revised: A latch is defined by one input and one output connection, whereas two inputs and one output connection define an AND gate.

Original: Inputs and do 5: probability p delete do 6: l ∼ U number lines

Original: C )

Original: ▷ number uniformly 7: Remove line l of C 8: else 9: pos ∼ U (1 , number of positions in C ) ▷ position uniformly 10: var ′ ← var ← variable number at position pos in C 11: while var = var ′ do 12: var ′ ∼ N d var, σ v 2 , 0 , 61) ▷ from discrete truncated Gaussian 13: replace variable number at position pos in C with var ′ outputs of the whole circuit are defined through lines with a single variable number that describes the connection to a node.
Revised: Inputs and outputs of the whole circuit are defined through lines with a single variable number that describes the connection to a node.

Original: The parity of the variable number implicitly gives negations.
Revised: The parity of the variable number implicitly gives negations.

Original: Hence, two consecutive numbers describe the same connection, with odd numbers representing the negated value of the preceding even variable number.
Revised: Hence, two consecutive numbers describe the same connection, with odd numbers representing the negated value of the preceding even variable number.

Original: The numbers 0 and 1 stand for the constants False and True .
Revised: The numbers 0 and 1 are the constants False and True .

Original: The full definition of AIGER circuits can be found in Appendix B.
Revised: The full definition of AIGER circuits can be found in Appendix B.

Original: 3. D ATA G ENERATION
Revised: 3. D ATA G ENERATION

Original: We replicated the neural circuit synthesis model of Schmitt et al.
Revised: We replicated the neural circuit synthesis model of Schmitt et al.

Revised: (2021b)

Original: and evaluated the model with all specifications from their dataset while keeping the training, validation, and test split separate.
Revised: and evaluated the model with all specifications from their dataset while keeping the training, validation, and test split separate.

Original: We evaluated with a beam size of 3 , resulting in a dataset RepairRaw of roughlyspecifications and corresponding (possibly faulty) circuits in the training split and about 72000 in the validation and test split, respectively.
Revised: We evaluated with a beam size of 3 , resulting in a dataset RepairRaw of roughly 580specifications and corresponding (possibly faulty) circuits in the training split and about 72 000 in the validation and test split, respectively.

Original: We model-check each predicted circuit against its specification with nuXmv (Cavada et al., 2014) to classify defective implementations into the following classes.
Revised: We model-check each predicted circuit against its specification with nuXmv (Cavada et al., 2014) to classify defective implementations into the following classes.

Original: A sample is violated if the predicted circuit is defective, i.e., violates the specification ( 55% ).
Revised: A sample is violated if the predicted circuit is defective, i.e., violates the specification ( 55% ).

Original: A sample is matching if the prediction of the synthesis model is completely identical to the target circuit in the dataset ( 16% ).
Revised: A sample is matching if the prediction of the synthesis model is completely identical to the target circuit in the dataset ( 16% ).

Original: Lastly, a sample is satisfied when the predicted circuit satisfies the specification (or represents a correct counter-strategy) but is no match ( 29% ), which regularly happens as a specification has multiple correct implementations.
Revised: Lastly, a sample is satisfied when the predicted circuit satisfies the specification (or represents a correct counter-strategy) but is no match ( 29% ), which regularly happens as a specification has multiple correct implementations.

Original: For example, consider our round-robin scheduler from the introduction: the specification does not specify the order in which the processes are given access to the resource.
Revised: For example, consider our round-robin scheduler from the introduction: the specification does not specify the order in which the processes are given access to the resource.

Original: We construct our final dataset from RepairRaw in two steps.
Revised: We construct our final dataset from RepairRaw in two steps.

Original: In the first step, we consider the violating samples, i.e., mispredictions of the neural circuit synthesis network, which are natural candidates for a circuit repair dataset.
Revised: In the first step, we consider the violating samples, i.e., mispredictions of the neural circuit synthesis network, which are natural candidates for a circuit repair dataset.

Original: In the second step, we introduce mistakes inspired by human errors into correct implementations (see Figure 7 in the appendix for an overview of the dataset generation and its parameters).
Revised: In the second step, we introduce mistakes inspired by human errors into correct implementations (see Figure 6 in the appendix for an overview of the dataset generation and its parameters).

Original: In the following, we describe these steps in detail.
Revised: In the following, we describe these steps in detail.

Original: Mispredictions of neural circuit synthesis.
Revised: Mispredictions of neural circuit synthesis.

Original: We first consider the violating samples from
Revised: We first consider the violating samples from

Original: RepairRaw .
Revised: RepairRaw .

Original: Likewise to a specification having multiple correct implementations, a defective circuit has multiple possible fixes, leading to correct yet different implementations.
Revised: Likewise to a specification having multiple correct implementations, a defective circuit has multiple possible fixes, leading to correct yet different implementations.

Original: For a given defective circuit, a fix can thus either be small and straightforward or lengthy and complicated.
Revised: For a given defective circuit, a fix can thus either be small and straightforward or lengthy and complicated.

Original: In a supervised learning setting, this leads us to the issue of misleading target circuits .
Revised: In a supervised learning setting, this leads us to the issue of misleading target circuits .

Original: This concerns samples where only a lengthy and complicated fix of the faulty circuit leads to the target circuit,  although a minor fix would also lead to a correct but different implementation.
Revised: This concerns samples where only a lengthy and complicated fix of the faulty circuit leads to the target circuit, [Figure] although a minor fix would also lead to a correct but different implementation.

Original: We identify misleading targets by searching for alternative solutions with the synthesis model (up to a beam size of 4 ).
Revised: We identify misleading targets by searching for alternative solutions with the synthesis model (up to a beam size of 4 ).

Original: If the model finds a correct alternative circuit with a smaller Levenshtein distance (see Appendix C for a definition) to the faulty circuit, a fix leading to the alternative circuit is smaller than a fix to the original target.
Revised: If the model finds a correct alternative circuit with a smaller Levenshtein distance (see Appendix C for a definition) to the faulty circuit, a fix leading to the alternative circuit is smaller than a fix to the original target.

Original: The target circuit will be replaced accordingly with the alternative circuit.
Revised: The target circuit will be replaced accordingly with the alternative circuit.

Original: We select all samples with a Levenshtein distance to the target circuit ≤ 50 for the final dataset.[Figure]
Revised: We select all samples with a Levenshtein distance to the target circuit ≤ 50 for the final dataset.

Original: Introducing errors.
Revised: Introducing errors.

Original: We propose Algorithm 1, which probabilistically introduces human-like mistakes into correct circuits.
Revised: We propose Algorithm 1, which probabilistically introduces human-like mistakes into correct circuits.

Original: Such mistakes include missing latches, AND gates, or inverters and miswired connections between the components.
Revised: Such mistakes include missing latches, AND gates, or inverters and miswired connections between the components.

Original: First, we determine the number of mistakes or changes we will introduce to the circuit.
Revised: First, we determine the number of mistakes or changes we will introduce to the circuit.

Original: For that, we sample from a discrete truncated normal distribution around zero, with a standard deviation of 7 . 5 and bounds from 1 to 50 .
Revised: For that, we sample from a discrete truncated normal distribution around zero, with a standard deviation of 7 . 5 and bounds from 1 to 50 .

Original: For each change, we flip a coin with the probability of p delete = 0 .
Revised: For each change, we flip a coin with the probability of p delete = 0 .

Original: 2 for deleting a line from the AIGER circuit and 1 − p delete = 0 .
Revised: 2 for deleting a line from the AIGER circuit and 1 − p delete = 0 .

Original: 8 for changing a variable number.
Revised: 8 for changing a variable number.

Original: For deleting , we uniformly choose a line from the
Revised: For deleting , we uniformly choose a line from the

Original: AIGER circuit to remove.
Revised: AIGER circuit to remove.

Original: We do not remove inputs or outputs to stay consistent with the dataset.
Revised: We do not remove inputs or outputs to stay consistent with the dataset.

Original: For changing a variable number, we uniformly choose a position of a variable number.
Revised: For changing a variable number, we uniformly choose a position of a variable number.

Original: The position can be an input, output, inbound edge(s), or outbound edge of a latch or AND gate.
Revised: The position can be an input, output, inbound edge(s), or outbound edge of a latch or AND gate.

Original: We replace the variable number at this position with a new variable number that is determined by sampling a discrete truncated normal distribution around the old variable number, a standard deviation of 10 , and bounds given by the minimal and maximal possible variable number in the dataset ( 0 to 61 ).
Revised: We replace the variable number at this position with a new variable number that is determined by sampling a discrete truncated normal distribution around the old variable number, a standard deviation of 10 , and bounds given by the minimal and maximal possible variable number in the dataset ( 0 to 61 ).

Original: The new variable number cannot be the mean itself to ensure a definite change.
Revised: The new variable number cannot be the mean itself to ensure a definite change.

Original: For a visualization of the discrete truncated normal distributions, see Figure 8 in the appendix.
Revised: For a visualization of the discrete truncated normal distributions, see Figure 7 in the appendix.

Original: Lastly, we spot-check altered circuits by model-checking to determine whether introduced changes create a faulty circuit.
Revised: Lastly, we spot-check altered circuits by model-checking to determine whether introduced changes create a faulty circuit.

Original: Only in less than 2% of the cases the circuit still satisfies the specification.
Revised: Only in less than 2% of the cases the circuit still satisfies the specification.

Original: Final Dataset.
Revised: Final Dataset.

Original: In the final dataset Repair , 61% of the samples contain circuits with errors introduced by Algorithm 1, while the others are based on mispredicted circuits.
Revised: In the final dataset Repair , 61% of the samples contain circuits with errors introduced by Algorithm 1, while the others are based on mispredicted circuits.

Original: In 38% of cases, the samples have a Levenshtein distance of less than 10 between the repair circuit and the target circuit.
Revised: In 38% of cases, the samples have a Levenshtein distance of less than 10 between the repair circuit and the target circuit.

Original: In total, the Levenshtein distance in the dataset has a mean of 15 .
Revised: In total, the Levenshtein distance in the dataset has a mean of 15 .

Original: 7 with a standard deviation of 12 . 77 , and the median is at 13 (see Figure 9 in Appendix D for its composition).
Revised: 7 with a standard deviation of 12 . 77 , and the median is at 13 (see Figure 8 in Appendix D for its composition).

Original:  A RCHITECTURE
Revised:  A RCHITECTURE

Original: In this section, we introduce the separated hierarchical Transformer architecture, a variation of the hierarchical Transformer Li et al.
Revised: In this section, we introduce the separated hierarchical Transformer architecture, a variation of the hierarchical Transformer Li et al.

Original: (2021), and provide further details on our architectural setup.
Revised: (2021), and provide further details on our architectural setup.

Revised: The hierarchical Transformer has been shown to be superior to a vanilla Transformer in many applications including logical and mathematical problems Li et al.

Revised: ; Schmitt et al.

Revised: (2021b).

Revised: The hierarchical Transformer, as well as the novel separated hierarchical Transformer, is invariant against the order of the assumptions and guarantees in the specification.

Original: 4. S EPARATED H IERARCHICAL T RANSFORMER
Revised: 4. S EPARATED H IERARCHICAL T RANSFORMER

Original: The encoder of a hierarchical Transformer contains two types of hierarchically structured layers.
Revised: The encoder of a hierarchical Transformer contains two types of hierarchically structured layers.

Original: Local layers only see parts of the input, while global layers handle the combined output of all local layers.
Revised: Local layers only see parts of the input, while global layers handle the combined output of all local layers.

Original: Contrary to the original Transformer, the input is decomposed into multiple partitions before being fed into the local layers.
Revised: Contrary to the original Transformer, the input is partitioned before being fed into the local layers.

Original: Positional Encoding is applied separately to each partition of the input.
Revised: A positional encoding is applied separately to each partition of the input.

Original: Model parameters are shared between the local layers, but no attention can be calculated between tokens in different partitions.
Revised: Model parameters are shared between the local layers, but no attention can be calculated between tokens in different partitions.

Original: The hierarchical Transformer has been beneficial to understanding repetitive structures in mathematics (Li et al., 2021) and has shown to be superior for processing LTL specifications (Schmitt et al., 2021). [Figure]
Revised: The hierarchical Transformer has been beneficial to understanding repetitive structures in mathematics (Li et al., 2021) and has shown to be superior for processing LTL specifications (Schmitt et al., 2021b).

Original: We extend the hierarchical Transformer to a separated hierarchical Transformer, which has two types of local layers: Each separated local layer is an independent encoder; therefore, separated local layers do not share any model parameters.
Revised: We extend the hierarchical Transformer to a separated hierarchical Transformer, which has two types of local layers: Each separated local layer is an independent encoder; therefore, separated local layers do not share any model parameters.

Original: Attention calculations are done independently for each local layer.
Revised: Attention calculations are done independently for each local layer.

Original: A visualization of the proposed Architecture is shown in Figure 2.
Revised: A visualization of the proposed Architecture is shown in Figure 2.

Original: Shared local layers are identical to local layers in the hierarchical Transformer.
Revised: Shared local layers are identical to local layers in the hierarchical Transformer.

Original: A separated local layer contains one or more shared local layers.
Revised: A separated local layer contains one or more shared local layers.

Original: The results of the separated and shared local layers are concatenated and fed into the global layer.
Revised: The results of the separated and shared local layers are concatenated and fed into the global layer.

Original: While the number of shared local layers does not change the model size, multiple separated local layers introduce slightly more model parameters.
Revised: While the number of shared local layers does not change the model size, multiple separated local layers introduce slightly more model parameters.

Original: The separated hierarchical
Revised: The separated hierarchical

Original: Transformer handles multiple independent inputs that differ in structure, type, or length better.
Revised: Transformer handles multiple independent inputs that differ in structure, type, or length better.

Original: 4. A RCHITECTURAL S ETUP
Revised: 4. A RCHITECTURAL S ETUP

Original: We separate the specification and the faulty circuit with a separate local layer.
Revised: We separate the specification and the faulty circuit with a separate local layer.

Original: The specification is partitioned into its guarantees and assumptions, which we feed into shared local layers.
Revised: The specification is partitioned into its guarantees and assumptions, which we feed into shared local layers.

Original: Let
Revised: Let

Original: Attention be the attention function of Vaswani et al.
Revised: Attention be the attention function of Vaswani et al.

Original: (2017) (see Appendix J).
Revised: (2017) (see Appendix K).

Original: When identifying the assumptions assumption 1 , · · · , assumption n and guarantees guarantee 1 , · · · , guarantee m with specification properties p 1 , . .
Revised: When identifying the assumptions assumption 1 , · · · , assumption n and guarantees guarantee 1 , · · · , guarantee m with specification properties p 1 , . .

Original: . , p n + m , the following computations are performed in a shared local layer:[Equation] p
Revised: . , p n + m , the following computations are performed in a shared local layer:

Original: [Equation]
Revised: [Equation]

Original: p [Equation] , where H p i denotes the stacked representations of all positions of specification property p i .
Revised: p n + m } , where H p i denotes the stacked representations of all positions of specification property p i .

Original: Therefore, the attention computation is limited between tokens in each guarantee and between tokens in each assumption while the learned parameters W QS , W KS , W VS are shared between all guarantees and assumptions.
Revised: Therefore, the attention computation is limited between tokens in each guarantee and between tokens in each assumption while the learned parameters W QS , W KS , W VS are shared between all guarantees and assumptions.

Original: The separated local layer that processes the circuit performs the attention computation:
Revised: The separated local layer that processes the circuit performs the attention computation:

Original: [Equation]
Revised: [Equation]

Original: , where H C denotes the stacked representations of all positions of the circuit.
Revised: where H C denotes the stacked representations of all positions of the circuit.

Original: Therefore, the computation is performed over all tokens in the circuit but the parameters W QC , W KC , W VC are different from the parameters for the specification (see Figure 2).
Revised: Therefore, the computation is performed over all tokens in the circuit but the parameters W QC , W KC , W VC are different from the parameters for the specification (see Figure 2).

Original: For embedding and tokenization, we specialize in the Domain Specific Language (DSL) of LTL formulas and AIGER circuits with only a few symbols.
Revised: For embedding and tokenization, we specialize in the Domain Specific Language (DSL) of LTL formulas and AIGER circuits with only a few symbols.

Original: For every symbol in the DSL, we introduce a token.
Revised: For every symbol in the DSL, we introduce a token.

Original: Variables in properties (i.e., assumptions and guarantees) are limited to five inputs i 0 · · · iand five outputs o 0 · · · o 4 , for each of which we introduce a token.
Revised: Variables in properties (i.e., assumptions and guarantees) are limited to five inputs i 0 · · · iand five outputs o 0 · · · o 4 , for each of which we introduce a token.

Original: In the AIGER format (used for the faulty circuit and the target circuit), we fix the variable numbers to the range of 0 to 61 , thereby indirectly limiting the size of the circuit. These limitations are a good trade-off between token set size and expressible complexity.
Revised: In the AIGER format (used for the faulty circuit and the target circuit), we fix the variable numbers to the range of 0 to 61 , thereby indirectly limiting the size of the circuit, while allowing for reasonable expressiveness.

Original: We set a special token as a prefix to the circuit embedding to encode the presumed realizability of the specification.
Revised: We set a special token as a prefix to the circuit embedding to encode the presumed realizability of the specification.

Original: This determines whether the circuit represents a satisfying circuit or a counter strategy.
Revised: This determines whether the circuit represents a satisfying circuit or a counter strategy.

Original: We embed the tokens by applying a one-hot encoding which we multiply with a learned embedding matrix.
Revised: We embed the tokens by applying a one-hot encoding which we multiply with a learned embedding matrix.

Original: Properties have a tree positional encoding (Shiv & Quirk, 2019) as introduced for LTL formulas by (Hahn et al., 2022).
Revised: Properties have a tree positional encoding (Shiv & Quirk, 2019) as used for LTL formulas by (Hahn et al., 2021).

Original: This encoding incorporates the tree structure of the LTL formula into the positional encoding and allows easy calculations between tree relations.
Revised: This encoding incorporates the tree structure of the LTL formula into the positional encoding and allows easy calculations between tree relations.

Original: For this encoding, we fix a maximal branching size and the maximal depth of the tree.

Original: For circuits, we use the standard linear positional encoding from Vaswani et al.[Figure]
Revised: For circuits, we use the standard linear positional encoding from Vaswani et al.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: In this section, we report on experimental results.
Revised: In this section, we report on experimental results.

Original: We first describe our training setup in Section 5.
Revised: We first describe our training setup in Section 5.

Original: before evaluating the model with two different methods.
Revised: before evaluating the model with two different methods.

Original: The model evaluation shows the evaluation  of the repair model on thetest split of the Repair dataset (Section 5.2).
Revised: The model evaluation shows the evaluation [Figure] of the repair model on the Repair dataset distribution(Section 5.2).

Original: In the synthesis pipeline evaluation , the repair model is evaluated on the predictions of the synthesis model and then repeatedly evaluated on its predictions (Section 5.3).
Revised: In the synthesis pipeline evaluation , the repair model is evaluated on the predictions of the synthesis model and then repeatedly evaluated on its predictions (Section 5.3).

Original: We differentiate between syntactic and semantic accuracy in both evaluations, following Hahn et al.
Revised: We differentiate between syntactic and semantic accuracy, following Hahn et al.

Original: A sample is considered semantically correct if the prediction satisfies the specification.
Revised: A sample is considered semantically correct if the prediction satisfies the specification.

Original: We consider the predicted circuit syntactically correct if it is identical to the target circuit.
Revised: We consider the prediction syntactically correct if it is identical to the target.

Original: The semantic accuracy is typically higher than the syntactic, as it also considers alternative solutions.

Original: 5. T RAINING S ETUP
Revised: 5. T RAINING S ETUP

Original: We trained a separated hierarchical Transformer with 4 heads in all attention layers, 4 stacked local layers in both separated local layers, and 4 stacked layers in the global layer.
Revised: We trained a separated hierarchical Transformer with 4 heads in all attention layers, 4 stacked local layers in both separated local layers, and 4 stacked layers in the global layer.

Original: The decoder stack contains 8 stacked decoders.
Revised: The decoder stack contains 8 stacked decoders.

Original: The embedding size in the decoder and encoder is 256 and all feedforward networks have a size of 1024 and use the Rectified Linear Unit (ReLU) activation function.
Revised: The embedding size in the decoder and encoder is 256 and all feedforward networks have a size of 1024 and use the Rectified Linear Unit (ReLU) activation function.

Original: We use the Adam optimizer (Kingma & Ba, 2017) with β 1 = 0 .
Revised: We use the Adam optimizer (Kingma & Ba, 2017) with β 1 = 0 .

Original: 9 , β 2 = 0 .
Revised: 9 , β 2 = 0 .

Original: 98 and ϵ = 10 − 9 and 4000 warmup steps with an increased learning rate, as proposed in Vaswani et al.
Revised: 98 and ϵ = 10 − 9 and 4000 warmup steps with an increased learning rate, as proposed in Vaswani et al.

Original: We trained on an single GPU of a NVIDIA DGX A100 system with a batch size of 256 for 20000 steps.
Revised: We trained on an single GPU of a NVIDIA DGX A100 system with a batch size of 256 for 20 000 steps.

Original: We restricted the specification input to 5 inputs and 5 outputs, no more than 12 properties (assumptions + guarantees) and no properties of a size of its abstract syntax tree (AST) greater than 25 .
Revised: We restricted the specification input to 5 inputs and 5 outputs, no more than 12 properties (assumptions + guarantees) and no properties of a size of its abstract syntax tree (AST) greater than 25 .

Original: In this section, we give results and insights into the best-performing model (see Section 6 for ablations).

Original: 5. M ODEL E VALUATION
Revised: 5. M ODEL E VALUATION

Original: We evaluated the model up to a beam size of 16 .
Revised: We evaluated the model up to a beam size of 16 .

Original: The key results of the model evaluation can be found at the top of Table 1.
Revised: The key results of the model evaluation can be found at the top of Table 1.

Original: With a beam size of 16 , the model outputs a correct implementation in 84% of the cases on a single try.
Revised: With a beam size of 16 , the model outputs a correct implementation in 84% of the cases on a single try.

Original: When analyzing the beams, we found that the model shows enormous variety when fixing the circuits.
Revised: When analyzing the beams, we found that the model shows enormous variety when fixing the circuits.

Original: Almost half of the beams result in correct implementations.
Revised: Almost half of the beams result in correct implementations.

Original: To investigate if the model performs a repair operation, we identify samples where the model copied the defective circuit ( Violated (Copy) ).
Revised: To investigate if the model performs a repair operation, we identify samples where the model copied the defective circuit ( Violated (Copy) ).

Original: The model only copied 31 of 1024 samples.
Revised: The model only copied 31 of 1024 samples.

Original: We, additionally, track if the predicted circuit contains syntax errors, which rarely happens (a total of 8 errors out of every beam).
Revised: We, additionally, track if the predicted circuit contains syntax errors, which rarely happens (a total of 8 errors out of every beam).

Original: We provide insight into the model’s performance by analyzing a) what exactly makes a sample challenging to solve for the model and b) if the model makes significant improvements towards the target circuit even when the prediction violates the specification.
Revised: We provide insight into the model’s performance by analyzing a) what exactly makes a sample challenging to solve for the model and b) if the model makes significant improvements towards the target circuit even when the prediction violates the specification.

Original: Difficulty measures.
Revised: Difficulty measures.

Original: We consider three parameters to measure the difficulty of solving a specific repair problem: the size of the specification (the LTL formula’s AST), the size of the target circuit (AND gates + latches), and the Levenshtein distance between the defective circuit and the target circuit.
Revised: We consider three parameters to measure the difficulty of solving a specific repair problem: the size of the specification (the LTL formula’s AST), the size of the target circuit (AND gates + latches), and the Levenshtein distance between the defective circuit and the target circuit.

Original: The Levenshtein distance is the dominant indicator of a sample’s difficulty (see Figure 4).
Revised: The Levenshtein distance is the dominant indicator of a sample’s difficulty (see Figure 3).

Original: However, the specification and circuit size is, perhaps surprisingly, less of a factor (see Figureand Figure 11 in the appendix).
Revised: However, the specification and circuit size is, perhaps surprisingly, less of a factor (see Figureand Figure 10 in the appendix).

Original: This indicates that our approach has the potential to scale up to larger circuits when increasing the model size.
Revised: This indicates that our approach has the potential to scale up to larger circuits when increasing the model size.

Original: [Figure] Levenshtein distance improvement.
Revised: Improvement measures.

Original: We analyze whether a violating prediction is still an improvement by calculating the difference between the distance of the faulty input and target circuit lev ( C i , C t ) and the distance between prediction and target circuit lev ( C p , C t ) .
Revised: We semantically and syntactically approximate whether a violating prediction is still an improvement over the faulty input circuit. For syntactic improvement, we calculate the difference between the distance of the faulty input and target circuit lev ( C i , C t ) and the distance between prediction and target circuit lev ( C p , C t ) .

Original: If the difference is below zero: lev ( C p , C t ) − lev ( C f , C t ) < 0 , the model  improved the faulty circuit towards the target circuit.
Revised: If the difference is below zero: lev ( C p , C t ) − lev ( C f , C t ) < 0 , the model syntactically improved the faulty circuit towards the target circuit.

Original: In Figure 3, we show a violin plot of the improvement.
Revised: On our test set, violated circuits improved by − 9 . 98 edits on average. For semantic improvement, we obtained a set of sub-specifications by creating a new specification with each [Figure]

Original: We observe that for all predictions, regardless if they are realizable or unrealizable specifications, the prediction is generally an improvement compared to  the defective circuit. Since this holds for violating and satisfying predictions alike, we conjecture that even violating predictions are still an improvement compared to  the previous faulty circuit. 
Revised: guarantee from the original specification: Let a 1 to a n be the original assumptions and g 1 to g m the original guarantees, the set of sub-specifications is defined as { ( a 1 ∧ · · · ∧ a n ) → g i | 1 ≤ i ≤ m } . We approximate that, the more sub-specifications a circuit satisfies, the closer it is semantically to a correct circuit. On our test set, in 75 . 9% , the prediction satisfied more sub-specifications, and in 2 . 4% , the prediction satisfied fewer sub-specifications.

Original: Forthe interested reader, we evaluate on a more symbolic metric inAppendix K, coming to the same conclusion.
Revised: For a more detailed insight, we supported violin plots for syntactic (Figure 12) and semantic (Figure 13) improvement in the Appendix.

Original: This poses the natural question if the model’s performance can be increased by iteratively querying the model on its predictions.
Revised: Since in both approximations, even violating predictions are an improvement over the faulty input, this poses the natural question if the model’s performance can be increased by iteratively querying the model on its predictions.

Original: In the next section, we investigate this more in-depth by applying our repair model iteratively to the prediction of a neural circuit synthesis model including real-world examples.
Revised: In the next section, we investigate this more in-depth by applying our repair model iteratively to the prediction of a neural circuit synthesis model including real-world examples.

Original: 5. S YNTHESIS P IPELINE E VALUATION
Revised: 5. S YNTHESIS P IPELINE E VALUATION

Original: We demonstrate how our approach can be used to improve the current state-of-the-art for neural reactive synthesis (see Figure 6).
Revised: We demonstrate how our approach can be used to improve the current state-of-the-art for neural reactive synthesis (see Figure 5).

Original: We first evaluate the synthesis model we replicated from Schmitt et al.
Revised: We first evaluate the synthesis model we replicated from Schmitt et al.

Revised: (2021b).

Original: If the predicted circuit violates the specification, we feed the specification together with the violating circuit into our repair model.
Revised: If the predicted circuit violates the specification, we feed the specification together with the violating circuit into our repair model.

Original: If the prediction still violates the specification after applying the repair model once, we re-feed the specification with the new violating circuit into the repair model until it is solved.
Revised: If the prediction still violates the specification after applying the repair model once, we re-feed the specification with the new violating circuit into the repair model until it is solved.

Original: Using the presented pipeline, we improve the results of Schmitt et al.
Revised: Using the presented pipeline, we improve the results of Schmitt et al.

Original: (2021) significantly, as shown in the bottom half of Table 1.
Revised: (2021b) significantly, as shown in the bottom half of Table 1.

Revised: We evaluate heldout samples from the synthesis dataset and out-of-distribution benchmarks and filtered out samples that exceed our input restrictions (see Section 5.1).

Revised: The datasets test contain randomly sampled held-out instances from the repair and neural synthesis dataset, respectively.

Revised: Figure 4 shows an in-depth analysis of the status changes of the samples when applying the synthesis pipeline

Original: [Table]
Revised: [Table]

Original: ModelChecking Circuit (Prediction) (Faulty
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: circuit

Original: Specification(inLTL)

Original: Specification(inLTL)

Original: HierarchicalTransformer
Revised: HierarchicalTransformer

Original: ModelChecking r e p ea t
Revised: ModelChecking r e p ea t

Original: I t e r a ti v e C i r c u it R
Revised: I t e r a ti v e C i r c u it R

Original: e p a
Revised: e p a

Original: i r
Revised: i r

Original: N e u r a l
Revised: N e u r a l

Original: C i r c u it
Revised: C i r c u it

Original: S yn t
Revised: S yn t

Original: h e s i s
Revised: h e s i s

Original: Circuit (Prediction)
Revised: Circuit (Prediction)

Original: SeparatedHierarchicalTransformer
Revised: SeparatedHierarchicalTransformer

Original: We evaluate held-out samples from the synthesis dataset and out-of-distribution benchmarks and filtered out samples that exceed our input restrictions (see Section 5.1).

Original: The datasets test contain randomly sampled held-out instances from the repair and neural synthesis dataset, respectively.

Original: Figure 5 shows an in-depth analysis of the status changes of the samples when applying the synthesis pipeline.

Original: Light and dark green represent the instances that were additionally solved with our repair approach; gray represent the instances that were already initially solved by the synthesis network.
Revised: Light and dark green represent the instances that were additionally solved with our repair approach; gray represent the instances that were already initially solved by the synthesis network.

Original: The problem becomes increasingly more challenging with a larger target circuit size.
Revised: The problem becomes increasingly more challenging with a larger target circuit size.

Original: In total, we achieve an improvement of 6 . 8 percentage points.
Revised: In total, we achieve an improvement of 6 . 8 percentage points.

Original:  The dataset timeouts consists of held-outsynthesis samples that the classical state-of-the-art synthesizer  Strix (Meyer et al., 2018b) could not solve inless than 120 s or 1 h. We achieve an improvement of 6 .9 percentage points.
Revised: To show that our improvement over the state-of-the-art is not due to scaling but rather a combination of new training data, architecture and iterative evaluation, we additionally scaled the model from Schmitt et al. (2021b) to match or exceed the number of parameters of our model. The parameter-matched models only lead to insignificant improvements over the base model (see Table 2 in the Appendix). We further identified a set of held-out samples were our approach performs significantly better than the classical stateof-the-art synthesizer tool Strix (Meyer et al., 2018b): Samples in timeouts could not been solved by Strix in 1 h, of which we still achieve 34 .

Revised: 2% with an improvement of 8 . 1 percentage points.

Original: Even more significant improvement can be observed in real-world samples from the annual synthesis competitions and out-of-distribution benchmarks: The dataset smart home are benchmarks for synthesizing properties over smart home applications (Geier et al., 2022), where we improve by 11 .
Revised: Even more significant improvement can be observed in real-world samples from the annual synthesis competitions and out-of-distribution benchmarks: The dataset smart home are benchmarks for synthesizing properties over smart home applications (Geier et al., 2022), where we improve by 11 .

Original: 8 percentage points.
Revised: 8 percentage points.

Original: The dataset syntcomp contains benchmarks from the annual reactive synthesis competitionbenchmark (Jacobs et al., 2022a;b), where the model pipeline improves the state-of-the-art by 23 .
Revised: The dataset syntcomp contains benchmarks from the annual reactive synthesis competition (Jacobs et al., 2022a;b), where the model pipeline improves the state-of-the-art by 23 .

Original: 8 percentage points and even by 19 percentage points by applying it once.
Revised: 8 percentage points and even by 19 percentage points by applying it once.

Original:  A BLATIONS
Revised:  A BLATIONS

Original: We performed various ablation studies that the interested reader can find in the appendix.
Revised: We performed various ablation studies that the interested reader can find in the appendix.

Original: In particular, we parameterized our data generationmethod for constructing the circuit repair dataset (see 
Revised: In particular, we parameterized our data generation for constructing the circuit repair dataset (see Figure 6 in

Original: Figure 7 in Appendix D).
Revised: Appendix D).

Original: An extensive table that contains over 100 generated datasets can be found in datasets.xlsx in the supplementary material.
Revised: An extensive collection of over 100 generated datasets are available through our code at GitHub 2 .

Original: We trained 39 models models based on these datasets and different hyperparameters.
Revised: We trained various models based on these datasets and different hyperparameters, also available at GitHub.

Original: An extensive table that contains the results of all trained models can be found in models.xlsx in the supplementary material.

Original: A hyperparameter study can be found in Figure 2 in Appendix G. A more in-depth analysis of the results of different models tested in the synthesis pipeline can be found in Appendix H. All datasets and models will be published after the double-blind reviewing phase.
Revised: A hyperparameter study can be found in Figure 3 in Appendix I. An in-depth analysis of the results of different models tested in the synthesis pipeline can be found in Appendix J.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, we studied the first application of neural networks to the circuit repair problem.
Revised: In this paper, we studied the first application of neural networks to the circuit repair problem.

Original: We introduced the separated hierarchical Transformer to account for the multiple independent inputs of the problem.
Revised: We introduced the separated hierarchical Transformer to account for the multimodal input of the problem.

Original: We provided a data generation method with a novel algorithm for introducing errors to circuit implementations.
Revised: We provided a data generation method with a novel algorithm for introducing errors to circuit implementations.

Original: A separated hierarchical Transformer model was successfully trained to repair defective sequential circuits.
Revised: A separated hierarchical Transformer model was successfully trained to repair defective sequential circuits.

Original: The resulting model was used to significantly improve the state-of-the-art in neural circuit synthesis.
Revised: The resulting model was used to significantly improve the state-of-theart in neural circuit synthesis.

Original: Additionally, our experiments indicate that the separated hierarchical Transformer has the potential to scale up to even larger circuits.
Revised: Additionally, our experiments indicate that the separated hierarchical Transformer has the potential to scale up to even larger circuits.

Original: Our approach can find applications in the broader hardware verification community.
Revised: Our approach can find applications in the broader hardware verification community.

Original: Possible applications include the automated debugging of defective hardware after model checking or testing.
Revised: Possible applications include the automated debugging of defective hardware after model checking or testing.

Original: Due to its efficiency, a well-performing neural repair method reduces the necessary human interaction in the hardware design process.
Revised: Due to its efficiency, a well-performing neural repair method reduces the necessary human interaction in the hardware design process.

Original: The benefit of a deep learning approach to the circuit repair problem is the scalability and generalization capabilities of deep neural networks: this allows for an efficient re-feeding of faulty circuits into the network when classical approaches suffer from the problem’s high computational complexity.
Revised: The benefit of a deep learning approach to the circuit repair problem is the scalability and generalization capabilities of deep neural networks: this allows for an efficient re-feeding of faulty circuits into the network when classical approaches suffer from the problem’s high computational complexity.

Original: Moreover, neural networks generalize beyond classical repair operations, whereas classical approaches are limited in their transformations, such as the limitation of replacing boolean functions.
Revised: Moreover, neural networks generalize beyond classical repair operations, whereas classical approaches are limited in their transformations, such as the limitation of replacing boolean functions.

Original: Future work includes, for example, the extension of our approach to hardware description languages, such as VHDL or Verilog, and the extension to other specification languages that express security policies, such as noninterference or observational determinism.
Revised: Future work includes, for example, the extension of our approach to hardware description languages, such as VHDL or Verilog, and the extension to other specification languages that express security policies, such as noninterference or observational determinism.

Original: R EPRODUCIBILITY STATEMENT
Revised: R EPRODUCIBILITY STATEMENT

Original: We will make the models, datasets, code, and guides  available after the double-blind reviewing phase to ensure anonymity during this phase.
Revised: All models, datasets, code, and guides are available in the corresponding code repository.

Original: All our datasets and models mentioned in the paper and supplementary files ( datasets.xlsx and models.xlsx ), the code of the data generation method and the code for training new models as well as evaluating existing models will be published under an open-source license (MIT License).
Revised: All our datasets and models mentioned in the paper, the code of the data generation method, and the code for training new models as well as evaluating existing models is licensed the open-source MIT License.

Original: Multiple Jupyter notebooks guide the interested reader through the use of the code to allow low-effort reproducibility of all our results and encourage fellow researchers to use, extend and build on our work.
Revised: Multiple Jupyter notebooks guide the interested reader through the use of the code to allow loweffort reproducibility of all our results and encourage fellow researchers to use, extend and build on our work.

Original: A L INEAR - TIME T EMPORAL L OGIC (LTL)
Revised: A L INEAR - TIME T EMPORAL L OGIC (LTL)

Original: The syntax of linear-time temporal logic (LTL) Pnueli (1977) is given as follows.
Revised: The syntax of linear-time temporal logic (LTL) Pnueli (1977) is given as follows.

Original: [Equation]
Revised: [Equation]

Original: where p is an atomic proposition p ∈ AP .
Revised: where p is an atomic proposition p ∈ AP .

Original: In this context, we assume that the set of atomic propositions AP can be partitioned into inputs I and outputs O : AP =
Revised: In this context, we assume that the set of atomic propositions AP can be partitioned into inputs I and outputs O : AP =

Original: I ˙ ∪ O .
Revised: I ˙ ∪ O .

Original: The semantics of LTL is defined over a set of traces: TR :
Revised: The semantics of LTL is defined over a set of traces: TR :

Original: = (2 AP ) ω .
Revised: = (2 AP ) ω .

Original: Let π ∈ TR be trace, π [0] the starting element of a trace π and for a k ∈ N and be π [ k ] be the kth element of the trace π .
Revised: Let π ∈ TR be trace, π [0] the starting element of a trace π and for a k ∈ N and be π [ k ] be the kth element of the trace π .

Original: With π [ k, ∞ ] we denote the infinite suffix of π starting at k .
Revised: With π [ k, ∞ ] we denote the infinite suffix of π starting at k .

Original: We write π | = φ for the trace π satisfies the formula φ .
Revised: We write π | = φ for the trace π satisfies the formula φ .

Original: For a trace π ∈ TR , p ∈ AP and formulas φ the semantics of LTL is defined as follows:
Revised: For a trace π ∈ TR , p ∈ AP and formulas φ the semantics of LTL is defined as follows:

Original: • π | = ¬ φ iff π ̸| =
Revised: • π | = ¬ φ iff π ̸| =

Original: φ • π | = p iff p ∈ π [0] ; π | = ¬ p iff p ̸∈ π [0] • π | = φ 1 ∧ φ 2 iff π | = φ 1 and π | =
Revised: φ • π | = p iff p ∈ π [0] ; π | = ¬ p iff p ̸∈ π [0] • π | = φ 1 ∧ φ 2 iff π | = φ 1 and π | =

Original: φ• π | = φ iff π [1] | = φ • π | = φ 1 U φ 2 iff ∃ l ∈ N : ( π [ l, ∞ ] | = φ 2 ∧ ∀ m ∈ [0 , l − 1] : π [ m, ∞ ] | = φ 1 ) .
Revised: φ• π | = φ iff π [1] | = φ • π | = φ 1 U φ 2 iff ∃ l ∈ N : ( π [ l, ∞ ] | = φ 2 ∧ ∀ m ∈ [0 , l − 1] : π [ m, ∞ ] | = φ 1 ) .

Original: We use further temporal and boolean operators that can be derived from the ones defined above.
Revised: We use further temporal and boolean operators that can be derived from the ones defined above.

Original: That includes ∨ , → , ↔ as boolean operators and the following temporal operators:
Revised: That includes ∨ , → , ↔ as boolean operators and the following temporal operators:

Original: • φ 1 R φ 2 (release) is defined as ¬ ( ¬ φ 1 U ¬ φ 2 ) • φ (globally) is defined as false R φ • φ (eventually) is defined as true U φ .
Revised: • φ 1 R φ 2 (release) is defined as ¬ ( ¬ φ 1 U ¬ φ 2 ) • φ (globally) is defined as false R φ • φ (eventually) is defined as true U φ .

Original: R EACTIVE S YNTHESIS
Revised: R EACTIVE S YNTHESIS

Original: Reactive synthesis is the task to find a circuit C that satisfies a given formal specification φ , i.e., ∀ t ∈ Traces C .
Revised: Reactive synthesis is the task to find a circuit C that satisfies a given formal specification φ , i.e., ∀ t ∈ Traces C .

Original: t | = φ , or determine that no such circuit exists.
Revised: t | = φ , or determine that no such circuit exists.

Original: We consider formal specifications that are formulas over a set of atomic propositions ( AP ) in LTL.
Revised: We consider formal specifications that are formulas over a set of atomic propositions ( AP ) in LTL.

Original: The specification defines the desired behavior of a system based on a set of input and output variables.
Revised: The specification defines the desired behavior of a system based on a set of input and output variables.

Original: As the system, we consider circuits, more precisely a text representation of And-Inverter Graphs, called AIGER circuits.
Revised: As the system, we consider circuits, more precisely a text representation of And-Inverter Graphs, called AIGER circuits.

Original: And-Inverter
Revised: And-Inverter

Original: Graphs connect input and output edges using AND gates, NOT gates (inverter), and memory cells (latches).
Revised: Graphs connect input and output edges using AND gates, NOT gates (inverter), and memory cells (latches).

Original: B A ND -I NVERTER G RAPHS
Revised: B A ND -I NVERTER G RAPHS

Original: And-Inverter Graphs are graphs that describe hardware circuits.
Revised: And-Inverter Graphs are graphs that describe hardware circuits.

Original: The graph connects input edges with output edges through AND gates, latches, and implicit NOT gates.
Revised: The graph connects input edges with output edges through AND gates, latches, and implicit NOT gates.

Original: We usually represent this graph by a text version called the AIGER Format Brummayer et al.
Revised: We usually represent this graph by a text version called the AIGER Format Brummayer et al.

Original: The AIGER format uses variable numbers that define variables.
Revised: The AIGER format uses variable numbers that define variables.

Original: Variables can be interpreted as wired connections in a circuit or as edges in a graph, where gates and latches are nodes.
Revised: Variables can be interpreted as wired connections in a circuit or as edges in a graph, where gates and latches are nodes.

Original: • A negation is implicitly encoded by distinguishing between even and odd variable numbers.
Revised: • A negation is implicitly encoded by distinguishing between even and odd variable numbers.

Original: Two successive variable numbers represent the same variable, the even variable number represents the non-negated variable, and the odd variable number represents the negated variable.
Revised: Two successive variable numbers represent the same variable, the even variable number represents the non-negated variable, and the odd variable number represents the negated variable.

Original: The variable numbers 0 and 1 have the constant values FALSE and TRUE .
Revised: The variable numbers 0 and 1 have the constant values FALSE and TRUE .

Original: • Each input and output edge is defined by a single variable number, respectively.
Revised: • Each input and output edge is defined by a single variable number, respectively.

Original: • An AND gate is defined by three variable numbers.
Revised: • An AND gate is defined by three variable numbers.

Original: The first variable number defines the outbound edge of the AND gate, and the following two variable numbers are inbound edges.
Revised: The first variable number defines the outbound edge of the AND gate, and the following two variable numbers are inbound edges.

Original: The value of the outbound variable is determined by the conjunction of the values of both inbound variables.
Revised: The value of the outbound variable is determined by the conjunction of the values of both inbound variables.

Original: • A latch is defined by two variable numbers: an outbound edge and an inbound edge.
Revised: • A latch is defined by two variable numbers: an outbound edge and an inbound edge.

Original: The value of the outbound variable is the value of the inbound 
Revised: The value of the outbound variable is the value of the inbound variable at the previous time step.

Original: variable at the previous time step In the first time step, the outbound variable is initialized as FALSE .
Revised: In the first time step, the outbound variable is initialized as FALSE .

Original: The AIGER format starts with a header, beginning with the letters aag and following five nonnegative integers M, I, L, O, A with the following meaning:
Revised: The AIGER format starts with a header, beginning with the letters aag and following five nonnegative integers M, I, L, O, A with the following meaning:

Original: [Equation]
Revised: [Equation]

Original: After the header, each line represents a definition of either input, latch, output, or AND gate in this order.
Revised: After the header, each line represents a definition of either input, latch, output, or AND gate in this order.

Original: The numbers in the header define the number of lines associated with each type.
Revised: The numbers in the header define the number of lines associated with each type.

Original: After the definition of the circuit, an optional symbol table might follow, where we can define names for inputs, outputs, latches, and AND gates.
Revised: After the definition of the circuit, an optional symbol table might follow, where we can define names for inputs, outputs, latches, and AND gates.

Original: In this context, the circuit can either describe a satisfying system or a counter strategy to the specification.
Revised: In this context, the circuit can either describe a satisfying system or a counter strategy to the specification.

Original: C L EVENSHTEIN D ISTANCE
Revised: C L EVENSHTEIN D ISTANCE

Original: The Levenshtein distance is an edit distance metric, measuring the degree of distinction between two strings.
Revised: The Levenshtein distance is an edit distance metric, measuring the degree of distinction between two strings.

Original: Let s 1 and s 2 two given strings, then the Levenshtein distance lev ( s 1 , s 2 ) is a the number of actions necessary to transform string s 1 into string s 2 or vice versa.
Revised: Let s 1 and s 2 two given strings, then the Levenshtein distance lev ( s 1 , s 2 ) is a the number of actions necessary to transform string s 1 into string s 2 or vice versa.

Original: Possible actions are deletions, insertions, and substitutions.
Revised: Possible actions are deletions, insertions, and substitutions.

Original: D D ATA G ENERATION
Revised: D D ATA G ENERATION

Original: In Figure 7 we sketch the data generation process.
Revised: In Figure 6 we sketch the data generation process.

Original: The base of the process is the evaluation of a model for neural circuit synthesis.
Revised: The base of the process is the evaluation of a model for neural circuit synthesis.

Original: This is parameterized as multiple beam size are possible.
Revised: This is parameterized as multiple beam size are possible.

Original: For mispredicted samples, we replace misleading targets (see Section 3.2).
Revised: For mispredicted samples, we replace misleading targets (see Section 3.2).

Original: This is optional but our experiments showed that the training benefits from this step.
Revised: This is optional but our experiments showed that the training benefits from this step.

Original: Up to a given Levenshtein distance, we collect samples for the final dataset.
Revised: Up to a given Levenshtein distance, we collect samples for the final dataset.

Original: All other samples (greater Levenshtein distances and correct predictions) are processed in Section 3.2 and Algorithm 1.
Revised: All other samples (greater Levenshtein distances and correct predictions) are processed in Section 3.2 and Algorithm 1.

Original: This process is optional, can be applied to only some samples and is also parameterized.
Revised: This process is optional, can be applied to only some samples and is also parameterized.

Original: The results can be used for the final dataset or are, depending on various parameters, discarded.
Revised: The results can be used for the final dataset or are, depending on various parameters, discarded.

Original: [Figure]
Revised: [Figure]

Original: FINAL DATASET
Revised: FINAL DATASET

Original: Figure 8 shows the probability mass function for the used truncated normal distributions used in
Revised: Figure 7 shows the probability mass function for the used truncated normal distributions used in

Original: Algorithm 1.
Revised: Algorithm 1.

Original: Figure 9 shows the composition of the final dataset.
Revised: Figure 8 shows the composition of the final dataset.

Original: Samples are sorted into bins depending on the Levenshtein distance between its faulty circuit and its target circuit.
Revised: Samples are sorted into bins depending on the Levenshtein distance between its faulty circuit and its target circuit.

Original: While yellow shows all samples 
Revised: While yellow shows all samples in the final dataset, blue only shows samples in the final dataset that are based on Section 3.2 and red only shows samples that are based on Section 3.2.

Original: [Figure]
Revised: [Figure]

Original: number of changes per sample new variable number
Revised: number of changes per sample new variable number

Original: [Figure]
Revised: [Figure]

Original: [Figure]
Revised: [Figure]

Original: depicted 
Revised: depicted samples

Original: [Figure]
Revised: [Figure]

Original: [Figure] [Figure]
Revised: Levenshtein distance between repair circuit and

Original: [Figure]
Revised: [Figure]

Original: c oun t in the blue only shows samples the final dataset

Original: In Figure 10, we show the composition three alternative datasets.
Revised: In Figure 9, we show the composition three alternative datasets.

Original: Samples are sorted into bins depending on Levenshtein distance between its faulty circuit and its target circuit.
Revised: Samples are sorted into bins depending on Levenshtein distance between its faulty circuit and its target circuit.

Original: The dataset scpa-repair-alter-19 ( blue ) shows a dataset that is solely based on Section 3.2.
Revised: The dataset scpa-repair-alter-19 ( blue ) shows a dataset that is solely based on Section 3.2.

Original: Datasets scpa-repair-gen-108 and scpa-repair-gen-96 ( red and yellow ) are the two best performing datasets from all datasets we trained and based on a mixture of Section 3.2 and Section 3.2.
Revised: Datasets scpa-repair-gen-108 and scpa-repair-gen-96 ( red and yellow ) are the two best performing datasets from all datasets we trained and based on a mixture of Section 3.2 and Section 3.2.

Original: Dataset scpa-repair-gen-96 (yellow) is the dataset presented in this paper.
Revised: Dataset scpa-repair-gen-96 (yellow) is the dataset presented in this paper.

Original: For insights into the other datasets and their parameters, we refer to the file datasets.xlsx .

Original: E D IFFICULTY M EASURES
Revised: E D IFFICULTY M EASURES

Original: Figure 11 and Figure 12 (together with Figure 4) show predictions of the presented model, sorted into bin by specification and target size as well as Levenshtein distance between faulty input circuit and target circuit.
Revised: Figure 10 and Figure 11 (together with Figure 3) show predictions of the presented model, sorted into bin by specification and target size as well as Levenshtein distance between faulty input circuit and target circuit.

Original: We use beam search (beam size 16) and only display the result of the best beam.
Revised: We use beam search (beam size 16) and only display the result of the best beam.

Revised: Different colors depict the different classes, a sample is sorted into, i.e. violated for a prediction that violates the specification and violated (copy) for a prediction that additionally is identical to the faulty input.

Revised: satisfied for correct predictions and match for predictions that additionally are identical to the target circuit.

Original: Different colors depict the different classes, a sample is sorted
Revised: The line shows the semantic accuracy smoothed over several bins. [Figure] [Figure] [Figure]

Original: [Figure]
Revised: [Figure]

Revised: F I MPROVEMENT M EASURES

Original: c oun t 
Revised: Figure 12 shows the Levenshtein distance difference ( lev ( C p , C t ) − lev ( C f , C t ) ) between faulty input circuit and prediction. A value below zero implies syntactic improvement towards the target circuit. Figure 13 shows the number of satisfied sub-specifications. The more sub-specifications a circuit satisfies, the closer it semantically is to a correct circuit.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: F A RBITER
Revised: G A RBITER

Original: Here, we repeat the arbiter from Figure 1, with the AIGER format for all circuits on the left of each graph representation.
Revised: Here, we repeat the arbiter from Figure 1, with the AIGER format for all circuits on the left of each graph representation.

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Table] [Table] [Figure] 
Revised: [Figure] [Table]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: G HYPERPARAMETER S TUDY
Revised: H S CALING P ARAMETERS

Original: We trained several versions of a model on the presented dataset ( scpa-repair-gen-96 ) as a hyperparameter study shown in Table 2.
Revised: In this experiment [Table] we scaled the synthesis model (Schmitt et al., 2021b) to match or exceed the number of parameters of our model.

Original: [Table] [Table] [Table]
Revised: This shows that the increased number of parameters of the separated hierarchical Transformer is not the reason for the overall increase in performance. The detailed results are shown in Table 2.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table] [Table]
Revised: We trained several versions of a model on the presented dataset ( scpa-repair-gen-96 ) as a hyperparameter study shown in Table 3.

Original: H E XPERIMENTS
Revised: J A BLATIONS

Original: Figure 14 shows the semantic accuracy of an evaluation of the pipeline with a beam size of 16 .
Revised: Figure 15 shows the semantic accuracy of an evaluation of the pipeline with a beam size of 16 .

Original: If a sample has been solved correctly it will be counted as correct for all further iterations.
Revised: If a sample has been solved correctly it will be counted as correct for all further iterations.

Original: We show the results of the model presented in this paper exp-repair-gen-96-0 ( blue ) and two further models.
Revised: We show the results of the model presented in this paper exp-repair-gen-96-0 ( blue ) and two further models.

Original: The model exp-repair-alter-19-0 ( green ) shows a model trained on a dataset that is solely based on Section 3.2.
Revised: The model exp-repair-alter-19-0 ( green ) shows a model trained on a dataset that is solely based on Section 3.2.

Original: Model exp-repair-gen-108-0 and exp-repair-gen-96- ( red and blue ) are the two best performing models and trained on a mixture of Section 3.2 and
Revised: Model exp-repair-gen-108-0 and exp-repair-gen-96- ( red and blue ) are the two best performing models and trained on a mixture of Section 3.2 and

Original: Section 3.2.
Revised: Section 3.2.

Original: For insights into the datasets, see Figure 10 and datasets.xlsx .
Revised: For insights into the datasets, see Figure 9. parameters [Table] [Table]

Original: [Figure]
Revised: [Table] [Table] results [Table]

Revised: loss 0.

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: validation

Revised: [Table]

Revised: loss 0.

Revised: accuracy 0.

Revised: (per

Revised: [Table]

Revised: beam size0.

Revised: beam size0.

Revised: test splitbeam size0.

Revised: beam size0.

Original: [Figure]
Revised: [Figure]

Original: In Figure 15, we display all models that were trained on different datasets.
Revised: In Figure 16, we display all models that were trained on different datasets.

Original: For all training, we used the same hyperparameters.
Revised: For all training, we used the same hyperparameters.

Original: We plot the accuracy improvement in the pipeline, hence the performance on the reactive synthesis task on the y-axis.
Revised: We plot the accuracy improvement in the pipeline, hence the performance on the reactive synthesis task on the y-axis.

Original: On the x-axis, we depict the validation accuracy, hence the performance on the circuit repair problem.
Revised: On the x-axis, we depict the validation accuracy, hence the performance on the circuit repair problem.

Original: Further, the pipeline accuracy improvement is based on the same distribution for all models, while the validation accuracy is based on the respective datasets used for training the model.
Revised: Further, the pipeline accuracy improvement is based on the same distribution for all models, while the validation accuracy is based on the respective datasets used for training the model.

Original: We can see that models having a higher pipeline accuracy are trained with a dataset that included evaluation results (Section 3.2) instead of altered circuits (Section 3.2).
Revised: We can see that models having a higher pipeline accuracy are trained with a dataset that included evaluation results (Section 3.2) instead of altered circuits (Section 3.2).

Original: This is not surprising, as these datasets are closer to the distribution, on which the pipeline accuracy is based.
Revised: This is not surprising, as these datasets are closer to the distribution, on which the pipeline accuracy is based.

Original: We can identify several clusters of models, of which one cluster (yellow) has relatively good validation accuracy and very good pipeline accuracy improvement.
Revised: We can identify several clusters of models, of which one cluster (yellow) has relatively good validation accuracy and very good pipeline accuracy improvement.

Original: All models in this cluster improve the synthesis accuracy by more than 5 percentage points, with the highest gain of 6 . 8 percentage points by the model exp-repair-gen-96-0 .
Revised: All models in this cluster improve the synthesis accuracy by more than 5 percentage points, with the highest gain of 6 . 8 percentage points by the model exp-repair-gen-96-0 .

Original: [Figure]
Revised: [Figure]

Original: ac
Revised: ac

Original: [Figure]
Revised: [Figure]

Original: In Figure
Revised: In Figure

Original: [Figure]
Revised: [Figure]

Original: we plot the mean and median of the Levenshtein distance between the faulty circuit and the target circuit for all models we trained.
Revised: we plot the mean and median of the Levenshtein distance between the faulty circuit and the target circuit for all models we trained.

Original: In the Figure 16a, the plot is dependent on the validation accuracy (the accuracy of the repair problem) and in Figure 16b the plot is dependent on the pipeline accuracy improvement (performance on the synthesis task).
Revised: In the Figure 17a, the plot is dependent on the validation accuracy (the accuracy of the repair problem) and in Figure 17b the plot is dependent on the pipeline accuracy improvement (performance on the synthesis task).

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table] 
Revised: [Table] [Figure] [Table] [Figure]

Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table][Figure] [Table] [Figure]
Revised: [Table]

Original: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table][Figure] [Table] [Figure]
Revised: [Table]

Original: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: -r e p a i r-
Revised: r e p a i r-

Original: g e n --e xp -r e p a i r-
Revised: g e n --e xp -r e p a i r-

Original: a lt e r13 -e xp -r e p a i r-
Revised: a lt e r13 -e xp -r e p a i r-

Original: a lt e r19 -e xp -r e p a
Revised: a lt e r19 -e xp -r e p a

Original: i r-
Revised: i r-

Original: g e n --e xp -r e p a
Revised: g e n --e xp -r e p a

Original: i r-
Revised: i r-

Original: g e n --e xp -r e p a
Revised: g e n --e xp -r e p a

Original: i r-
Revised: i r-

Original: g e n108 -e xp -r e p a i r-
Revised: g e n108 -e xp -r e p a i r-

Original: g e n --
Revised: g e n --

Original: [Figure]
Revised: [Figure]

Original: I S CALING P ARAMETERS
Revised: K S CALED DOT PRODUCT ATTENTION

Original: In this experiment, we scaled the synthesis model (Schmitt et al., 2021) to match or exceed the number of parameters of our model. This shows that the increased number of parameters of the separated hierarchical Transformer is not the reason for the overall increase in performance. The detailed results are shown in Table 3.

Original: [Table]

Original: [Figure]

Original: [Table] [Figure] [Table] J S CALED DOT PRODUCT ATTENTION (V ASWANI ET AL ., 2017) 
Revised: For a set of queries, keys and values packed into the matrices Q (queries), K (keys) and V (values), the scaled dot product attention (Vaswani et al., 2017) is defined as:

Original: [Equation]
Revised: [Equation]

Original: K M ETRIC OF S ATISFIED S UB -S PECIFICATION

Original: While the Levenshtein distance is widely and easily applicable, its expressiveness regarding improvement between the input circuit and the model’s prediction is limited to syntactical differences.

Original: To elucidate the semantic improvement between a faulty input circuit and the prediction of our model, we conducted an experiment on realizable samples: We constructed a set of subspecifications by creating a new specification with each guarantee from the original specification:

Original: Let a 1 to a n be the original assumptions and g 1 to g m the original guarantees, the set of subspecifications is defined as { ( a 1 ∧ · · · ∧ a n ) → g i | 1 ≤ i ≤ m } .

Original: We count the number of sub-specifications satisfied by the faulty circuit and the prediction.

Original: Any circuit satisfying the original (realizable) specification satisfies all sub-specifications.

Original: The more sub-specifications a circuit satisfies, the closer it is to a correct circuit.

Original: On our test set, in 75.9%, the prediction satisfied more sub-specifications, and in 2.4%, the prediction satisfied fewer sub-specs.

Original: In 21.7%, the prediction did not improve according to this metric.

Original: We show a more detailed plot in Figure

Original: L R EPAIRING C IRCUITS FROM P ARTIAL S PECIFICATIONS
Revised: L R EPAIRING C IRCUITS FROM P ARTIAL S PECIFICATIONS

Original: To show the widespread applicability of our approach, we conduct another experiment.
Revised: To show the widespread applicability of our approach, we conduct another experiment.

Original: With a classical synthesis tool, we generated a test set of potentially faulty circuits from specifications where we removed the last one or two guarantees compared to the original spec.
Revised: With a classical synthesis tool, we generated a test set of potentially faulty circuits from specifications where we removed the last one or two guarantees compared to the original spec.

Original: This method ensures that only 7 . 8% of these circuits still satisfy the original specification.
Revised: This method ensures that only 7 . 8% of these circuits still satisfy the original specification.

Original: We evaluated (not trained) our model on these out-of-distribution circuits and achieved 71 .
Revised: We evaluated (not trained) our model on these out-of-distribution circuits and achieved 71 .

Original: 4% semantic accuracy after up to 5 iterations (see Table 4).
Revised: 4% semantic accuracy after up to 5 iterations (see Table 4).

Original: We further looked into the status of the samples broken down by (original) specification size and target size (see Figures 18 and 19).
Revised: We further looked into the status of the samples broken down by (original) specification size and target size (see Figures 18 and 19).

Original: While overall results demonstrate the successful application of our model to this problem, it is noticeable that the model produces more syntax errors, most notably in larger circuits and specifications.
Revised: While overall results demonstrate the successful application of our model to this problem, it is noticeable that the model produces more syntax errors, most notably in larger circuits and specifications.

Original: Especially compared to Figures 11 and 12), where the model did not produce any circuits with syntax errors.
Revised: Especially compared to Figures 10 and 11), where the model did not produce any circuits with syntax errors.

Original: This is most likely because the defective circuits in this test are out-of-distribution.
Revised: This is most likely because the defective circuits in this test are out-of-distribution.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: afterfirst iteration after
Revised: after

Original: [Table]
Revised: [Table]

Original: n 
Revised: n partial -

Original: [Table]
Revised: [Table]

Original: n partial64 .

Original: 4% (+7 . 2)
Revised: [Table]