Optimization - Revision history

N00basaurus: Linked the speed section to the tick article

2025-09-10T20:06:35Z

Linked the speed section to the tick article

← Older revision		Revision as of 20:06, 10 September 2025
Line 12:		Line 12:
	== Speed ==		== Speed ==
	Speed is the time it takes for a signal to propagate through a circuit.		Speed is the time it takes for a signal to propagate through a circuit.
	In Logic World, most gates have a delay of 1 tick. The more sequential gates you have, the slower the circuit will be.		In Logic World, most gates have a delay of 1 [[tick]]. The more sequential gates you have, the slower the circuit will be.
	When you have cycles or feedback in your circuit, speed becomes even more critical.		When you have cycles or feedback in your circuit, speed becomes even more critical.
	In complex circuits, you can measure the speed by counting ticks from the first activation of the input to the ''final'' state on the output.		In complex circuits, you can measure the speed by counting ticks from the first activation of the input to the ''final'' state on the output.

DjSapsan: small fixes

2025-09-09T15:53:12Z

small fixes

← Older revision		Revision as of 15:53, 9 September 2025
Line 66:		Line 66:
	A bit more complex technique is to use negations. This often requires a complete rethinking of the design.		A bit more complex technique is to use negations. This often requires a complete rethinking of the design.
	But when done correctly, it can lead to a significant reduction in the number of gates, especially in very big circuits.		But when done correctly, it can lead to a significant reduction in the number of gates, especially in very big circuits.
	~~To start, you~~ need to stop thinking in terms of ON/~~OFF~~ to ~~activate~~ something~~, you must embrace the negation!~~		You need to stop thinking in terms of {{On}}/{{Off}} to enable/disable something.
	For example, ~~what if~~ you can use 0 to indicate the enabled state in some part? This will already remove a NOT gate from the design.		For example, you can use {{Off}} to indicate the '''enabled''' state in some part. This will already remove a NOT gate from the design.
	{{todo\|add specific examples with negated logic}}		{{todo\|add specific examples with negated logic}}

Line 105:		Line 105:

	You can divide it however you want, the main idea is to reduce the number of gates activated at once.		You can divide it however you want, the main idea is to reduce the number of gates activated at once.

			Next advice is especially important on servers with multiple people. Make sure all your circuits can halt. Even if it's small timer - add a switch. If you are not using a circuit, turn it off.

	{{todo\|expand on the topic}}		{{todo\|expand on the topic}}

Line 110:		Line 113:
	If you focus only on speed or performance, you may end up with a huge circuit that is hard to build and manage.		If you focus only on speed or performance, you may end up with a huge circuit that is hard to build and manage.
	Sometimes you need to optimize purely for size.		Sometimes you need to optimize purely for size.
	Minimizing the size will ~~force~~ you to avoid bulky fast gates, introduce cycles, remove parallelism, etc., often leading to slower circuits. But ~~with high tickrates,~~ it may still be worth it.		Minimizing the size will make you avoid bulky fast gates, introduce cycles, remove parallelism, etc., often leading to slower circuits. But for some designs it may still be worth it.
	We will not be focusing on designing a logic with a smaller footprint. Instead, here are''structural'' tips that some people find useful:		We will not be focusing on designing a logic with a smaller footprint. Instead, here are ''structural'' tips that some people find useful:

	*Use "round" or "hollow" designs.		*Use "round" or "hollow" designs.
	*Use 1-tile stackable parts.		*Use 1-tile stackable parts.
	These "round" or "hollow" designs are made by placing supporting structures at the edges or against each other and putting logic and wiring in the middle of it. Always remember, ''Logic world'' is 3D!		These "round" or "hollow" designs are made by placing supporting structures at the edges or against each other and putting logic and wiring in the middle of it. Always remember, ''Logic world'' is 3D!
	This approach is extremely useful for wiring, as it allows you ~~to basically~~ connect '''everything to everything'''.		This approach is extremely useful for wiring, as it allows you connect '''everything to everything'''.
	Examples:		Examples:
	[[File:Compact-design1.png\|frame\|center\|alt=Logic gates are only in 4 corners, all wires are inside \|Logic gates are only in 4 corners, all wires are inside]]		[[File:Compact-design1.png\|frame\|center\|alt=Logic gates are only in 4 corners, all wires are inside \|Logic gates are only in 4 corners, all wires are inside]]

