數位邏輯與
Verilog 設計Digital Logic &
Verilog Designデジタル論理と
Verilog 設計

文氏圖 (Venn diagram) 把布林變數畫成矩形（全集）內互相重疊的圓。每個區域對應真值表中的一個最小項：圓 $x$ 之內＝「x 為 1」，之外＝「x 為 0」。兩圓的交集＝AND；聯集＝OR；圓外的區域＝NOT。

A Venn diagram represents Boolean variables as overlapping circles inside a rectangle (the universe). Each region corresponds to one minterm of the truth table: inside circle $x$ = "x is 1", outside = "x is 0". The intersection of two circles = AND; the union = OR; the area outside a circle = NOT.

ベン図はブール変数を、長方形（全体集合）の中で重なり合う円として表す。各領域は真理値表の 1 つの最小項に対応する：円 $x$ の内側＝「x が 1」、外側＝「x が 0」である。2 つの円の共通部分＝AND、和集合＝OR、円の外側の領域＝NOT である。

兩變數文氏圖（4 個區域 = 真值表 4 列）：

Two-variable Venn (4 regions = 4 truth-table rows):

2 変数のベン図（4 領域 = 真理値表の 4 行）：

三變數文氏圖（8 個區域 = 真值表 8 列）：

Three-variable Venn (8 regions = 8 truth-table rows):

3 変数のベン図（8 領域 = 真理値表の 8 行）：

Operators visually:

用法：分別為左式與右式塗色 — 若兩者的陰影圖樣一致，該恆等式即獲證明。

Use: shade LHS and RHS separately — if the shaded patterns match, the identity is proven.

使い方：左辺と右辺を別々に網掛けする — 網掛けの模様が一致すれば、その恒等式は証明されたことになる。

情境設定：輸送帶把口香糖球送過三個感測器：

Setup: a conveyor moves gumballs past three sensors:

設定：ベルトコンベアがガムボールを 3 つのセンサの前に運ぶ：

• 若口香糖球太輕則 $s_1 = 1$（重量感測器）
• $s_1 = 1$ if the gumball is too light (weight sensor)
• ガムボールが軽すぎるとき $s_1 = 1$（重量センサ）
• 若口香糖球太小則 $s_2 = 1$（直徑感測器）
• $s_2 = 1$ if the gumball is too small (diameter sensor)
• ガムボールが小さすぎるとき $s_2 = 1$（直径センサ）
• 若口香糖球太大則 $s_3 = 1$（直徑感測器）
• $s_3 = 1$ if the gumball is too large (diameter sensor)
• ガムボールが大きすぎるとき $s_3 = 1$（直径センサ）

當輸出 $f = 1$ 時，活門會把口香糖球剔除。剔除規則：太大時剔除，或（太小 AND 太輕）時剔除。

A trap door rejects the gumball when output $f = 1$. Reject rule: reject if it is too large, OR (too small AND too light).

出力 $f = 1$ のとき、落とし戸がガムボールを排除する。排除の規則：大きすぎる場合、または（小さすぎる AND 軽すぎる）場合に排除する。

圖 2.21a — 輸送帶示意圖：

Figure 2.21a — conveyor schematic:

図 2.21a — コンベヤの概略図：

圖 2.21b — 真值表：

Figure 2.21b — truth table:

図 2.21b — 真理値表：

例題 2.7 的推導（課本原本的作法）：

Example 2.7 derivation (the original textbook approach):

例題 2.7 の導出（教科書本来の方法）：

由最小項寫出的 SOP：$f = \overline{s_1}\overline{s_2}s_3 + \overline{s_1}s_2 s_3 + s_1\overline{s_2}s_3 + s_1 s_2\overline{s_3} + s_1 s_2 s_3$

SOP from minterms: $f = \overline{s_1}\overline{s_2}s_3 + \overline{s_1}s_2 s_3 + s_1\overline{s_2}s_3 + s_1 s_2\overline{s_3} + s_1 s_2 s_3$

最小項から得られる SOP：$f = \overline{s_1}\overline{s_2}s_3 + \overline{s_1}s_2 s_3 + s_1\overline{s_2}s_3 + s_1 s_2\overline{s_3} + s_1 s_2 s_3$

把 $s_1 s_2 s_3$ 這一項複製一份（規則 7b），再重新分組：

Replicate the $s_1 s_2 s_3$ term (rule 7b), then group:

$s_1 s_2 s_3$ の項を複製し（規則 7b）、まとめ直す：

$= \overline{s_1}s_3(\overline{s_2}+s_2) + s_1 s_3(\overline{s_2}+s_2) + s_1 s_2(\overline{s_3}+s_3) = \overline{s_1}s_3 + s_1 s_3 + s_1 s_2$

合併前兩項：$f = s_3 + s_1 s_2$

Combine the first two terms: $f = s_3 + s_1 s_2$

最初の 2 項をまとめる：$f = s_3 + s_1 s_2$

習題 2.19 要求什麼：給出一條不同的化簡路徑，卻得到相同的結果。把 $s_1 s_2\overline{s_3}$ 這一項重複一次，再以 $\overline{s_3}$ 提出因式：

What problem 2.19 asks: show a different simplification path that ends at the same result. Repeat the term $s_1 s_2\overline{s_3}$, then factor by $\overline{s_3}$:

問題 2.19 が求めていること：同じ結果に至る別の簡単化の道筋を示すこと。項 $s_1 s_2\overline{s_3}$ を繰り返し、$\overline{s_3}$ でくくる：

$f = s_3(\overline{s_1}\overline{s_2}+\overline{s_1}s_2+s_1\overline{s_2}+s_1 s_2) + s_1 s_2(\overline{s_3}+s_3) = s_3 \cdot 1 + s_1 s_2 = s_3 + s_1 s_2$

括號中的和涵蓋 $(s_1, s_2)$ 的每一種賦值，因此等於 1。結果相同、路徑不同 — 這說明代數化簡並不唯一。

The bracketed sum spans every valuation of $(s_1, s_2)$, so it equals 1. Same result, different route — illustrating that algebraic minimization isn't unique.

括弧の中の和は $(s_1, s_2)$ のあらゆる付値を尽くすので 1 に等しい。同じ結果に別の道筋で到達しており — 代数的な最小化が一通りではないことを示している。

可以 — NOR 是功能完備的：任何布林函數都能只用 NOR 閘建構出來。三個基本作法：

Yes — NOR is functionally complete: every Boolean function can be built using only NOR gates. Three base recipes:

できる — NOR は機能的完全である：どんなブール関数も NOR ゲートだけで構成できる。基本となる作り方は 3 つある：

NOT — 一個 NOR，兩個輸入短接在一起：$\mathrm{NOR}(x, x) = \overline{x+x} = \overline{x}$。

NOT — one NOR with both inputs shorted: $\mathrm{NOR}(x, x) = \overline{x+x} = \overline{x}$.

NOT — NOR 1 個の入力どうしを短絡する：$\mathrm{NOR}(x, x) = \overline{x+x} = \overline{x}$。

OR — 兩個 NOR（NOR 之後接一個反相器）：$x + y = \overline{\overline{x+y}} = \mathrm{NOR}(\mathrm{NOR}(x, y), \mathrm{NOR}(x, y))$。

OR — two NORs (NOR followed by inverter): $x + y = \overline{\overline{x+y}} = \mathrm{NOR}(\mathrm{NOR}(x, y), \mathrm{NOR}(x, y))$.

OR — NOR 2 個（NOR のあとにインバータ）：$x + y = \overline{\overline{x+y}} = \mathrm{NOR}(\mathrm{NOR}(x, y), \mathrm{NOR}(x, y))$。

AND — 三個 NOR（兩個反相器 + 一個 NOR），依 DeMorgan 定律：$x \cdot y = \overline{\overline{x} + \overline{y}} = \mathrm{NOR}(\overline{x}, \overline{y})$。

AND — three NORs (two inverters + one NOR), via DeMorgan: $x \cdot y = \overline{\overline{x} + \overline{y}} = \mathrm{NOR}(\overline{x}, \overline{y})$.

AND — NOR 3 個（インバータ 2 個 + NOR 1 個）。DeMorgan の定理による：$x \cdot y = \overline{\overline{x} + \overline{y}} = \mathrm{NOR}(\overline{x}, \overline{y})$。

總結 — 閘數：

Summary — gate counts:

まとめ — ゲート数：

只要有了 NOR，其他所有閘（以及任何函數）都隨之而來。只用 NAND 也是一樣 — 兩者都是單一閘的萬用元件，這正是 CMOS 閘庫通常以它們為核心建構的原因。

Once you have NOR, every other gate (and any function whatsoever) follows. The same is true for NAND alone — both are single-gate universals, which is why CMOS gate libraries are typically built around them.

NOR さえあれば、ほかのすべてのゲート（そしてどんな関数でも）が得られる。NAND だけの場合も同様である — どちらも単一ゲートで万能であり、CMOS ゲートライブラリがふつうこの 2 つを軸に構築されているのはそのためである。

套用到習題 2.24： $f = (\overline{x_1}+x_2)(x_2+\overline{x_3})$ — 已經是兩層 POS 形式，可直接對映成兩層的 NOR-NOR 網路：

Application to problem 2.24: $f = (\overline{x_1}+x_2)(x_2+\overline{x_3})$ — already in 2-level POS form, which maps directly to a 2-level NOR-NOR network:

問題 2.24 への適用： $f = (\overline{x_1}+x_2)(x_2+\overline{x_3})$ — すでに 2 レベル POS 形になっており、2 レベルの NOR-NOR 回路網へそのまま写せる：

