Minimum POS from a K-Map

The K-map procedure for Product of Sums is identical to SOP with three changes:

   1. Group the ZEROS instead of the ones.
   2. Read each group as a SUM term (not a product).
   3. INVERT the reading rule:
         variable constant at 0  ->  write it PLAIN      (A)
         variable constant at 1  ->  write it COMPLEMENTED (A')
         variable changing       ->  drop it
   4. AND all the sum terms together.

Why the inversion? Grouping the 0s gives you the minimum SOP of F'. Complementing that with De Morgan turns products into sums and flips every literal — which is exactly the modified reading rule.

Worked Example 1 — 3 Variables

F(A, B, C) = Σm(0, 1, 2, 5, 7), so the 0s are at m3, m4, m6.

              BC
         00     01     11     10
       +------+------+------+------+
   A=0 |  1   |  1   |  0   |  1   |
       | (0)  | (1)  | (3)  | (2)  |
       +------+------+------+------+
   A=1 |  0   |  1   |  1   |  0   |
       | (4)  | (5)  | (7)  | (6)  |
       +------+------+------+------+

Group the zeros:

   Zeros at m3 (011), m4 (100), m6 (110)

   Group 1: m4, m6  (row A=1, columns 00 and 10)
            A = 1 constant   ->  A'
            B changes        ->  drop
            C = 0 constant   ->  C
            Sum term:  (A' + C)

   Group 2: m3 alone (011)   -- check adjacency: m1(001)? that's a 1. m7(111)? that's a 1.
            A = 0  ->  A
            B = 1  ->  B'
            C = 1  ->  C'
            Sum term:  (A + B' + C')

   F = (A' + C)(A + B' + C')

Verification by expansion:

   (A' + C)(A + B' + C')
 = A'A + A'B' + A'C' + CA + CB' + CC'
 = 0 + A'B' + A'C' + AC + B'C + 0
 Test A=0,B=1,C=1 (m3): A'B'=0, A'C'=0, AC=0, B'C=0  ->  F = 0  ✓
 Test A=1,B=0,C=1 (m5): AC = 1  ->  F = 1  ✓

Worked Example 2 — 4 Variables

F(A, B, C, D) = ΠM(0, 1, 4, 5, 10, 11, 14, 15) — the maxterm list already tells you where the 0s are.

                     CD
            00     01     11     10
         +------+------+------+------+
   AB 00 |  0   |  0   |  1   |  1   |
         | (0)  | (1)  | (3)  | (2)  |
         +------+------+------+------+
      01 |  0   |  0   |  1   |  1   |
         | (4)  | (5)  | (7)  | (6)  |
         +------+------+------+------+
      11 |  1   |  1   |  0   |  0   |
         | (12) | (13) | (15) | (14) |
         +------+------+------+------+
      10 |  1   |  1   |  0   |  0   |
         | (8)  | (9)  | (11) | (10) |
         +------+------+------+------+

Group the zeros:

   Group 1 (4 cells): m0, m1, m4, m5   (top-left block)
        A = 0 constant  ->  A
        B changes       ->  drop
        C = 0 constant  ->  C
        D changes       ->  drop
        Sum term:  (A + C)

   Group 2 (4 cells): m10, m11, m14, m15  (bottom-right block)
        A = 1 constant  ->  A'
        B changes       ->  drop
        C = 1 constant  ->  C'
        D changes       ->  drop
        Sum term:  (A' + C')

   F = (A + C)(A' + C')

That is exactly A ⊕ C — the function is 1 whenever A and C differ.

Worked Example 3 — Compare SOP and POS Cost

F(A, B, C, D) = Σm(1, 3, 5, 7, 9, 11, 13, 15) (all odd minterms)

   SOP: the 1s occupy the two columns CD = 01 and CD = 11 -> D = 1 always.
        Group of 8 cells  ->  F = D              (1 term, 1 literal)

   POS: the 0s occupy CD = 00 and CD = 10  ->  D = 0 always.
        Group of 8 cells  ->  sum term (D)
        F = (D)                                  (same answer)

Both forms agree, as they always must — the cost is what differs from function to function.

   Rule of thumb:
      map dominated by 1s   ->  POS is usually cheaper (few 0-groups)
      map dominated by 0s   ->  SOP is usually cheaper (few 1-groups)

Complete Comparison

Getting F' for Free

While grouping the 0s you have already produced the minimum SOP of F'.

   Example 2 above:  the 0-groups read in SOP style were
       Group 1: A' C'          (A=0 -> A', C=0 -> C')
       Group 2: A C
   So   F' = A'C' + AC
   And  F  = (F')' = (A'C' + AC)' = (A + C)(A' + C')   ✓  matches

Practice Problems

   1. F(A,B,C) = Σm(0, 2, 4, 5, 6)   -> minimum POS
      Zeros at m1, m3, m7.
      m1(001), m3(011) group -> A=0 ->A, C=1 ->C', B changes -> (A + C')
      m3(011), m7(111) group -> B=1 ->B', C=1 ->C', A changes -> (B' + C')
      F = (A + C')(B' + C')

   2. F(A,B,C,D) = ΠM(3, 7, 11, 15)  -> minimum POS
      Zeros are the whole column CD = 11  ->  C=1 ->C', D=1 ->D'
      F = (C' + D')

   3. F(A,B,C,D) = Σm(0,1,2,3,4,5,6,7)  -> minimum POS
      Zeros are m8..m15, i.e. A = 1 everywhere -> A' ... wait, A=1 constant -> write A'
      F = (A')

The next lesson adds the one extra ingredient that makes K-maps genuinely powerful in real designs: don't care conditions.