Jimmy: fix links and stuff

2025-09-09T04:59:13Z

fix links and stuff

Jimmy: fix links

2025-09-09T04:51:04Z

fix links

← Older revision		Revision as of 04:51, 9 September 2025
Line 19:		Line 19:

	*Remove unnecessary gates		*Remove unnecessary gates
	*Use fast gates, such as [[Relay\|~~relays~~]] or [[Fast ~~buffer~~\|~~fast buffers~~]]		*Use fast gates, such as [[Relay\|Relays]] or [[Fast Buffer\|Fast Buffers]]
	*Mods		*Mods

DjSapsan: fixes and improvements

2025-09-07T22:44:02Z

fixes and improvements

← Older revision		Revision as of 22:44, 7 September 2025
Line 26:		Line 26:
	==== Remove unnecessary gates ====		==== Remove unnecessary gates ====
	To start, the most newbie-friendly way to optimize gates is to just remove repetitions.		To start, the most newbie-friendly way to optimize gates is to just remove repetitions.
	For example, if you have a NOT gate followed by another NOT gate, you can just remove both of them!		For example, if you have a NOT gate followed by another NOT gate, you can just remove both of them! The same applies to other gates. Instead of placing many AND gates following one after another, make a single big AND gate with multiple inputs.

	Now moving on to ~~the serious discussion~~.		Now moving on to a more complex topic.
	The first big distinction of ''Logic World'' from real life: there are no OR gates! Instead, wires are just connected together.		The first big distinction of ''Logic World'' from real life is that there are no OR gates! Instead, wires are just connected together.
	This game design already removes some gates.		This game design already removes some gates.
	But the OR operation is still a necessary part of logic, even if implicitly. We still need to connect wires together.		But the OR operation is still a necessary part of logic, even if implicitly. We still need to connect wires together.
	The problem is that the wrong way may either introduce delays or lead to backpropagation.		The problem is that the wrong way may either introduce delays or lead to backpropagation.
	{{Backpropagation}}		{{Backpropagation}}
	A solution to this using fast gates will be discussed later. Here I will show a hacky way: connecting multiple wires together from '''output''' pins.		A solution to this by using fast gates will be discussed later. Here I will show a hacky way: connecting multiple wires together from '''output''' pins.
	You may notice that in the screenshot ~~above~~, the '''output''' pin from the button is connected to a lamp and then the lamp is connected to another gate.		You may notice that in the screenshot on the right, the '''output''' pin from the button is connected to a lamp and then the lamp is connected to another gate.
	In general, if a wire is connected between normal pins, it will allow the signal to travel everywhere. The exception is the '''output''' pin.		In general, if a wire is connected between normal pins, it will allow the signal to travel everywhere. The exception is the '''output''' pin.
	Wires ''coming'' out of '''output''' pins do not conduct signals backward. To use it, you need to connect all the affected items to all the related '''output''' pins individually. You can always find the output pin by its big fat size. The next screenshot shows the correct way.		Wires ''coming'' out of '''output''' pins do not conduct signals backward. To use it, you need to connect all the affected items to all the related '''output''' pins individually. You can always find the output pin by its big fat size. The next screenshot below shows the correct way.
	[[File:Fix-backprop.png\|thumb\|right\|alt=Everything is connected from output pins\|Everything is connected from output pins]]		[[File:Fix-backprop.png\|thumb\|right\|alt=Everything is connected from output pins\|Everything is connected from output pins]]
	If you do it correctly, you won't need additional gates to stop backpropagation.		If you do it correctly, you won't need additional gates to stop backpropagation.
Line 47:		Line 47:
	<div class="mw-collapsible mw-collapsed">		<div class="mw-collapsible mw-collapsed">
	Expand to see an example<div class="mw-collapsible-content">		Expand to see an example<div class="mw-collapsible-content">
	[[File:Toomanywires.png\|center\|alt=toomanywires\|toomanywires]]		[[File:Toomanywires.png\|center\|frameless\|alt=toomanywires\|toomanywires]]
	</div>		</div>
	</div>		</div>