1. NOR_a：$\mathrm{NOR}(x_1, x_1) = \overline{x_1}$  （反相器）
2. NOR_a: $\mathrm{NOR}(x_1, x_1) = \overline{x_1}$  (inverter)
3. NOR_a：$\mathrm{NOR}(x_1, x_1) = \overline{x_1}$  （インバータ）
4. NOR_b：$\mathrm{NOR}(x_3, x_3) = \overline{x_3}$  （反相器）
5. NOR_b: $\mathrm{NOR}(x_3, x_3) = \overline{x_3}$  (inverter)
6. NOR_b：$\mathrm{NOR}(x_3, x_3) = \overline{x_3}$  （インバータ）
7. NOR1：$\mathrm{NOR}(\overline{x_1}, x_2) = \overline{\overline{x_1}+x_2}$  （第一個和項，取反）
8. NOR1: $\mathrm{NOR}(\overline{x_1}, x_2) = \overline{\overline{x_1}+x_2}$  (first sum, inverted)
9. NOR1：$\mathrm{NOR}(\overline{x_1}, x_2) = \overline{\overline{x_1}+x_2}$  （1 つ目の和項の反転）
10. NOR2：$\mathrm{NOR}(x_2, \overline{x_3}) = \overline{x_2+\overline{x_3}}$  （第二個和項，取反）
11. NOR2: $\mathrm{NOR}(x_2, \overline{x_3}) = \overline{x_2+\overline{x_3}}$  (second sum, inverted)
12. NOR2：$\mathrm{NOR}(x_2, \overline{x_3}) = \overline{x_2+\overline{x_3}}$  （2 つ目の和項の反転）
13. NOR3：$\mathrm{NOR}(\mathrm{NOR1}, \mathrm{NOR2}) = (\overline{x_1}+x_2)(x_2+\overline{x_3}) = f$  （依 DeMorgan 定律再次取反並做 AND）
14. NOR3: $\mathrm{NOR}(\mathrm{NOR1}, \mathrm{NOR2}) = (\overline{x_1}+x_2)(x_2+\overline{x_3}) = f$  (re-inverts and ANDs by DeMorgan)
15. NOR3：$\mathrm{NOR}(\mathrm{NOR1}, \mathrm{NOR2}) = (\overline{x_1}+x_2)(x_2+\overline{x_3}) = f$  （ド・モルガンにより再反転して AND をとる）

合計：5 個 NOR 閘。

Total: 5 NOR gates.

合計：NOR ゲート 5 個。

題設。兩個 4 變數函數 $f_1$ 與 $f_2$ 要實作成單一的合併電路（可共用之處就共用閘）。

Setup. Two 4-variable functions $f_1$ and $f_2$ are to be implemented in a single combined circuit (shared gates where possible).

設定。4 変数の関数 $f_1$ と $f_2$ を 1 つの結合回路として実装する（可能なところではゲートを共有する）。

Figure 2.64a / 2.64b — K-maps:

例題 2.16 — 最小 SOP（含共用）

Example 2.16 — minimum SOP (with sharing)

例題 2.16 — 最小 SOP（共有あり）

$f_1 = \overline{x_1}\,\overline{x_3} + x_1 x_3 + \overline{x_2} x_3 x_4$

$f_2 = \overline{x_1}\,\overline{x_3} + x_1 x_3 + x_2 \overline{x_3} x_4$

前兩個乘積項完全相同 → 圖 2.64c 中那些 AND 閘是共用的。合併後的成本：6 gates / 16 inputs = 22（相對於兩個獨立電路的 28）。

The first two product terms are identical → those AND gates are shared in Figure 2.64c. Combined cost: 6 gates / 16 inputs = 22 (versus 28 for two separate circuits).

最初の 2 つの積項は同一である → 図 2.64c ではそれらの AND ゲートが共有されている。結合後のコストは 6 gates / 16 inputs = 22（別々の 2 回路なら 28）。

例題 2.18 — 最小 POS（習題 2.29 的題目）

