(a) Fan-in = number of inputs = 3 (three NMOS stacked in series in the pull-down net).
(b) Fan-out counts the loads, not the inputs. The output drives 5 inputs, so total load Cout=5Cg.
f=CinCout=3Cg5Cg=35≈1.667
Notice fan-out is not simply "5" here — it is 5 relative to this gate's own input size. A wider gate with the same 5 loads would have a smaller f.
Recall Solution L1.2
A NOR output is high only when all inputs are low, so the pull-up must be all PMOS in series → the PMOS pull-up carries the 4-transistor stack. This matters because PMOS carriers (holes) have roughly half the mobility of NMOS carriers (electrons), so a PMOS must be ~2× wider for the same drive. That is exactly why NOR's logical effort g=32N+1 carries the "2N" penalty. See CMOS Static Logic Gates.
Step — electrical effort. 6 equal loads on an equal-size driver ⇒ f=6. Why: each load equals the input cap, six in parallel.
Step — plug the law.d=gf+p=1⋅6+1=7τ.
Double the loads to 12 and d=13τ — nearly double: delay is linear in fan-out.
Recall Solution L2.2
d=gf+p=34⋅4+2=316+2=322≈7.33τ
Compare an inverter at the same f=4: d=1⋅4+1=5τ. The NAND is slower both because g>1 (steeper slope) and p>1 (higher offset).
Recall Solution L2.3
Origin of 0.69. The output rises as V(t)=VDD(1−e−t/RC). The 50% crossing solves 0.5=1−e−t/RC ⇒ e−t/RC=0.5 ⇒ t=RCln2=0.6931RC.
Number.tpd=0.69×(10×103)×(20×10−15)=0.69×2.0×10−10=1.38×10−10 s=138 ps.
Ratio =12/322=2236=1118≈1.64.
Fan-in raised bothg (slope: 34→2) and p (offset: 2→4), so the same load costs ~64% more delay. This is why we split large gates into trees (next level). See Transistor Sizing.
Recall Solution L3.2
NAND-3: d=35⋅3+3=5+3=8τ.
NOR-3: d=37⋅3+3=7+3=10τ.
The NOR is 10/8=1.25× slower at identical fan-in and load, purely because it stacks weak PMOS. Rule of thumb: NOR is poorer — prefer NAND logic in CMOS.
Recall Solution L3.3
Step. Output current splits among loads; to keep the high level valid, N⋅Iin≤IOH.
Nmax=⌊IinIOH⌋=⌊0.24⌋=20 loadsPure CMOS: gate leakage Iin≈0, so this DC limit is essentially infinite — the real limit becomes capacitive (speed), not current. The current limit only bites at TTL/interface boundaries.
2-input NAND:d=34⋅4+2=322≈7.33τ per stage.
A balanced tree reaching 8 inputs needs log28=3 levels of 2-input gates, roughly 3×7.33≈22τ end-to-end — comparable to a single 8-NAND for one stage, but the tree's stages each drive light, well-sized loads and can be pipelined/buffered, whereas the monolithic 8-NAND's 8R series resistance and p=8 cannot be undone. As fan-in grows the monolithic delay climbs super-linearly; the tree grows only logarithmically in depth. See Buffer Sizing and Inverter Chains.
Recall Solution L4.2
(A) direct:d=1⋅64+1=65τ.
(B) two equal stages: each stage f=8, so dstage=1⋅8+1=9τ, total d=2×9=18τ.
Splitting a large effort into equal geometric-mean stages turns a linear65τ into a much smaller 18τ. This is the whole idea of Buffer Sizing and Inverter Chains: the optimal per-stage effort is around e≈4, so very large fan-outs want several stages.
(a) Doubling driver width halves its on-resistance, so its own electrical effort seen from its load halves in effect: the load Cout is unchanged but Cin doubles, so f=Cout/Cin drops from 16 to 8. New delay d=1⋅8+1=9τ (was 17τ).
(b) But doubling this gate's width doubles its input capacitance, which is the load of the previous stage. The previous stage's fdoubles, adding delay upstream.
Conclusion: fan-out fixes ripple backward. You cannot locally upsize without paying earlier in the chain — the correct answer is a jointly sized chain (equal effort per stage), not one greedy stage. See Propagation Delay and Timing.
Recall Solution L5.2
Per-stage delays with common f=2.29:
NOR-2: d1=35(2.29)+2=3.817+2=5.817
NAND-3: d2=35(2.29)+3=3.817+3=6.817
Inverter: d3=1(2.29)+1=3.29dpath=5.817+6.817+3.29=15.92τ
Read the anatomy: the slope terms (gf) reward keeping stage effort near the optimum (≈e); the offset terms (p) are the fixed cost of the chosen gates. The NOR and NAND cost more p than an inverter — that is the fan-in tax showing up in the path budget. (Check: the logical-effort optimum verifies F=G⋅B⋅H style bookkeeping in Logical Effort.)