Line 76:		Line 76:
	*[[Fast buffer]] is a simple gate that just propagates the signal from input to output without any delay. The main purpose is to avoid backpropagation. It's also useful to route wires neatly.		*[[Fast buffer]] is a simple gate that just propagates the signal from input to output without any delay. The main purpose is to avoid backpropagation. It's also useful to route wires neatly.
	:The drawback is that it's very bulky, increasing the circuit size significantly.		:The drawback is that it's very bulky, increasing the circuit size significantly.
	*[[Relay]] is a gate that also propagates the signal without delay, but only if enabled. It's different from ~~relays~~ in two major ways:		*[[Relay]] is a gate that also propagates the signal without delay, but only if enabled. It's different from Fast buffers in two major ways:
	** It propagates signals both ways, so it can't be used to avoid backpropagation.		** It propagates signals both ways, so it can't be used to avoid backpropagation.
	**Enabling it takes 1 tick, but after it's enabled, it will propagate the signal without delay.		**Enabling it takes 1 tick, but after it's enabled, it will propagate the signal without delay.
	While fast gates ~~only~~ increase the number of gates, they ~~still~~ remove delays.		While fast gates increase the overall number of gates, they remove delays.
	Fast buffer ~~can~~ replace regular [[Buffer\|buffers]]~~, removing 1 tick delay.~~		So you can use Fast buffer to replace regular [[Buffer\|buffers]] and
	Relays ~~can be used~~ to replace [[AND Gate\|AND gates]], ~~removing 1~~ tick ~~delay~~.		Relays to replace [[AND Gate\|AND gates]].
	A notable circuit with fast gates is an [[ICA\|Instant Carry Adder ('''ICA''')]].		But remember, sometimes you still need regular Buffers to synchronize signals. Otherwise, signals coming from fast gates may not match with signals from other gates.
			Please note, that extensive usage of fast gates may lead to slower performance, as all connected gates updated all at once each tick.

			A notable example of a circuit with fast gates is an [[ICA\|Instant Carry Adder ('''ICA''')]].

	==== Mods ====		==== Mods ====
Line 107:		Line 110:
	If you focus only on speed or performance, you may end up with a huge circuit that is hard to build and manage.		If you focus only on speed or performance, you may end up with a huge circuit that is hard to build and manage.
	Sometimes you need to optimize purely for size.		Sometimes you need to optimize purely for size.
	Minimizing the size will force you to avoid fast gates, introduce cycles, remove parallelism, etc., often leading to slower circuits. But with high tickrates, it may still be worth it.		Minimizing the size will force you to avoid bulky fast gates, introduce cycles, remove parallelism, etc., often leading to slower circuits. But with high tickrates, it may still be worth it.
	We will not be focusing on ~~building the~~ logic ~~itself~~ with a smaller footprint~~, it should be trivial - just don't use fast gates~~.		We will not be focusing on designing a logic with a smaller footprint. Instead, here are''structural'' tips that some people find useful:
	Instead, ~~there~~ are ~~some~~ ''structural'' tips that some people ~~utilize~~:

	*Use "round" or "hollow" designs.		*Use "round" or "hollow" designs.
	*Use 1-tile stackable parts.		*Use 1-tile stackable parts.
	So "round" or "hollow" designs are made by ~~constructing~~ supporting structures at the ~~sides/~~edges and putting logic and wiring in the middle of it. Always remember, ''Logic world'' is 3D!		These "round" or "hollow" designs are made by placing supporting structures at the edges or against each other and putting logic and wiring in the middle of it. Always remember, ''Logic world'' is 3D!
	This approach is extremely useful for wiring, as it allows you to basically connect '''everything to everything'''.		This approach is extremely useful for wiring, as it allows you to basically connect '''everything to everything'''.
	Examples:		Examples:
	[[File:Compact-design1.png\|~~frameless~~\|center\|alt=Logic gates are only in 4 corners, all wires are inside \|Logic gates are only in 4 corners, all wires are inside]]		[[File:Compact-design1.png\|frame\|center\|alt=Logic gates are only in 4 corners, all wires are inside \|Logic gates are only in 4 corners, all wires are inside]]


	[[File:Compact-design2.png\|~~frameless~~\|center\|alt=Logic gates are against each other\|Logic gates are against each other]]		[[File:Compact-design2.png\|frame\|center\|alt=Logic gates are against each other\|Logic gates are against each other]]

	{{todo\|expand on the topic}}		{{todo\|expand on the topic}}

Jimmy: Delete "obviously"