Example 2.18 — minimum POS (problem 2.29's task)

例題 2.18 — 最小 POS（問題 2.29 の課題）

$f_1 = (x_1 + \overline{x_3})(\overline{x_1} + x_3)(\overline{x_1} + \overline{x_3} + x_4)$

$f_2 = (x_1 + \overline{x_3})(\overline{x_1} + x_3)(\overline{x_1} + \overline{x_3} + \overline{x_4})$

前兩個和項是共同的（可以共用），但 K-map 顯示沒有任何 0 格分組同時出現在兩個函數中 — 因此除了那兩個共用的 OR 閘之外，再沒有其他和項值得合併。每個函數仍需要三個 OR 閘 + 一個 AND 閘 + 11 個輸入 ≈ 30 total（若共用那兩個共同和項的 OR 閘，則約 26）。

The first two sum terms are common (could be shared), but the K-maps reveal no 0-cell grouping that simultaneously appears in both functions — so beyond those two shared OR gates, no additional sum terms can be merged advantageously. Each function still needs three OR gates + one AND gate + 11 inputs ≈ 30 total (or ~26 if you share the two common sum-term ORs).

最初の 2 つの和項は共通で（共有できる）、しかし K-map を見ると両方の関数に同時に現れる 0 セルのグループは存在しない — したがって、その 2 つの共有 OR ゲート以外に、有利に併合できる和項はない。各関数にはなお OR ゲート 3 個 + AND ゲート 1 個 + 入力 11 本 ≈ 30 total が必要である（共通の和項の OR を 2 つ共有すれば約 26）。

結論：22（SOP，有共用）< 26–30（POS） — 對這幾張特定的 K-map 而言，SOP 形式能容許較多共用，因為 1 格聚成的乘積項彼此重疊，而 0 格則無法相容地聚集。這高度取決於函數本身 — 範例 2.17（圖 2.65，$f_3, f_4$）就顯示相反的順序也可能發生。

Conclusion: 22 (SOP, shared) < 26–30 (POS) — for these particular K-maps, the SOP form admits more sharing because the 1-cells cluster into product terms that overlap, while the 0-cells don't cluster compatibly. This is highly function-dependent — Example 2.17 (Figure 2.65, $f_3, f_4$) shows the opposite ordering can occur.

結論：22（SOP、共有あり）< 26–30（POS） — これらの K-map に限っては、1 セルが重なり合う積項にまとまるのに対し 0 セルは都合よくまとまらないため、SOP 形のほうが共有の余地が大きい。これは関数に強く依存する — 例 2.17（図 2.65、$f_3, f_4$）では逆の順序が起こり得ることが示される。

關於圖 2.65：該圖以另一組 $f_3, f_4$ 說明同樣的取捨，課本在那裡比較「只用質蘊涵項」的實作與「刻意共用非質蘊涵項」的實作 — 見範例 2.17 / 2.19（那是學習指南裡的另一道題，不是本題）。

Note on Figure 2.65: that figure illustrates the same trade-off for a different pair $f_3, f_4$ where the textbook compares prime-implicant-only realizations against intentionally-shared non-prime implicants — see Example 2.17 / 2.19 (different problem in the study guide, not this one).

図 2.65 について：その図は別の組 $f_3, f_4$ について同じトレードオフを示しており、教科書はそこで主項のみによる実現と、意図的に共有した非主項による実現とを比較している — 例 2.17 / 2.19 を参照（学習ガイド中の別の問題であり、本問ではない）。

題設。兩個 4 變數函數 $f_3$ 與 $f_4$ 要實作成單一的合併電路。範例 2.16 只使用質蘊涵項，並共用其中明顯共同的部分；範例 2.17 則刻意採用一些非質蘊涵項，以挖出更多共用的機會。

Setup. Two 4-variable functions $f_3$ and $f_4$ are to be implemented as a single combined circuit. Whereas Example 2.16 used only prime implicants and shared the obviously-common ones, Example 2.17 deliberately uses some non-prime implicants to expose more sharing opportunities.

設定。4 変数の関数 $f_3$ と $f_4$ を 1 つの結合回路として実装する。例 2.16 が主項だけを用いて明らかに共通なものを共有したのに対し、例 2.17 ではあえて非主の内項をいくつか使い、共有の機会をさらに引き出す。

Figure 2.65a / 2.65b — K-maps:

範例 2.17 — 只用質蘊涵項的最小 SOP：

Example 2.17 — minimum SOP using only prime implicants:

例 2.17 — 主項のみを用いた最小 SOP：

$f_3 = \overline{x_1}x_4 + x_2 x_4 + x_1 x_2 x_3$

$f_4 = \overline{x_1}\overline{x_2}\overline{x_4} + x_1 \overline{x_2} \overline{x_3} + x_1\overline{x_4}$  （或等價形式 — 總共六個 AND 閘，沒有任何 AND 可以共用）

$f_4 = \overline{x_1}\overline{x_2}\overline{x_4} + x_1 \overline{x_2} \overline{x_3} + x_1\overline{x_4}$  (or equivalent — six AND gates total, no AND can be shared)

$f_4 = \overline{x_1}\overline{x_2}\overline{x_4} + x_1 \overline{x_2} \overline{x_3} + x_1\overline{x_4}$  （あるいは同等の形 — AND ゲートは合計 6 個で、共有できる AND はない）

不共用時的合併成本：6 ANDs + 2 ORs + 21 inputs = 29。

Combined cost with no sharing: 6 ANDs + 2 ORs + 21 inputs = 29.

共有なしの結合コスト：6 ANDs + 2 ORs + 21 inputs = 29。

範例 2.17 — 共用非質蘊涵項的較佳 SOP：

Example 2.17 — better SOP using shared non-prime implicants:

例 2.17 — 非主の内項を共有したより良い SOP：

$f_3 = \overline{x_1}x_2 x_4 + x_1 x_2 x_3 \overline{x_4} + \overline{x_1}x_4$

$f_4 = \overline{x_1}x_2 x_4 + x_1 x_2 x_3 \overline{x_4} + x_2\overline{x_4}$

此時兩式的前兩個乘積項完全相同，可以共用 AND 閘。合併成本：6 gates + 17 inputs = 23 — 比質蘊涵項的實作省下 6 個輸入。

Now the first two product terms are identical in both expressions and can share AND gates. Combined cost: 6 gates + 17 inputs = 23 — a 6-input saving over the prime-implicant realization.

いまや両式の最初の 2 つの積項は同一であり、AND ゲートを共有できる。結合コストは 6 gates + 17 inputs = 23 — 主項による実現より入力が 6 本少なくて済む。

範例 2.19 — 同一組函數的最小 POS（習題 2.30 問的就是這個）：

Example 2.19 — minimum POS for the same pair (problem 2.30 asks this):

例 2.19 — 同じ組に対する最小 POS（問題 2.30 が問うているのはこれ）：

$f_3 = (x_3 + x_4)(x_2 + x_4)(x_1 + x_4)(\overline{x_1} + x_2)$

$f_4 = (x_3 + x_4)(x_2 + x_4)(x_1 + x_4)(\overline{x_1} + x_2 + \overline{x_4})$

兩個函數的前三個和項完全相同 — 三個共用的 OR 閘，共耗六個輸入。再加上 $f_3$ 的一個 2 輸入 OR 與一個 4 輸入 AND，以及 $f_4$ 的一個 3 輸入 OR 與一個 4 輸入 AND。合併成本：5 ORs + 2 ANDs + 19 inputs = 26。

The first three sum terms are identical in both functions — three shared OR gates costing six inputs. Plus one 2-input OR and one 4-input AND for $f_3$, and one 3-input OR and one 4-input AND for $f_4$. Combined cost: 5 ORs + 2 ANDs + 19 inputs = 26.

両関数で最初の3 つの和項が同一である — 共有できる OR ゲート 3 個で入力は 6 本。さらに $f_3$ 用に 2 入力 OR 1 個と 4 入力 AND 1 個、$f_4$ 用に 3 入力 OR 1 個と 4 入力 AND 1 個が要る。結合コスト：5 ORs + 2 ANDs + 19 inputs = 26。

Comparison:

心得：對這一組函數而言，刻意採用非最小（共用）蘊涵項的 SOP 勝過 POS。SOP 與 POS 之間、質蘊涵項與共用蘊涵項之間的取捨，取決於 K-map 的幾何形狀 — 現代的合成工具兩者都會探索。

Lesson: SOP with intentionally-non-minimum (shared) implicants beats POS for this pair. The choice of SOP vs POS, and prime-vs-shared implicants, depends on the K-map geometry — modern synthesis tools explore both.

教訓：この組では、あえて最小でない（共有した）内項を使う SOP のほうが POS より優れている。SOP か POS か、主項か共有内項かの選択は K-map の幾何に依存する — 現代の合成ツールは両方を探索する。

兩個電路都把兩個 4 位元無號數 $M = m_3 m_2 m_1 m_0$ 與 $Q = q_3 q_2 q_1 q_0$ 相乘，得到 8 位元的乘積 $P = p_7 \ldots p_0$。它們的部分積產生方式相同（16 個 AND 閘：$m_i q_j$），差別在於如何累加這些和。

Both circuits multiply two 4-bit unsigned numbers $M = m_3 m_2 m_1 m_0$ and $Q = q_3 q_2 q_1 q_0$ to produce an 8-bit product $P = p_7 \ldots p_0$. They use the same partial-product generation (16 AND gates: $m_i q_j$) but differ in how the sums are accumulated.

どちらの回路も、4 ビットの符号なし数 $M = m_3 m_2 m_1 m_0$ と $Q = q_3 q_2 q_1 q_0$ を掛けて 8 ビットの積 $P = p_7 \ldots p_0$ を得る。部分積の生成は同じ（16 個の AND ゲート：$m_i q_j$）だが、和の積み上げ方が異なる。

圖 3.35 — 漣波進位陣列（慢）：每一列的 FA 由左至右串接，前一個的進位輸出接到下一個的進位輸入（漣波）。接著該列的和位元落到下一列，在那裡再次漣波。關鍵路徑就這樣蜿蜒穿過好幾列。

Figure 3.35 — ripple-carry array (slow): FAs in each row are chained left-to-right with the carry-out of one feeding the carry-in of the next (ripple). Then the row's sum bits drop into the next row, which again ripples. The critical path snakes through several rows.

図 3.35 — リプルキャリーアレイ（遅い）：各行の FA は左から右へ数珠つなぎになっており、ある FA の桁上げ出力が次の FA の桁上げ入力に入る（リプル）。その行の和ビットは次の行へ落ち、そこでもまたリプルする。クリティカルパスは何行にもわたって蛇行する。

沿關鍵路徑由右至左走：第 1 列（2 個 FA）→ 第 2 列（2 個 FA）→ 第 3 列 → 第 4 列（整條底部漣波，4 個 FA）→ 從最左邊的乘積位元輸出。總共 8 個 FA 延遲 + 1 個 AND 延遲。

Walk the critical path right-to-left through row 1 (2 FAs) → row 2 (2 FAs) → row 3 → row 4 (whole bottom ripple, 4 FAs) → exit at the leftmost product bit. 8 FA delays + 1 AND delay total.

クリティカルパスを右から左へたどる：第 1 行（FA 2 個）→ 第 2 行（FA 2 個）→ 第 3 行 → 第 4 行（最下段のリプル全体、FA 4 個）→ 最左の積ビットから出る。合計 8 FA 遅延 + 1 AND 遅延。

圖 3.48 — 進位保留陣列（快）：在前三列之中，進位不是漣波傳遞，而是被保留下來（以正確的位元位置送到下一列）。因此第 1–3 列的每個 FA 都看到三個獨立且已位移的部分積位元。最底下那列仍是一個由 4 個 FA 組成的漣波進位加法器，用來把最後保留下來的進位與累計和合併。

Figure 3.48 — carry-save array (fast): within each of the first three rows, carries are saved (sent to the next row at the correct bit position) instead of rippled. Each FA in rows 1–3 thus sees three independent shifted partial-product bits. The bottom row is still a 4-FA ripple-carry adder to merge the final saved carries with the running sum.

図 3.48 — 桁上げ保存アレイ（速い）：最初の 3 行では、桁上げはリプルさせずに保存される（正しいビット位置で次の行へ送られる）。そのため第 1〜3 行の各 FA は、独立にシフトされた 3 本の部分積ビットを受け取る。最下段は依然として FA 4 個のリプルキャリー加算器で、最後に残った保存桁上げを走行和と合流させる。

沿關鍵路徑走：第 1 列最右邊的 FA → 第 2 列最右邊的 FA → 直接往下到第 4 列（拜進位保留之賜，第 3 列沒有水平漣波）→ 底部漣波進位加法器的全部 4 個 FA。總共 6 個 FA 延遲 + 1 個 AND 延遲 — 省下 2 個 FA 延遲（快 25 %）。

Walk the critical path: rightmost FA in row 1 → rightmost FA in row 2 → straight down to row 4 (no horizontal ripple in row 3 thanks to carry-save) → all 4 FAs of the bottom ripple-carry adder. 6 FA delays + 1 AND delay total — a savings of 2 FA delays (25 % faster).

クリティカルパスをたどる：第 1 行の最右の FA → 第 2 行の最右の FA → そのまま真下の第 4 行へ（桁上げ保存のおかげで第 3 行に水平方向のリプルはない）→ 最下段のリプルキャリー加算器の FA 4 個すべて。合計 6 FA 遅延 + 1 AND 遅延 — FA 遅延 2 個分の節約（25 % 高速）。

Comparison:

為什麼進位保留比較快：在第 1–3 列中，和與被保留的進位只往垂直方向傳遞，不往水平方向傳。每個 FA 不論位在哪一行，都只等一個延遲。只有最後那列加法器需要漣波。對 $n \times n$ 的乘法器而言，漣波進位陣列的延遲是 $\mathcal{O}(n)$ 列 × 每列 $\mathcal{O}(n)$ 的漣波 = 最壞情況下大致 $\mathcal{O}(n^2)$ 個 FA 延遲，而進位保留形式則是 $\mathcal{O}(n)$ — 這正是所有現代快速乘法器（Wallace tree、Dadda multiplier 等）的基礎。

Why carry-save is faster: in rows 1–3, sums and saved carries propagate only vertically, not horizontally. Each FA waits one delay regardless of which column it sits in. Only the final adder row needs to ripple. For an $n \times n$ multiplier the ripple-carry array delay is $\mathcal{O}(n)$ rows × $\mathcal{O}(n)$ ripple per row = $\mathcal{O}(n^2)$ FA-delays in the worst case (ish), while the carry-save form is $\mathcal{O}(n)$ — the basis of all modern fast multipliers (Wallace tree, Dadda multiplier, etc.).

桁上げ保存が速い理由：第 1〜3 行では、和と保存された桁上げは垂直方向にしか伝わらず、水平方向には伝わらない。各 FA はどの列にあっても 1 段分の遅延しか待たない。リプルが必要なのは最後の加算器の行だけである。$n \times n$ の乗算器では、リプルキャリーアレイの遅延は $\mathcal{O}(n)$ 行 × 1 行あたり $\mathcal{O}(n)$ のリプル = 最悪の場合おおよそ $\mathcal{O}(n^2)$ FA 遅延となるのに対し、桁上げ保存形は $\mathcal{O}(n)$ である — これが現代の高速乗算器（Wallace tree、Dadda multiplier など）すべての基礎である。

依慣例，索引最大的已 assert 輸入勝出：I₃ > I₂ > I₁ > I₀。編碼器在 (Y₁, Y₀) 上回報這個勝出輸入的索引，而只要有任一輸入為作用中，V=1。

By convention the highest-indexed asserted input wins: I₃ > I₂ > I₁ > I₀. The encoder reports the index of that winning input on (Y₁, Y₀), and V=1 whenever any input is active.

慣例として、アサートされた入力のうち添字が最大のものが勝つ：I₃ > I₂ > I₁ > I₀。エンコーダはその勝った入力の添字を (Y₁, Y₀) に出力し、いずれかの入力が活性なら V=1 となる。

在 if / else if 串接中，這就是最先被檢查的輸入：

In an if / else if chain this is the input checked first:

if / else if の連鎖では、これが最初に調べられる入力である：

if      (in[3]) out = 2'd3;   // highest priority
else if (in[2]) out = 2'd2;
else if (in[1]) out = 2'd1;
else if (in[0]) out = 2'd0;   // lowest priority

若想改成讓輸入 0 的優先權最高，只要把這串判斷的順序反過來即可。

To make input 0 the highest priority instead, just reverse the order of the chain.

代わりに入力 0 を最優先にしたければ、連鎖の順序を逆にするだけでよい。

那就變成 I₀ > I₁ > I₂ > I₃。輸出 (Y₁,Y₀) 一樣回報勝出輸入的索引，但每一項都必須以優先權較高之輸入的補數來閘控。

Then I₀ > I₁ > I₂ > I₃. The output (Y₁,Y₀) still reports the index of the winning input, but every term must gate on the complements of the higher-priority inputs.

そのときは I₀ > I₁ > I₂ > I₃ となる。出力 (Y₁,Y₀) が勝った入力の添字を示すのは同じだが、各項は優先順位の高い入力の補数でゲートしなければならない。

$Y_0 = I_1\overline{I_0} + I_3\overline{I_2}\,\overline{I_1}\,\overline{I_0}$

$Y_1 = \overline{I_0}\,\overline{I_1}(I_2 + I_3)$

$V = I_0 + I_1 + I_2 + I_3$

與 I₃ 最高的情形（$Y_1 = I_3 + I_2$、$Y_0 = I_3 + I_1\overline{I_2}$）相比，把優先權翻轉成 I₀ 最高會讓式子變長，因為現在必須明確壓制優先權較高的輸入。

Compared to the I₃-highest case ($Y_1 = I_3 + I_2$, $Y_0 = I_3 + I_1\overline{I_2}$), flipping the priority to I₀ makes the equations longer because the higher-priority inputs now need to be explicitly suppressed.

I₃ を最優先とする場合（$Y_1 = I_3 + I_2$、$Y_0 = I_3 + I_1\overline{I_2}$）と比べると、優先順位を I₀ 最優先へ反転させると式は長くなる。優先順位の高い入力を明示的に抑え込む必要があるからである。

只把 I₁ 指定為最高優先權，並不能完全決定其餘三者的順序。慣例的讀法是循環移位（round-robin 式）：I₁ > I₂ > I₃ > I₀。

Naming only I₁ as highest doesn't fully specify the order of the other three. The usual reading is a cyclic shift (round-robin style): I₁ > I₂ > I₃ > I₀.

I₁ だけを最上位と決めても、残り 3 つの順序は完全には定まらない。ふつうの読み方は巡回シフト（ラウンドロビン式）である：I₁ > I₂ > I₃ > I₀。

$Y_0 = I_1 + I_3\overline{I_2}\,\overline{I_1}$

$Y_1 = \overline{I_1}(I_2 + I_3)$

$V = I_0 + I_1 + I_2 + I_3$

由於 I₀ 現在是最低優先權，而其索引為 00，兩個輸出中都不會出現 I₀ 項 — 只有當所有較高優先權的輸入都為 0 時它才會被「選中」，而這個選擇就由 Y₁Y₀ = 00 編碼。

Because I₀ is now the lowest priority and its index is 00, no I₀ term appears in either output — it's "selected" only when all higher-priority inputs are 0, and that selection is encoded by Y₁Y₀ = 00.

I₀ は今や最下位の優先度であり、その索引は 00 なので、どちらの出力にも I₀ の項は現れない — I₀ が「選ばれる」のは、より優先度の高い入力がすべて 0 のときだけであり、その選択は Y₁Y₀ = 00 で符号化される。

段位示意：a = 上橫，b = 右上，c = 右下，d = 下橫，e = 左下，f = 左上，g = 中橫。BCD 用 ABCD = wxyz。

Segment layout: a = top bar, b = upper right, c = lower right, d = bottom bar, e = lower left, f = upper left, g = middle bar. BCD uses ABCD = wxyz.

セグメント配置：a = 上の横棒、b = 右上、c = 右下、d = 下の横棒、e = 左下、f = 左上、g = 中央の横棒。BCD は ABCD = wxyz を用いる。

特殊規律：Notable patterns:目につく規則性：

• 數字 8：七段全亮 (1111111)，是最完整的圖形。
• Digit 8: all seven segments lit (1111111) — the most complete pattern.
• 数字 8：7 セグメントすべてが点灯 (1111111) — もっとも完全なパターン。
• 數字 1：只有 b、c 亮 (右側兩段)。
• Digit 1: only b and c are lit (the two right-hand segments).
• 数字 1：b と c だけが点灯（右側の 2 セグメント）。
• 數字 7：比 1 多一條上橫 (a 段)。
• Digit 7: digit 1 plus the top bar (segment a).
• 数字 7：数字 1 に上の横棒（セグメント a）を足したもの。
• g 段 (中橫)：只有 0、1、7 不亮，其餘皆亮。
• Segment g (middle bar): unlit only for 0, 1 and 7; lit for every other digit.
• セグメント g（中央の横棒）：0・1・7 のときだけ消灯し、それ以外の数字ではすべて点灯する。
• BCD 1010–1111 (10–15) 為無效輸入，列為 Don't Care (X)，可在 K-map 化簡時自由利用。
• BCD 1010–1111 (10–15) are invalid inputs, treated as Don't Care (X), and can be exploited freely when simplifying the K-map.
• BCD 1010–1111（10–15）は無効な入力なので Don't Care (X) として扱い、K-map の簡単化で自由に活用できる。

格雷碼（反射二進位碼）是一種二進位編碼系統，其中相鄰兩個數值恰好只差一個位元。

Gray code (reflected binary code) is a binary numbering system where two consecutive values differ in exactly one bit.

グレイ符号（反射 2 進符号）とは、連続する 2 つの値がちょうど 1 ビットだけ異なる 2 進の数値表現である。

每一列相對於上一列只變動一個位元。與二進位比較：0011 → 0100 一次就變了 3 個位元。

Each row changes only one bit from the row above. Compare with binary: 0011 → 0100 changes 3 bits at once.

各行は 1 つ上の行から 1 ビットしか変わらない。2 進と比べてみよ：0011 → 0100 では一度に 3 ビットが変わる。

為什麼重要：

Why it matters:

なぜ重要か：

• 機械／光學編碼器（旋轉位置）：位於位元邊界上的感測器無法全部同時切換。若用二進位，在轉換途中可能會短暫讀到完全錯誤的值（例如 011 → 100 可能會經過 000 或 111 的突波）。格雷碼保證只有一個感測器改變，因此最壞情況的誤讀也只差一。
• Mechanical / optical encoders (rotary position): sensors at bit boundaries can't all switch simultaneously. With binary, mid-transition you might briefly read a wildly wrong value (e.g. 011 → 100 might glitch through 000 or 111). Gray guarantees only one sensor changes, so the worst-case mis-read is off by one.
• 機械式／光学式エンコーダ（回転位置）：ビット境界にあるセンサがすべて同時に切り替わることはあり得ない。2 進では、遷移の途中でまったく違う値を一瞬読んでしまうことがある（たとえば 011 → 100 が 000 や 111 を経由してグリッチする）。グレイ符号なら変化するセンサは必ず 1 つだけなので、最悪でも誤読は 1 つ違いにとどまる。
• K-map：列與行都依格雷碼順序排列，因此在圈選最小項時，實體上的相鄰就等於邏輯上的相鄰。
• K-maps: rows/columns are in Gray order so physical adjacency = logical adjacency for grouping minterms.
• K-map：行と列がグレイ順に並んでいるので、最小項をまとめるとき物理的な隣接がそのまま論理的な隣接になる。
• 非同步 FIFO／跨時脈域：計數器採用格雷碼，因此取樣到的值一定是「目前的計數」或「下一個計數」，絕不會是介於兩者之間的垃圾值。
• Asynchronous FIFOs / clock-domain crossing: counters use Gray code so a sampled value is always either "this count" or "next count", never garbage in-between.
• 非同期 FIFO／クロックドメイン交差：カウンタにグレイ符号を使うので、サンプルした値は必ず「今のカウント」か「次のカウント」のどちらかであり、その中間のゴミ値になることはない。
• 功耗／EMI：每次遞增的位元轉換次數較少 → 切換雜訊也較低。
• Power / EMI: fewer bit transitions per increment → less switching noise.
• 電力／EMI：1 回の増加あたりのビット遷移が少ない → スイッチングノイズが減る。

Conversion formulas:

• 二進位 → 格雷碼：$G_i = B_i \oplus B_{i+1}$，其中 $G_{MSB} = B_{MSB}$。等價地寫成 $G = B \oplus (B \gg 1)$。
• Binary → Gray: $G_i = B_i \oplus B_{i+1}$, with $G_{MSB} = B_{MSB}$. Equivalently $G = B \oplus (B \gg 1)$.
• 2 進 → グレイ：$G_i = B_i \oplus B_{i+1}$、ただし $G_{MSB} = B_{MSB}$。同じことを $G = B \oplus (B \gg 1)$ とも書ける。
• 格雷碼 → 二進位：$B_{MSB} = G_{MSB}$，接著 $B_i = G_i \oplus B_{i+1}$（由 MSB 往下的累積 XOR）。
• Gray → Binary: $B_{MSB} = G_{MSB}$, then $B_i = G_i \oplus B_{i+1}$ (cumulative XOR from MSB down).
• グレイ → 2 進：$B_{MSB} = G_{MSB}$、続いて $B_i = G_i \oplus B_{i+1}$（MSB から下へ向かう累積 XOR）。

交叉開關 (crossbar switch) 是一種網路元件，能把任一輸入繞送到任一輸出，就像數位版的「跳線盤」。最簡單而不平凡的情形是 2×2 交叉開關：兩個輸入（$x_1, x_2$）、兩個輸出（$y_1, y_2$），以及一個在兩種連接樣式之間做選擇的控制位元 $s$：

A crossbar switch is a network element that lets any input be routed to any output, like a digital "patch panel". The simplest non-trivial case is the 2×2 crossbar: two inputs ($x_1, x_2$), two outputs ($y_1, y_2$), and one control bit $s$ that picks between two connection patterns:

クロスバスイッチ (crossbar switch) は、任意の入力を任意の出力へ回せるネットワーク要素であり、デジタル版の「パッチパネル」のようなものである。最も簡単で自明でない場合が 2×2 クロスバである：入力 2 本（$x_1, x_2$）、出力 2 本（$y_1, y_2$）、そして 2 通りの接続パターンを選ぶ制御ビット $s$ が 1 本。

兩種繞送樣式的電路圖：

Schematic of the two routing patterns:

2 通りの経路パターンの回路図：

Boolean expressions:

$y_1 = \overline{s}\,x_1 + s\,x_2 \;=\; \mathrm{MUX2}(s; x_1, x_2)$

$y_2 = \overline{s}\,x_2 + s\,x_1 \;=\; \mathrm{MUX2}(s; x_2, x_1)$

每個輸出都是一個 2-to-1 MUX：$s=0$ 時選「直通」的輸入，$s=1$ 時選「交叉」的輸入。總共兩個 MUX。

Each output is a 2-to-1 MUX: when $s=0$ pick the "straight" input, when $s=1$ pick the "crossed" input. Two MUXes total.

各出力は 2-to-1 MUX である：$s=0$ なら「ストレート」の入力を、$s=1$ なら「クロス」の入力を選ぶ。MUX は全部で 2 個である。

Block diagram:

每個 MUX 的上方資料線直接接自 $x_i$，下方資料線則橫接自 $x_j$。單一控制訊號 $s$ 會同時翻轉兩個 MUX。

Each MUX has its top data line wired straight from $x_i$ and its bottom data line wired across from $x_j$. The single control $s$ flips both MUXes simultaneously.

各 MUX の上側のデータ線は $x_i$ から直結され、下側のデータ線は $x_j$ から横に渡される。制御信号 $s$ 1 本で両方の MUX が同時に切り替わる。

Verilog:

module crossbar_2x2 (
  input  x1, x2, s,
  output y1, y2
);
  assign y1 = s ? x2 : x1;
  assign y2 = s ? x1 : x2;
endmodule

為什麼重要。交叉開關可以擴充成 $n \times n$ 的網路（用於 CPU 暫存器檔案、多處理器記憶體網路、network-on-chip 路由器）。一個 $n \times n$ 交叉開關需要 $n$ 個並列的 $n$-to-1 MUX — 雖然是無阻塞的，但規模是 $O(n^2)$，因此較大的 $n$ 會改用多級網路（Clos、Beneš）。

Why it matters. Crossbar switches scale up to $n \times n$ networks (used in CPU register files, multiprocessor memory networks, network-on-chip routers). An $n \times n$ crossbar takes $n$ parallel $n$-to-1 MUXes — non-blocking but $O(n^2)$ in size, hence the use of multistage networks (Clos, Beneš) for larger $n$.

なぜ重要か。クロスバスイッチは $n \times n$ のネットワークへ拡張できる（CPU のレジスタファイル、マルチプロセッサのメモリネットワーク、network-on-chip のルータなどで使われる）。$n \times n$ クロスバには $n$ 並列の $n$-to-1 MUX が要る — ノンブロッキングだが規模は $O(n^2)$ なので、$n$ が大きい場合は多段ネットワーク（Clos、Beneš）が使われる。

三輸入多數決函數 $M(w_1, w_2, w_3)$ 在三個輸入中至少有兩個為 1 時輸出 1，否則輸出 0。它是「多數表決」的布林版本：每個輸入是一張贊成／反對票，輸出就是勝出的那一方。

The three-input majority function $M(w_1, w_2, w_3)$ outputs 1 when at least two of the three inputs are 1, and 0 otherwise. It's the Boolean version of "majority vote": each input is a yes/no vote, the output is the winning side.

3 入力の多数決関数 $M(w_1, w_2, w_3)$ は、3 入力のうち少なくとも 2 つが 1 のとき 1 を、それ以外では 0 を出力する。「多数決」のブール版であり、各入力が賛成／反対の 1 票、出力が勝った側にあたる。

Truth table:

布林表示式（最小 SOP）：

Boolean expression (minimum SOP):

ブール式（最小 SOP）：

$M = w_1 w_2 + w_1 w_3 + w_2 w_3$   必背$M = w_1 w_2 + w_1 w_3 + w_2 w_3$   memorise this$M = w_1 w_2 + w_1 w_3 + w_2 w_3$   要暗記

（任何一對 1 都會使 $M=1$ — 三個 2 輸入 AND 項再 OR 起來）。

(any pair of 1s makes $M=1$ — three 2-input AND terms ORed together).

（どの 1 の対でも $M=1$ になる — 2 入力の AND 項 3 つを OR で結んだ形である）。

4-to-1 MUX 的實作策略。把 $w_1, w_2$ 當作選擇輸入（$s_1 s_0 = w_1 w_2$）。每一種選擇樣式下的 MUX 輸出就是真值表所要求的值，並以 $w_3$ 為參數：

4-to-1 MUX implementation strategy. Use $w_1, w_2$ as select inputs ($s_1 s_0 = w_1 w_2$). The MUX output for each select pattern is whatever the truth table dictates, parameterized by $w_3$:

4-to-1 MUX による実装の方針。$w_1, w_2$ を選択入力とする（$s_1 s_0 = w_1 w_2$）。各選択パターンでの MUX 出力は真理値表が定めるとおりであり、$w_3$ をパラメータとして表される：

結果：接上 $I_0 = 0$、$I_1 = I_2 = w_3$、$I_3 = 1$。無論輸入的 $(w_1, w_2, w_3)$ 為何，這個 4-to-1 MUX 都會自動產生多數決輸出。

Result: connect $I_0 = 0$, $I_1 = I_2 = w_3$, $I_3 = 1$. The 4-to-1 MUX automatically produces the majority output for whatever $(w_1, w_2, w_3)$ comes in.

結果：$I_0 = 0$、$I_1 = I_2 = w_3$、$I_3 = 1$ とつなぐ。$(w_1, w_2, w_3)$ がどう入ってきても、4-to-1 MUX が自動的に多数決の出力を作る。

多數決為何有趣：它是「投票」／「故障遮蔽」類函數的典型例子 — 用於三重模組冗餘 (TMR)，把同一訊號的三份副本拿來表決，以遮蔽單一故障。它也是經典的 K-map 例題，因為其質蘊涵項 SOP 形式沒有靜態冒險。

Why majority is interesting: it's the canonical example of a "voting" / "fault-masking" function — used in triple-modular redundancy (TMR), where three copies of a signal are voted on to mask a single fault. Also a classic K-map example because its prime-implicant SOP form has no static hazards.

多数決が興味深い理由：「投票」「故障マスキング」型の関数の代表例だからである — 三重モジュール冗長 (TMR) で、同じ信号の 3 つの複製を多数決にかけて単一故障を隠すのに使われる。主項による SOP 形に静的ハザードがないことから、K-map の古典的な例題でもある。

定義。一個 $k$-LUT 是 FPGA 的基本可程式邏輯單元,可以實作任何 $k$ 變數的 Boolean 函數。本質上就是一塊 $2^k$ 位元的小型 SRAM,把 $k$ 個輸入當成 address,讀出對應位置儲存的 1 bit 即為函數輸出。

Definition. A $k$-LUT is the basic programmable logic element of an FPGA and can implement any Boolean function of $k$ variables. It is essentially a small $2^k$-bit SRAM: the $k$ inputs act as an address, and the single bit read out of that location is the function output.

定義。$k$-LUT は FPGA の基本となるプログラマブル論理素子で、$k$ 変数の任意のブール関数を実装できる。実体は $2^k$ ビットの小さな SRAM であり、$k$ 本の入力をアドレスとして、その番地から読み出した 1 ビットがそのまま関数の出力になる。

結構 (3-LUT 為例):Structure (using a 3-LUT as the example):構造（3-LUT を例に）：

$k$ 個輸入接到 $2^k$-to-1 MUX 的 select,$2^k$ 個 SRAM 位元接到 MUX 的資料輸入。Programming 時把目標函數的真值表寫入 SRAM;runtime 時 MUX 依輸入位址選出對應位元當作輸出。

The $k$ inputs drive the select lines of a $2^k$-to-1 MUX, and $2^k$ SRAM bits drive its data inputs. At programming time the target function's truth table is written into the SRAM; at runtime the MUX selects the addressed bit as the output.

$k$ 本の入力が $2^k$-to-1 MUX の select を駆動し、$2^k$ 個の SRAM ビットがそのデータ入力につながる。プログラム時に目的の関数の真理値表を SRAM へ書き込み、実行時には MUX がアドレスされたビットを選んで出力する。

具體例子: 要實作 $g(x_1, x_2, x_3) = x_1 x_2 + \overline{x_3}$,真值表為:

Concrete example: to implement $g(x_1, x_2, x_3) = x_1 x_2 + \overline{x_3}$, the truth table is:

具体例：$g(x_1, x_2, x_3) = x_1 x_2 + \overline{x_3}$ を実装するとき、真理値表は次のようになる：

把 8 個位元 1,1,1,1,0,0,0,1 寫入 SRAM,這顆 3-LUT 就「成為」函數 $g$。同一顆硬體要改實作別的函數,只需 reprogram SRAM 內容。

Write the eight bits 1,1,1,1,0,0,0,1 into the SRAM and this 3-LUT “becomes” the function $g$. To make the same hardware implement a different function, you only reprogram the SRAM contents.

8 ビット 1,1,1,1,0,0,0,1 を SRAM に書き込めば、この 3-LUT は関数 $g$ に「なる」。同じハードウェアで別の関数を実装したければ、SRAM の内容を書き換えるだけでよい。

關鍵特性:Key properties:重要な性質：

• 通用性 (universality): 一個 $k$-LUT 可實作 $2^{2^k}$ 種不同的 $k$ 變數函數 — 真值表寫什麼,輸出就是什麼,跟函數的「複雜度」(SOP 字數、AND/OR 數量) 無關。
• Universality: one $k$-LUT can implement all $2^{2^k}$ functions of $k$ variables — the output is whatever the truth table says, independent of how “complex” the function is (number of SOP terms, count of ANDs/ORs).
• 万能性 (universality)：1 個の $k$-LUT は $k$ 変数の関数 $2^{2^k}$ 種すべてを実装できる — 出力は真理値表に書いたとおりであり、関数の「複雑さ」（SOP の項数、AND/OR の個数）とは無関係である。
• 固定面積: 不管函數複雜或簡單,LUT 都佔同樣 $2^k$ bits 的儲存 + 一個 $2^k$-to-1 MUX,硬體成本固定。
• Fixed area: complex or simple, a LUT always costs the same $2^k$ bits of storage plus one $2^k$-to-1 MUX. The hardware cost is constant.
• 面積が一定：関数が複雑でも単純でも、LUT は同じ $2^k$ ビットの記憶と $2^k$-to-1 MUX 1 個を消費する。ハードウェアコストは一定である。
• 輸入數限制: 函數變數數 $> k$ 時,單顆 LUT 放不下,必須分解成多顆 LUT 接力 (cascading) — 這就是 functional decomposition 在 FPGA 設計上的直接應用。
• Input-count limit: when a function has more than $k$ variables it will not fit in a single LUT and must be decomposed across cascaded LUTs — the direct application of functional decomposition to FPGA design.
• 入力数の制限：関数の変数が $k$ 個を超えると 1 個の LUT には収まらず、複数の LUT へ分解して縦続接続 (cascading) しなければならない — 関数分解の FPGA 設計への直接的な応用である。

FPGA 中的角色:Role in an FPGA:FPGA における役割：

• 現代商用 FPGA 通常用 4-LUT(早期)或 6-LUT(Xilinx Virtex/Zynq、Intel Cyclone V/Stratix 等)為基本邏輯區塊。
• Modern commercial FPGAs use 4-LUTs (older parts) or 6-LUTs (Xilinx Virtex/Zynq, Intel Cyclone V/Stratix and so on) as the basic logic element.
• 現在の商用 FPGA は基本論理素子として 4-LUT（旧世代）または 6-LUT（Xilinx Virtex/Zynq、Intel Cyclone V/Stratix など）を用いる。
• 編譯流程: HDL → 邏輯合成 (gate-level netlist) → technology mapping (把通用 gate 改寫成 LUT 形式) → placement → routing。
• Compilation flow: HDL → logic synthesis (gate-level netlist) → technology mapping (rewriting generic gates into LUT form) → placement → routing.
• コンパイルの流れ：HDL → 論理合成（gate-level netlist）→ technology mapping（汎用ゲートを LUT の形へ書き換える）→ placement → routing。
• 每個 LUT 通常配有一個 D flip-flop,合稱一個 logic cell;許多 logic cell 又組成一個 logic block (CLB / LAB / ALM 視廠商而定)。
• Each LUT is usually paired with a D flip-flop, together forming a logic cell; many logic cells make up a logic block (CLB / LAB / ALM, depending on the vendor).
• 各 LUT にはふつう D フリップフロップが 1 個組み合わされ、合わせて logic cell となる。多数の logic cell が集まって logic block（ベンダによって CLB / LAB / ALM）を構成する。

本題 (4.41) 的應用: 4-to-1 MUX 共有 6 個輸入 ($s_1, s_0$ + $w_3, w_2, w_1, w_0$),但每顆 4-LUT 只能容納 4 個輸入。直觀做法 — 把 MUX 看成 $f = \overline{s_1}\overline{s_0}w_0 + \overline{s_1}s_0 w_1 + s_1\overline{s_0}w_2 + s_1 s_0 w_3$:先用兩顆 4-LUT 各算一半 (例如一顆做 $\overline{s_1}$ 那半:輸入 $s_0, w_0, w_1$ 共 3 個,輸出半結果;另一顆做 $s_1$ 那半:輸入 $s_0, w_2, w_3$),再用第三顆 4-LUT 用 $s_1$ 選擇兩半。共 3 顆 LUT。優化做法:利用 LUT 結構直接實作 $\text{MUX}(s_1, h_0, h_1)$,其中 $h_0, h_1$ 由前一級 LUT 算好,合併共用變數,可降到 2 顆 4-LUT。

Application to this problem (4.41): a 4-to-1 MUX has six inputs in total ($s_1, s_0$ plus $w_3, w_2, w_1, w_0$), but each 4-LUT holds only four. The straightforward approach — viewing the MUX as $f = \overline{s_1}\overline{s_0}w_0 + \overline{s_1}s_0 w_1 + s_1\overline{s_0}w_2 + s_1 s_0 w_3$: use two 4-LUTs for the two halves (one computes the $\overline{s_1}$ half from inputs $s_0, w_0, w_1$ — three inputs — and outputs a partial result; the other computes the $s_1$ half from $s_0, w_2, w_3$), then a third 4-LUT selects between the halves with $s_1$. Three LUTs in total. The optimised approach exploits the LUT structure to implement $\text{MUX}(s_1, h_0, h_1)$ directly, where $h_0, h_1$ come from the previous stage; sharing the common variables brings this down to two 4-LUTs.

本問 (4.41) への応用：4-to-1 MUX の入力は合計 6 本（$s_1, s_0$ と $w_3, w_2, w_1, w_0$）だが、4-LUT 1 個に入るのは 4 本までである。素直なやり方 — MUX を $f = \overline{s_1}\overline{s_0}w_0 + \overline{s_1}s_0 w_1 + s_1\overline{s_0}w_2 + s_1 s_0 w_3$ とみなし、2 個の 4-LUT で半分ずつ計算する（一方は $\overline{s_1}$ 側を入力 $s_0, w_0, w_1$ の 3 本から求めて中間結果を出し、もう一方は $s_1$ 側を $s_0, w_2, w_3$ から求める）。そのうえで 3 個目の 4-LUT が $s_1$ で両者を選択する。合計 3 個の LUT である。最適化したやり方では LUT の構造を活かして $\text{MUX}(s_1, h_0, h_1)$ を直接実装する。ここで $h_0, h_1$ は前段の LUT が出したもので、共通変数を共有することで 4-LUT 2 個まで減らせる。

跟 ROM 與 PLA 的差別: 三者都用 memory-like 結構儲存真值表,但 ROM 通常輸入較多 (大型解碼)、輸出多位元、address space 大;PLA 是固定 AND-OR plane 的可程式陣列;LUT 是細粒度單輸出單元 ($k$ 通常 4–6),由大量 LUT 組合構成 FPGA 的可程式邏輯。

How it differs from ROM and PLA: all three store a truth table in a memory-like structure, but a ROM typically has many inputs (large decoders), multi-bit outputs and a large address space; a PLA is a programmable array with fixed AND-OR planes; a LUT is a fine-grained single-output element ($k$ is usually 4–6), and an FPGA's programmable logic is built from a large number of them.

ROM や PLA との違い：3 つとも真理値表をメモリ的な構造に格納する点は同じだが、ROM は入力数が多く（大規模なデコーダ）、出力も多ビットでアドレス空間が広い。PLA は AND-OR プレーンが固定されたプログラマブルアレイである。LUT は細粒度の単一出力素子（$k$ はふつう 4–6）で、FPGA のプログラマブル論理はこれを大量に並べて構成される。

桶形移位器 (barrel shifter) 是一種組合電路，不論移位量多少，都能在一個時脈週期內把 $n$ 位元的向量移位（或旋轉）任意量。與每個時脈只移動一個位置的循序移位暫存器不同，桶形移位器完全以組合邏輯完成整個移位 — 靠的是平行的多工器。

A barrel shifter is a combinational circuit that shifts (or rotates) an $n$-bit vector by any amount in one clock cycle, regardless of how many bits the shift is. Unlike a sequential shift register, which moves one position per clock, a barrel shifter performs the entire shift through pure combinational logic — exploiting parallel multiplexers.

バレルシフタ (barrel shifter) は、シフト量がいくつであっても $n$ ビットのベクタを1 クロックサイクルで任意量シフト（または回転）する組合せ回路である。1 クロックに 1 位置ずつ動かす順序式のシフトレジスタとは違い、バレルシフタはシフト全体を純粋な組合せ論理で行う — 並列なマルチプレクサを活用するのである。

Two flavors:

• 旋轉式桶形移位器 — 從一端掉出的位元會從另一端回到序列中。輸出位元是輸入位元的循環排列。
• Rotating barrel shifter — bits that fall off one end re-enter the other. Output bits are a cyclic permutation of input bits.
• 回転型バレルシフタ — 片端からあふれたビットが反対端から入り直す。出力ビットは入力ビットの巡回置換になる。
• 邏輯／算術移位桶形移位器 — 掉出的位元被丟棄；空出的位置補 0（邏輯移位）或補符號延伸（算術移位）。
• Logical/Arithmetic shift barrel shifter — bits that fall off are discarded; vacated positions get 0 (logical) or sign-extension (arithmetic).
• 論理／算術シフトバレルシフタ — あふれたビットは捨てられ、空いた位置には 0（論理）または符号拡張（算術）が入る。

習題 4.43 要求的是一個旋轉式 4 位元移位器（$n=4$），移位量 $\{0,1,2,3\}$ 由 2 位元控制訊號 $S = s_1 s_0$ 選擇。

Problem 4.43 asks for a rotating 4-bit shifter ($n=4$) with shift amounts $\{0,1,2,3\}$ selected by a 2-bit control $S = s_1 s_0$.

問題 4.43 が求めているのは回転型の 4 ビットシフタ（$n=4$）で、シフト量 $\{0,1,2,3\}$ を 2 ビットの制御 $S = s_1 s_0$ で選ぶ。

功能表（輸入 $W = w_3 w_2 w_1 w_0$，輸出 $Y = y_3 y_2 y_1 y_0$）：

Functional table (input $W = w_3 w_2 w_1 w_0$, output $Y = y_3 y_2 y_1 y_0$):

機能表（入力 $W = w_3 w_2 w_1 w_0$、出力 $Y = y_3 y_2 y_1 y_0$）：

每個輸出位元都需要一個 4-to-1 MUX，其資料輸入是四個候選來源位元，選擇訊號為 $S$。從表中往下讀每一個 $y_i$ 欄，就知道 MUX$_i$ 的資料輸入是什麼：

Each output bit needs a 4-to-1 MUX whose data inputs are the four candidate source bits and whose select is $S$. From the table, reading down each $y_i$ column tells you the data inputs to MUX$_i$:

各出力ビットには 4-to-1 MUX が 1 個必要で、そのデータ入力は候補となる 4 本のソースビット、選択入力は $S$ である。表の各 $y_i$ 列を上から下へ読めば、MUX$_i$ のデータ入力が分かる：

• $y_3$ 的 MUX：$S = (00, 01, 10, 11)$ 對應的資料線為 $(w_3, w_0, w_1, w_2)$
• MUX for $y_3$: data lines $(w_3, w_0, w_1, w_2)$ for $S = (00, 01, 10, 11)$
• $y_3$ 用の MUX：$S = (00, 01, 10, 11)$ に対するデータ線は $(w_3, w_0, w_1, w_2)$
• $y_2$ 的 MUX：資料線 $(w_2, w_3, w_0, w_1)$
• MUX for $y_2$: data lines $(w_2, w_3, w_0, w_1)$
• $y_2$ 用の MUX：データ線 $(w_2, w_3, w_0, w_1)$
• $y_1$ 的 MUX：資料線 $(w_1, w_2, w_3, w_0)$
• MUX for $y_1$: data lines $(w_1, w_2, w_3, w_0)$
• $y_1$ 用の MUX：データ線 $(w_1, w_2, w_3, w_0)$
• $y_0$ 的 MUX：資料線 $(w_0, w_1, w_2, w_3)$
• MUX for $y_0$: data lines $(w_0, w_1, w_2, w_3)$
• $y_0$ 用の MUX：データ線 $(w_0, w_1, w_2, w_3)$

規律：每個 MUX$_i$ 的資料輸入為 $(w_i, w_{(i-1)\bmod 4}, w_{(i-2)\bmod 4}, w_{(i-3)\bmod 4})$ — 正好是 $W$ 從位置 $i$ 開始的循環移位。

Pattern: each MUX$_i$ has data inputs $(w_i, w_{(i-1)\bmod 4}, w_{(i-2)\bmod 4}, w_{(i-3)\bmod 4})$ — exactly the cyclic shift of $W$ starting at position $i$.

法則：各 MUX$_i$ のデータ入力は $(w_i, w_{(i-1)\bmod 4}, w_{(i-2)\bmod 4}, w_{(i-3)\bmod 4})$ である — ちょうど位置 $i$ から始まる $W$ の巡回シフトになっている。

電路圖（四個共用同一 $S$ 的並列 4-to-1 MUX）：

Schematic (four parallel 4-to-1 MUXes sharing the same $S$):

回路図（同じ $S$ を共有する 4 個の並列 4-to-1 MUX）：

Verilog（可對任意 2 的冪次 $n$ 參數化）：

Verilog (parameterized for any $n$ that is a power of 2):

Verilog（2 のべき乗である任意の $n$ に対してパラメータ化）：

module barrel_rot4 (
  input  [3:0] W,
  input  [1:0] S,
  output [3:0] Y
);
  // each output is the input rotated right by S
  assign Y = (W >> S) | (W << (4 - S));
endmodule

`(W >> S) | (W << (4-S))` 這個式子是右旋轉的標準寫法：從低位移出去的位元，會經由反向移位從高位回來。合成工具會把它變成上面那四個 4-to-1 MUX。

The expression `(W >> S) | (W << (4-S))` is the canonical right-rotate idiom: bits shifted off the bottom re-enter at the top via the inverted shift. The synthesis tool will turn this into the four 4-to-1 MUXes shown above.

`(W >> S) | (W << (4-S))` という式は右回転の定石である：下位からあふれたビットが、逆向きのシフトによって上位から入り直す。合成ツールはこれを上に示した 4 個の 4-to-1 MUX に変える。

成本 & 深度。由 $n$ 個並列 $n$-to-1 MUX 建成的 $n$ 位元桶形旋轉器使用 $O(n^2)$ 個閘，延遲為一個 MUX。當 $n$ 較大時，改用對數式的多級桶形移位器（每個位元 $\log_2 n$ 級的 2-to-1 MUX）可把成本降到 $O(n \log n)$，代價是 $\log_2 n$ 個 MUX 延遲 — 這就是現代 CPU 中 ALU 移位器的標準設計。

Cost & depth. An $n$-bit barrel rotator built from $n$ parallel $n$-to-1 MUXes uses $O(n^2)$ gates and one MUX-delay. For larger $n$, a logarithmic multi-stage barrel shifter ($\log_2 n$ stages of 2-to-1 MUXes per bit) cuts cost to $O(n \log n)$ at the price of $\log_2 n$ MUX delays — the standard ALU shifter design in modern CPUs.

コスト & 段数。$n$ 並列の $n$-to-1 MUX で作った $n$ ビットのバレル回転器は $O(n^2)$ 個のゲートを使い、遅延は MUX 1 段分である。$n$ が大きい場合、対数段の多段バレルシフタ（1 ビットあたり 2-to-1 MUX を $\log_2 n$ 段）にすればコストは $O(n \log n)$ に下がるが、代わりに $\log_2 n$ 段分の MUX 遅延がかかる — 現代の CPU における ALU シフタの標準的な設計である。

寫法 1 — 逐位元明確指派：

Style 1 — explicit bit assignments:

スタイル 1 — ビットごとの明示的な代入：

module shifter_if (input [3:0] R, input shift, output reg [3:0] Q);
    always @* begin
        if (shift) begin
            Q[3] = 1'b0;       // fill MSB with 0
            Q[2] = R[3];
            Q[1] = R[2];
            Q[0] = R[1];       // R[0] discarded
        end else
            Q = R;
    end
endmodule

寫法 2 — 使用 >>：

Style 2 — using >>:

スタイル 2 — >> を使う：

module shifter_op (input [3:0] R, input shift, output [3:0] Q);
    assign Q = shift ? (R >> 1) : R;
endmodule

為什麼偏好 >>？

Why prefer >>?

なぜ >> のほうがよいのか？

結論：對固定 1 位元的移位而言，兩者在電氣上完全相同（都會合成成單純的接線改名 — 不含正反器）。但 >> 處在對的抽象層級：它陳述的是運算本身，而非其實作方式。面對參數化的寬度或可變的移位量時，>> 讓你不必手工寫出桶形多工器。課本兩種寫法都要求，是為了說清楚 HDL 運算子並不是魔法 — 它們只是你原本可以用結構化方式寫出來的東西的簡寫。

Bottom line: the two are electrically identical for a fixed 1-bit shift (both synthesize to a trivial wire-rename — no flip-flops). But >> is the right level of abstraction: it states the operation rather than its implementation. For parameterized widths or variable shift amounts, >> saves you from writing a barrel multiplexer by hand. The textbook asks for both styles to make clear that HDL operators are not magic — they're shorthand for what you could otherwise write structurally.

結論：1 ビット固定のシフトなら、両者は電気的に同一である（どちらも単なる配線の付け替えに合成され、フリップフロップは生じない）。しかし >> のほうが抽象度として適切である：実装ではなく演算そのものを述べているからである。幅をパラメータ化する場合や、シフト量が可変の場合、>> のおかげでバレルマルチプレクサを手書きせずに済む。教科書が両方の書き方を求めるのは、HDL の演算子が魔法ではないこと — 構造的に書こうと思えば書けるものの略記にすぎないこと — をはっきりさせるためである。

範例 5.3 回顧（阻擋式 — 用於串接是錯的）。課本從這段程式碼開始：

Recap of Example 5.3 (blocking — wrong for cascading). The textbook starts with this code:

例 5.3 の復習（ブロッキング — 縦続接続には不適）。教科書はこのコードから始まる：

module example5_3 (D, Clock, Q1, Q2);
  input D, Clock;
  output reg Q1, Q2;
  always @(posedge Clock) begin
    Q1 = D;     // blocking
    Q2 = Q1;    // blocking — Q1 already updated
  end
endmodule

阻擋式指定是循序求值的。在 Q1 = D; 之後，變數 Q1 已經持有新值 D，所以 Q2 = Q1; 讀到的也是 D。兩個 FF 在每個時脈邊緣都閂鎖同一個輸入：

Blocking assignments evaluate sequentially. After Q1 = D;, the variable Q1 already holds the new value D, so Q2 = Q1; reads D as well. Both FFs latch the same input on every clock edge:

ブロッキング代入は逐次に評価される。Q1 = D; のあと、変数 Q1 はすでに新しい値 D を保持しているので、Q2 = Q1; も D を読む。両方の FF がクロックエッジごとに同じ入力を取り込む：

習題 5.16 — 非阻擋式（正確）：把 = 換成 <=：

Problem 5.16 — non-blocking (right): swap = for <=:

問題 5.16 — ノンブロッキング（正解）：= を <= に置き換える：

always @(posedge Clock) begin
  Q1 <= D;     // non-blocking
  Q2 <= Q1;    // reads OLD Q1 (value at block entry)
end

非阻擋式指定全都在 always 區塊觸發的那一刻取樣各自的右側，然後在結尾一起提交新值。因此 Q2 <= Q1; 讀到的是 Q1 的前一個值 — 這正是真實串接 FF 的行為。合成出來的硬體是不折不扣的兩級移位暫存器：

Non-blocking assignments all sample their right-hand sides at the moment the always block fires, then commit new values together at the end. So Q2 <= Q1; reads the previous value of Q1 — exactly what a real cascaded FF does. The synthesized hardware is a true 2-stage shift register:

ノンブロッキング代入はいずれも always ブロックが起動した時点で右辺をサンプルし、最後に新しい値をまとめて確定する。したがって Q2 <= Q1; は Q1 の直前の値を読む — 実際に縦続接続した FF の動作そのものである。合成されるハードウェアは正真正銘の 2 段シフトレジスタとなる：

單一上升緣的語意對照。假設邊緣之前為：$D=1, Q_1=0, Q_2=0$。

Side-by-side semantics for one rising edge. Suppose before the edge: $D=1, Q_1=0, Q_2=0$.

1 回の立上りエッジにおける意味論の対比。エッジの直前が $D=1, Q_1=0, Q_2=0$ だとする。

使用非阻擋式時，要到第二個時脈邊緣之後 $Q_2$ 才終於變成 1 — 輸入已經走過兩級，所以才叫「移位暫存器」。

After the second clock edge with non-blocking, $Q_2$ finally becomes 1 — the input has propagated through two stages, hence "shift register".

ノンブロッキングでは、2 回目のクロックエッジのあとにようやく $Q_2$ が 1 になる — 入力が 2 段を伝わったわけで、だから「シフトレジスタ」と呼ぶ。

經驗法則。 在時脈驅動的 always @(posedge clk) 區塊裡，一切都用非阻擋式（<=）。阻擋式（=）只用在組合邏輯的 always @(*) 區塊，那裡的循序求值恰好對應閘級的資料流。在同一個區塊裡混用兩者，是合成與模擬不一致最常見的來源。

Rule of thumb. Use non-blocking (<=) for everything inside a clocked always @(posedge clk) block. Use blocking (=) only in combinational always @(*) blocks where sequential evaluation matches gate-level dataflow. Mixing the two in the same block is the most common source of synthesis-vs-simulation mismatches.

経験則。 クロック同期の always @(posedge clk) ブロックの中では、すべてノンブロッキング（<=）を使う。ブロッキング（=）は、逐次評価がゲートレベルのデータフローと一致する組合せ用の always @(*) ブロックでのみ使う。同じブロックで両者を混ぜることが、合成とシミュレーションの食い違いのもっとも多い原因である。

Four requirements:

1. 參數化的 Verilog 模組 regn — 模組名稱為 regn（「register，參數化的 n」）。必須使用 Verilog 的 parameter 機制，讓位元寬度不被寫死 — 同一份模組檔案，只要在實例化時傳入不同的值，就能適用於任意寬度。

1. parameterized Verilog module regn — module name is regn ("register, parameterized n"). Must use Verilog's parameter mechanism so the bit width is not hard-coded — the same module file works for any width by passing a different value at instantiation.

1. パラメータ化された Verilog モジュール regn — モジュール名は regn（「register、パラメータ化された n」）である。ビット幅をハードコードしないよう Verilog の parameter 機構を使わなければならない — 同じモジュールファイルが、インスタンス化時に違う値を渡すだけでどの幅にも使える。

2. 用於 $n$ 位元暫存器 — 也就是 $n$ 個 D 正反器並聯成的一組：輸入匯流排 D[n-1:0]、輸出匯流排 Q[n-1:0]，共用一個時脈。每個時脈上升緣，$n$ 個輸入同時閂鎖到 $n$ 個輸出。

2. for an $n$-bit register — a bank of $n$ D flip-flops in parallel: input bus D[n-1:0], output bus Q[n-1:0], one shared clock. On each rising clock edge, the $n$ inputs latch into the $n$ outputs simultaneously.

2. $n$ ビットレジスタ用 — $n$ 個の D フリップフロップを並列に並べたものである：入力バス D[n-1:0]、出力バス Q[n-1:0]、クロックは 1 本を共有する。クロックの立上りごとに、$n$ 本の入力が $n$ 本の出力へ同時に取り込まれる。

3. 具備非同步清除 — 一個重置訊號，在 assert 時立刻把全部 $n$ 個位元清為 0，而不等待下一個時脈邊緣。實作上，重置訊號會和時脈一起放進 always 區塊的敏感度列表（always @(posedge Clock or negedge Resetn)），因此重置一 assert，該區塊就觸發。對照之下，同步清除要到下一個時脈上升緣才會生效。

3. with asynchronous clear — a reset signal that clears all $n$ bits to 0 immediately when asserted, not waiting for the next clock edge. Implementation-wise, the reset signal goes into the always-block sensitivity list along with the clock (always @(posedge Clock or negedge Resetn)), so the block fires the moment reset asserts. Contrast: a synchronous clear would only take effect on the next rising clock edge.

3. 非同期クリア付き — アサートされた瞬間に $n$ ビットすべてをただちに 0 にするリセット信号であり、次のクロックエッジを待たない。実装上は、リセット信号をクロックとともに always ブロックの感度リストに入れる（always @(posedge Clock or negedge Resetn)）ので、リセットがアサートされた瞬間にブロックが起動する。対して同期クリアは、次のクロック立上りではじめて効く。

4. 其中 $n$ 是帶有預設值的 parameter：

4. where $n$ is a parameter with a default value:

4. ただし $n$ は既定値をもつ parameter である：

• n 要用 parameter 宣告（不是 localparam，也不是寫死的數字）。
• n declared with parameter (not localparam, not a hard-coded number).
• n は parameter で宣言する（localparam でも、直書きの数値でもない）。
• 要提供預設值，讓實例化時不指定寬度也能得到合理的預設（例如 8 位元）。
• Default value provided so instantiating without specifying width gets a sensible fallback (e.g., 8 bits).
• 既定値を与えておき、幅を指定せずにインスタンス化しても妥当な既定（たとえば 8 ビット）になるようにする。

評分時會檢查的重點：單一模組檔案就支援 regn r1();（預設）、regn #(.n(16)) r2();（16 位元）、regn #(32) r3();（32 位元） — 全都不必改動原始碼。assert Resetn 會讓 Q 在時脈邊緣之間就掉到 0（波形上看得見）。Resetn 未作用時，全部 $n$ 個位元都在時脈上升緣載入 D。

What the grader checks: one module file that supports regn r1(); (default), regn #(.n(16)) r2(); (16-bit), regn #(32) r3(); (32-bit) — all without editing the source. Asserting Resetn drops Q to 0 between clock edges (visible in waveform). All $n$ bits load D on the rising clock edge when Resetn is inactive.

採点で見られる点：1 つのモジュールファイルで regn r1();（既定）、regn #(.n(16)) r2();（16 ビット）、regn #(32) r3();（32 ビット）をすべてサポートし、しかもソースを書き換えずに済むこと。Resetn をアサートすると、クロックエッジの間で Q が 0 に落ちる（波形で確認できる）。Resetn が非アクティブなら、クロックの立上りで $n$ ビットすべてが D を取り込む。

muxdff 是並列載入／移位暫存器裡的主力單元：一個 D 正反器，前面接一個 2 對 1 多工器，用來在兩個下一狀態值之間做選擇。這個 MUX 的選擇線通常叫做 L（load）：

A muxdff is the workhorse cell of a parallel-load / shift register: a single D flip-flop preceded by a 2-to-1 multiplexer that selects between two next-state values. The MUX's select line is usually called L (load):

muxdff は、並列ロード／シフトレジスタの主力セルである。D フリップフロップ 1 個の手前に 2-to-1 マルチプレクサを置き、2 つの次状態値のどちらかを選ぶ。この MUX の選択線はふつう L（load）と呼ばれる：

• L = 0 — MUX 選擇「移位」輸入 w；FF 把來自鄰接單元的位元打進去。整條鏈就移位。
• L = 0 — MUX picks the "shift" input w; the FF clocks in the bit coming from a neighbour cell. The chain shifts.
• L = 0 — MUX は「シフト」入力 w を選ぶ。FF は隣のセルから来たビットを取り込む。チェーンはシフトする。
• L = 1 — MUX 選擇「並列」輸入 R；FF 把外部來的新資料位元打進去。暫存器就完成載入。
• L = 1 — MUX picks the "parallel" input R; the FF clocks in a fresh data bit from outside. The register loads.
• L = 1 — MUX は「並列」入力 R を選ぶ。FF は外部から来た新しいデータビットを取り込む。レジスタはロードする。

它是能讓暫存器在單一控制位元之下兼做兩件事（移位或載入）的最小積木。

It's the smallest building block that lets a register do both jobs (shift OR load) under a single control bit.

1 本の制御ビットだけでレジスタに 2 つの仕事（シフトまたはロード）をさせられる、最小の構成要素である。

Verilog for the muxdff cell:

module muxdff (
  input  R, w, L, Clock,
  output reg Q
);
  always @(posedge Clock)
    Q <= L ? R : w;   // L=1 → load R; L=0 → shift in w
endmodule

用四個 muxdff 單元串接，做出 4 位元並列載入移位暫存器：

Building a 4-bit parallel-load shift register by chaining four muxdff cells:

4 個の muxdff セルを縦続接続して 4 ビット並列ロードシフトレジスタを作る：

每個單元的 MUX 下方輸入接到前一個單元的 Q。L=0 時，位元沿著鏈一路傳遞（移位）。L=1 時，每個單元並列載入各自對應的 R[i]。

Each cell's MUX bottom input is wired to the previous cell's Q. With L=0, bits ripple through the chain (shift). With L=1, every cell loads its corresponding R[i] in parallel.

各セルの MUX の下側入力は、前段セルの Q に配線される。L=0 ならビットはチェーンを伝わっていく（シフト）。L=1 なら各セルが対応する R[i] を並列に取り込む。

Hierarchical Verilog (problem 5.22's task):

module shift_load_4 (
  input  [3:0] R,
  input        L, w, Clock,
  output [3:0] Q
);
  muxdff bit3 (.R(R[3]), .w(w),    .L(L), .Clock(Clock), .Q(Q[3]));
  muxdff bit2 (.R(R[2]), .w(Q[3]), .L(L), .Clock(Clock), .Q(Q[2]));
  muxdff bit1 (.R(R[1]), .w(Q[2]), .L(L), .Clock(Clock), .Q(Q[1]));
  muxdff bit0 (.R(R[0]), .w(Q[1]), .L(L), .Clock(Clock), .Q(Q[0]));
endmodule

為什麼 muxdff 這層抽象很重要：真實設計裡幾乎每個暫存器都不只要「每個邊緣把 D 打進 Q」而已。加上載入、移位、保持與重置的能力，if 和邊角情況會愈堆愈多。把每種組合收成一個有名字的小單元（muxdff，再加上 enable／reset 變體），然後為 n 位元暫存器實例化 n 份，是擴展規模最乾淨的做法 — 單元驗證一次，到處重用。

Why the muxdff abstraction matters: almost every register in a real design needs more than just "clock D into Q on each edge". Adding load, shift, hold, and reset capabilities can pile up ifs and edge cases. Capturing each combination as a tiny named cell (muxdff, plus enable/reset variants) and instantiating n copies for an n-bit register is the cleanest way to scale — verify the cell once, reuse everywhere.

muxdff という抽象がなぜ効くのか：実際の設計では、ほとんどのレジスタが「エッジごとに D を Q へ取り込む」だけでは足りない。ロード、シフト、ホールド、リセットを足していくと、if と例外ケースが積み上がる。組合せごとに名前を付けた小さなセル（muxdff と、enable／reset 版）としてまとめ、n ビットレジスタには n 個インスタンス化する — これが規模を広げるいちばんきれいなやり方である。セルを一度検証すれば、あとはどこでも再利用できる。

圖 5.70a — 兩個串接的反相器，從內部節點 A 與 B 拉出訊號

Figure 5.70a — two cascaded inverters tap-off internal nodes A and B

図 5.70a — 縦続接続した 2 個のインバータから内部ノード A と B を取り出す

因此 $A = \overline{C}$ 是延遲 $\Delta$ 後的結果，而 $B = C$ 是延遲 $2\Delta$ 後的結果（也就是 $A$ 再反相一次）。

So $A = \overline{C}$ delayed by $\Delta$, and $B = C$ delayed by $2\Delta$ (i.e. $A$ further inverted).

したがって $A = \overline{C}$ は $\Delta$ だけ遅れたもの、$B = C$ は $2\Delta$ だけ遅れたもの（すなわち $A$ をさらに反転したもの）である。

電路。兩個邊緣觸發的 JK 正反器共用時脈輸入 $w$ 與一個共同的非同步 Clear。兩個 K 輸入都綁在邏輯 1，所以每個 FF 不是保持（$J=0$ 時）就是翻轉（$J=1$ 時）。組合邏輯的接線如下：

The circuit. Two edge-triggered JK flip-flops share clock input $w$ and a common asynchronous Clear. Both K inputs are tied to logic 1, so each FF either holds (when $J=0$) or toggles (when $J=1$). The combinational wiring is:

回路。エッジトリガの JK フリップフロップ 2 個が、クロック入力 $w$ と共通の非同期 Clear を共有する。K 入力はどちらも論理 1 に固定されているので、各 FF は保持（$J=0$ のとき）かトグル（$J=1$ のとき）のいずれかになる。組合せ回路の配線は次のとおりである：

• $J_0 = \overline{Q_1}$、$K_0 = 1$  （FF0 會翻轉，除非 $Q_1=1$，此時它會被重置）
• $J_0 = \overline{Q_1}$, $K_0 = 1$  (FF0 toggles unless $Q_1=1$, in which case it resets)
• $J_0 = \overline{Q_1}$、$K_0 = 1$  （FF0 はトグルするが、$Q_1=1$ のときはリセットされる）
• $J_1 = Q_0$、 $K_1 = 1$  （FF1 在 $Q_0=1$ 時翻轉，否則被重置）
• $J_1 = Q_0$,  $K_1 = 1$  (FF1 toggles when $Q_0=1$, otherwise resets)
• $J_1 = Q_0$、 $K_1 = 1$  （FF1 は $Q_0=1$ のときトグルし、そうでなければリセットされる）

JK 行為回顧。在 $w$ 的每個上升緣：

JK behavior recap. On each rising edge of $w$:

JK の動作の復習。$w$ の立上りごとに：

逐狀態走一遍。從 Clear $\Rightarrow Q_1Q_0=00$ 開始：

State walk-through. Start from Clear $\Rightarrow Q_1Q_0=00$:

状態を順に追う。Clear $\Rightarrow Q_1Q_0=00$ から始める：