2025-09-07T21:58:16Z

Delete "obviously"

← Older revision		Revision as of 21:58, 7 September 2025
Line 3:		Line 3:
	There are countless ways to build any given circuit. Different designs will have different characteristics.		There are countless ways to build any given circuit. Different designs will have different characteristics.
	This article will help you design circuits optimized for specific purposes.		This article will help you design circuits optimized for specific purposes.
	~~Obviously, you~~ can mix and match different techniques to achieve the results you want.		You can mix and match different techniques to achieve the results you want.

	So, when designing a circuit you need to decide what you want to optimize for. Let's break down each optimization one by one.		So, when designing a circuit you need to decide what you want to optimize for. Let's break down each optimization one by one.

FoxFireFive at 21:30, 7 September 2025

2025-09-07T21:30:14Z

← Older revision		Revision as of 21:30, 7 September 2025
Line 81:		Line 81:
	While fast gates only increase the number of gates, they still remove delays.		While fast gates only increase the number of gates, they still remove delays.
	Fast buffer can replace regular [[Buffer\|buffers]], removing 1 tick delay.		Fast buffer can replace regular [[Buffer\|buffers]], removing 1 tick delay.
	Relays can be used to replace [[AND ~~gate~~\|AND gates]], removing 1 tick delay.		Relays can be used to replace [[AND Gate\|AND gates]], removing 1 tick delay.
	A notable circuit with fast gates is an [[ICA\|Instant Carry Adder ('''ICA''')]].		A notable circuit with fast gates is an [[ICA\|Instant Carry Adder ('''ICA''')]].

DjSapsan: Better pictures framing

2025-09-07T21:21:00Z

Better pictures framing

← Older revision		Revision as of 21:21, 7 September 2025
Line 41:		Line 41:
	If you do it correctly, you won't need additional gates to stop backpropagation.		If you do it correctly, you won't need additional gates to stop backpropagation.
	The drawback is that it requires a direct path from all the inputs to the outputs.		The drawback is that it requires a direct path from all the inputs to the outputs.










	----		----
Line 61:		Line 52:

	----		----


	Moving on to other techniques to remove unnecessary gates.		Moving on to other techniques to remove unnecessary gates.
Line 126:		Line 116:
	This approach is extremely useful for wiring, as it allows you to basically connect '''everything to everything'''.		This approach is extremely useful for wiring, as it allows you to basically connect '''everything to everything'''.
	Examples:		Examples:
	[[File:Compact-design1.png\|\|alt=Logic gates are only in 4 corners, all wires are inside \|Logic gates are only in 4 corners, all wires are inside]]		[[File:Compact-design1.png\|frameless\|center\|alt=Logic gates are only in 4 corners, all wires are inside \|Logic gates are only in 4 corners, all wires are inside]]


	[[File:Compact-design2.png\|\|alt=Logic gates are against each other\|Logic gates are against each other]]		[[File:Compact-design2.png\|frameless\|center\|alt=Logic gates are against each other\|Logic gates are against each other]]

	{{todo\|expand on the topic}}		{{todo\|expand on the topic}}
	~~---~~

DjSapsan: First version of the article

2025-09-07T21:08:15Z

First version of the article

New page

== Optimization ==

There are countless ways to build any given circuit. Different designs will have different characteristics.
This article will help you design circuits optimized for specific purposes.
Obviously, you can mix and match different techniques to achieve the results you want.

So, when designing a circuit you need to decide what you want to optimize for. Let's break down each optimization one by one.

Please note that, while you may be familiar with real electronics or programming, in ''Logic World'' there are certain features that are not obvious at first.
These features can be used to your advantage when optimizing circuits.

== Speed ==
Speed is the time it takes for a signal to propagate through a circuit.
In Logic World, most gates have a delay of 1 tick. The more sequential gates you have, the slower the circuit will be.
When you have cycles or feedback in your circuit, speed becomes even more critical.
In complex circuits, you can measure the speed by counting ticks from the first activation of the input to the ''final'' state on the output.

There are three major ways to cut the delays:

*Remove unnecessary gates
*Use fast gates, such as [[Relay|relays]] or [[Fast buffer|fast buffers]]
*Mods

Let's break it down further.

==== Remove unnecessary gates ====
To start, the most newbie-friendly way to optimize gates is to just remove repetitions.
For example, if you have a NOT gate followed by another NOT gate, you can just remove both of them!

Now moving on to the serious discussion.
The first big distinction of ''Logic World'' from real life: there are no OR gates! Instead, wires are just connected together.
This game design already removes some gates.
But the OR operation is still a necessary part of logic, even if implicitly. We still need to connect wires together.
The problem is that the wrong way may either introduce delays or lead to backpropagation.
{{Backpropagation}}
A solution to this using fast gates will be discussed later. Here I will show a hacky way: connecting multiple wires together from '''output''' pins.
You may notice that in the screenshot above, the '''output''' pin from the button is connected to a lamp and then the lamp is connected to another gate.
In general, if a wire is connected between normal pins, it will allow the signal to travel everywhere. The exception is the '''output''' pin.
Wires ''coming'' out of '''output''' pins do not conduct signals backward. To use it, you need to connect all the affected items to all the related '''output''' pins individually. You can always find the output pin by its big fat size. The next screenshot shows the correct way.
[[File:Fix-backprop.png|thumb|right|alt=Everything is connected from output pins|Everything is connected from output pins]]
If you do it correctly, you won't need additional gates to stop backpropagation.
The drawback is that it requires a direct path from all the inputs to the outputs.

----

Also, in complex circuits it becomes hard to see individual wires.
<div class="mw-collapsible mw-collapsed">
Expand to see an example<div class="mw-collapsible-content">
[[File:Toomanywires.png|center|alt=toomanywires|toomanywires]]
</div>
</div>

----

Moving on to other techniques to remove unnecessary gates.
This part will require some logic understanding. In many cases, you can improve the circuit by just using a different formula than the one you initially thought of.
And remember the lack of OR gates, some circuit variations are simply simpler.
For example, you need <math>(B \land A) \lor (B \land C)</math>, this will require 2 explicit AND gates. But you can rewrite it as <math>B \land (A \lor C)</math>.
Notice in the screenshot that a different formulation leads to a smaller circuit.
[[File:ABC-circuit.png|thumb|On the left - two explicit gates. On the right - a simple refactoring removes one gate]]
Although this simple example doesn't improve speed (because it's not sequential), this lesson still shows that you can remove unnecessary gates.

The most useful thing to know here is [[wikipedia:De Morgan's laws|De Morgan's laws]]. They allow you to rewrite common formulas from one form to another.
There could be other examples, but just remember, this part will become easier with experience and overall logic understanding.

A bit more complex technique is to use negations. This often requires a complete rethinking of the design.
But when done correctly, it can lead to a significant reduction in the number of gates, especially in very big circuits.
To start, you need to stop thinking in terms of ON/OFF to activate something, you must embrace the negation!
For example, what if you can use 0 to indicate the enabled state in some part? This will already remove a NOT gate from the design.
{{todo|add specific examples with negated logic}}

==== Use fast gates ====
In ''Logic World'' there are so-called fast gates, such as [[Relay|relays]] or [[Fast buffer|fast buffers]].
These gates don't have a delay to propagate the signal. This is far from real life, but if you learn to use them correctly, they can significantly speed up your circuits.
Let's break them down.
*[[Fast buffer]] is a simple gate that just propagates the signal from input to output without any delay. The main purpose is to avoid backpropagation. It's also useful to route wires neatly.
:The drawback is that it's very bulky, increasing the circuit size significantly.
*[[Relay]] is a gate that also propagates the signal without delay, but only if enabled. It's different from relays in two major ways:
** It propagates signals both ways, so it can't be used to avoid backpropagation.
**Enabling it takes 1 tick, but after it's enabled, it will propagate the signal without delay.
While fast gates only increase the number of gates, they still remove delays.
Fast buffer can replace regular [[Buffer|buffers]], removing 1 tick delay.
Relays can be used to replace [[AND gate|AND gates]], removing 1 tick delay.
A notable circuit with fast gates is an [[ICA|Instant Carry Adder ('''ICA''')]].

==== Mods ====
There are many mods that add complex circuits as single black boxes, and they usually take 1 tick to perform the function.
Examples: CPUs, RAMs, Displays, Keyboards, Network devices, Decoders, Buffers, etc.

== Performance ==
Even if you design a very fast circuit, it may be too big for the game to handle, especially on high tickrates, leading to lags or slower execution overall.
You may want to trade off some circuit speed for better simulation performance.
Usually it may be done by splitting the circuit into smaller parts that are activated only when needed.
The heaviest parts are usually decoders (by themselves or with RAM), HDDs, LUTs.
Let's say you have a huge decoder with 1024 outputs. In a naive design, it will activate all the gates at once, leading to a big lag spike.
How do you optimize it?
You can do it by iteratively converging on the output, using the divide and conquer approach.
For example, split the computation into two iterations:

#First iteration: a 3-bit decoder, effectively multiplexing the input between 8x parts.
#Second iteration: only one active 7-bit decoder among 8 parts, with 128 outputs.

You can divide it however you want, the main idea is to reduce the number of gates activated at once.
{{todo|expand on the topic}}

== Size ==
If you focus only on speed or performance, you may end up with a huge circuit that is hard to build and manage.
Sometimes you need to optimize purely for size.
Minimizing the size will force you to avoid fast gates, introduce cycles, remove parallelism, etc., often leading to slower circuits. But with high tickrates, it may still be worth it.
We will not be focusing on building the logic itself with a smaller footprint, it should be trivial - just don't use fast gates.
Instead, there are some ''structural'' tips that some people utilize:

*Use "round" or "hollow" designs.
*Use 1-tile stackable parts.
So "round" or "hollow" designs are made by constructing supporting structures at the sides/edges and putting logic and wiring in the middle of it. Always remember, ''Logic world'' is 3D!
This approach is extremely useful for wiring, as it allows you to basically connect '''everything to everything'''.
Examples:
[[File:Compact-design1.png||alt=Logic gates are only in 4 corners, all wires are inside |Logic gates are only in 4 corners, all wires are inside]]

[[File:Compact-design2.png||alt=Logic gates are against each other|Logic gates are against each other]]

{{todo|expand on the topic}}
---

← Older revision		Revision as of 04:59, 9 September 2025
Line 71:		Line 71:

	==== Use fast gates ====		==== Use fast gates ====
	In ''Logic World'' there are so-called fast gates, such as [[Relay\|relays]] or [[Fast ~~buffer~~\|fast buffers]].		In ''Logic World'' there are so-called fast gates, such as [[Relay\|relays]] or [[Fast Buffer\|fast buffers]].
	These gates don't have a delay to propagate the signal. This is far from real life, but if you learn to use them correctly, they can significantly speed up your circuits.		These gates don't have a delay to propagate the signal. This is far from real life, but if you learn to use them correctly, they can significantly speed up your circuits.
	Let's break them down.		Let's break them down.
	*[[Fast ~~buffer~~]] is a simple gate that just propagates the signal from input to output without any delay. The main purpose is to avoid backpropagation. It's also useful to route wires neatly.		*[[Fast Buffer]] is a simple gate that just propagates the signal from input to output without any delay. The main purpose is to avoid backpropagation. It's also useful to route wires neatly.
	:The drawback is that it's very bulky, increasing the circuit size significantly.		:The drawback is that it's very bulky, increasing the circuit size significantly.
	*[[Relay]] is a gate that also propagates the signal without delay, but only if enabled. It's different from Fast ~~buffers~~ in two major ways:		*[[Relay]] is a gate that also propagates the signal without delay, but only if enabled. It's different from Fast Buffers in two major ways:
	** It propagates signals both ways, so it can't be used to avoid backpropagation.		** It propagates signals both ways, so it can't be used to avoid backpropagation.
	**Enabling it takes 1 tick, but after it's enabled, it will propagate the signal without delay.		**Enabling it takes 1 tick, but after it's enabled, it will propagate the signal without delay.
	While fast gates increase the overall number of gates, they remove delays.		While fast gates increase the overall number of gates, they remove delays.
	So you can use Fast ~~buffer~~ to replace regular [[Buffer\|buffers]] and		So you can use Fast Buffer to replace regular [[Buffer\|buffers]] and
	Relays to replace [[AND Gate\|AND gates]].		Relays to replace [[AND Gate\|AND gates]].
	But remember, sometimes you still need regular Buffers to synchronize signals. Otherwise, signals coming from fast gates may not match with signals from other gates.		But remember, sometimes you still need regular Buffers to synchronize signals. Otherwise, signals coming from fast gates may not match with signals from other gates.