접속 그래프는 임의의 두 정점 사이의 경로를 포함하는 그래프이다.

도전

4 버텍스 그래프가 연결되어 있는지 확인하는 [2 입력 NAND 게이트] 회로를 구축하십시오.
(게이트의 2 개의 입력 은 동일한 입력 비트 또는 다른 게이트 일 수 있습니다.)
출력 그래프가 연결된 경우 True이고, 그렇지 않으면 False입니다.

입력

4 개의 정점 이있는 간단한 그래프 의 6 가지 가능한 가장자리 :

[ ₀ e ₁ , ₀ e ₂ , ₁ e ₂ , ₀ e ₃ , ₁ e ₃ , ₂ e ₃ ]

여기서 _a e _b 는 꼭짓점 a 와 b 사이에 모서리가 있는지 여부를 나타냅니다.

연결성은 다음 조건과 같습니다.

• 3 개 미만의 입력이 True이면 출력 False입니다.

• 3 개 이상의 입력이 True이면 True를 출력합니다.

• 정확히 3 개의 입력이 True이고 삼각형 을 형성하면 False를 출력합니다.

• 그렇지 않으면 True를 출력하십시오.

가장 적은 수의 게이트를 사용하는 답이 이깁니다. 타이는
가장 낮은 회로 깊이 (입력에서 출력까지의 가장 긴 경로 길이)에 의해 끊어집니다 .

30 개 낸드

언제 우리가 1을 얻는 지 묻는 대신, 나는 우리가 언제 0을 얻는 지에 대한 질문을했다.

다음은 모서리 수에 따른 분포입니다 (파스칼 삼각형의 6 행).

Edges     0  1  2  3  4  5  6
Frequency 1  6 15 20 15  6  1 (total 64)
Output    0  0  0  *  1  1  1
* = 0 if triangle (4 possibilities) 1 if claw (4 possibilities) 
1 if two opposite edges and one other (12 possibilities)

이런 식으로 질문을하면 다음과 같은 다이어그램과 표현을 얻습니다.

 ___D___
|\     /|
| E   F |
|  \ /  |
A   X   C
|  / \  |
| /   \ |
|/__B__\|

(A|C|D|B)&(A|D|E)&(D|B|E|F)&(C|B|E)&(A|C|E|F)&(D|F|C)&(A|F|B) 

출력은 기본적으로 1로 가정하지만 다음 조건 중 하나에서 0으로 변경됩니다.

1. 인접한 3 개의 모서리에 대해 0 (테스트 3 입력)

2 개의 서로 다른 쌍의 모서리에 대해 0 (테스트 4 입력)

위의 용어는 다음과 같이 그룹화 할 수있는 방식으로 이미 주문되었습니다. (실수로,이 버전의 표현식은 AFB 정점에 대해 회전 대칭입니다.)

((A|D)|((C|B)&E))&((B|E)|((D|F)&C))&((C|F)|((A|E)&D))&(A|F|B)    =6 inverters
   1      1  1       1      1  1       1      1  1      1        =10 (7 OR with both inputs inverted, 3 NAND)
      2                 2                 2               2      =8  (4 OR with one input inverted)
                 2                 2                 2           =6  (3 AND) 
                                                        Total    =30

각각 &또는 의 점수 |는 기호 아래에 있으며 다음과 같이 정당화됩니다.

레벨 0 : 각 입력에 대해 인버터에 투자합니다 : 6 NANDS

레벨 1 : 인버터를 입력 (총 3 개의 NAND)에 배치하여 NAND 게이트에서 OR을 구축 할 수 있지만 이전 단계에서 6 개의 NAND에 이미 투자 한 것처럼 7 개의 NAND 게이트에서 7 개의 OR 게이트를 만들 수 있습니다. 또한 3 개의 AND 게이트가 필요합니다. 이를 위해 NAND를 사용하고 출력을 반전시킵니다. 10 개 낸드

2 단계 : 다시 NAND 게이트에서 4 개의 OR 게이트를 만듭니다. 각각의 경우에 OR 게이트에서 1 개의 입력을 가지므로 반전시켜야합니다. 그러나 다른 입력은 이미 반전되었습니다 (이전 단계의 NAND 중 하나에서 &기호에 해당 하고 마지막 경우에는 인버터에서 왔습니다). 따라서 각 OR 기능에 대해 2 개의 게이트 만 필요합니다. 4 * 2 = 8

레벨 3 : 이제 4 개의 출력을 함께 AND해야합니다. 여기에는 각각 2 개의 NAND로 구성된 3 개의 AND 게이트가 필요합니다. 3 * 2 = 6

총 30 개의 NAND 게이트이며 |레벨이 1 인 분기의 경우 최대 깊이 2 + 2 + 4 = 8NAND 또는 레벨이 1 인 분기의 경우 3 + 1 + 4 = 8NAND입니다 &.

다음 Ruby 스크립트는 위의 표현식이 유효한지 시각적으로 확인합니다.

64.times{|i|
  a=i%2
  b=i/2%2
  c=i/4%2
  d=i/8%2
  e=i/16%2 
  f=i/32%2

puts i, ((a|d)|((c|b)&e))&((b|e)|((d|f)&c))&((c|f)|((a|e)&d))&(a|f|b)

puts " ___#{d}___
|\\     /|
| #{e}   #{f} |
|  \\ /  |
#{a}   X   #{c}
|  / \\  |
| /   \\ |
|/__#{b}__\\|


"
}

19 개 낸드

이것보다 간단한 회로는 없습니다.

그림 아래에 테스트 코드가 있습니다. 그것을 이해하는 것은 어렵습니다. 거기에는 몇 개의 IF 게이트가 있으며, 입력은 일종의 삼각형으로 그룹화되어 있으며, 자유 코너 선은 하나씩 분석을 위해 추가되었지만 간단한 방법은 아닙니다. 누군가가 그것을 이해한다면 감동받을 것입니다.

테스트와 Verilog 코드 :

// 4-vertex Connectedness Tester                                                                  
// Minimal at 19 NANDs                                                                            
//                                                                                                
// By Kim Øyhus 2018 (c) into (CC BY-SA 3.0)                                                      
// This work is licensed under the Creative Commons Attribution 3.0                               
// Unported License. To view a copy of this license, visit                                        
// https://creativecommons.org/licenses/by-sa/3.0/                                                
//                                                                                                
// This is my entry to win this Programming Puzzle & Code Golf                                    
// at Stack Exchange:                                                                             
// /codegolf/69912/build-a-4-vertex-connectedness-tester-using-nand-gates/                                                                                      
//                                                                                                
// I am sure there are no simpler solutions to this problem.                                      
// It has a logical depth of 11, which is deeper than                                             
// circuits using a few more NANDs.                                                               

module counting6 ( in_000, in_001, in_002, in_003, in_004, in_005, in_006, out000 );
  input  in_000, in_001, in_002, in_003, in_004, in_005, in_006;
  output out000;
  wire   wir000, wir001, wir002, wir003, wir004, wir005, wir006, wir007, wir008, wir009, wir010, wir011, wir012, wir013, wir014, wir015, wir016, wir017;

  nand gate000 ( wir000, in_000, in_000 );
  nand gate001 ( wir001, in_001, in_003 );
  nand gate002 ( wir002, wir001, wir000 );
  nand gate003 ( wir003, in_002, wir002 );
  nand gate004 ( wir004, wir002, wir002 );
  nand gate005 ( wir005, wir004, in_002 );
  nand gate006 ( wir006, wir005, wir004 );
  nand gate007 ( wir007, in_005, wir006 );
  nand gate008 ( wir008, in_003, wir006 );    
  nand gate009 ( wir009, in_004, wir003 );
  nand gate010 ( wir010, wir003, wir009 );
  nand gate011 ( wir011, wir009, wir000 );
  nand gate012 ( wir012, wir011, in_001 );
  nand gate013 ( wir013, wir008, wir012 );
  nand gate014 ( wir014, wir013, in_005 );
  nand gate015 ( wir015, wir006, wir013 );
  nand gate016 ( wir016, wir015, wir007 );
  nand gate017 ( wir017, wir016, wir010 );
  nand gate018 ( out000, wir014, wir017 );
endmodule


module connecting6_test;
   reg [5:0] X;
   wire a;

  counting6 U1 (
  .in_000 (X[0]),
  .in_001 (X[1]),
  .in_002 (X[2]),
  .in_003 (X[3]),
  .in_004 (X[4]),
  .in_005 (X[5]),
  .in_006 (X[6]),
  .out000 (a )
  );

  initial begin
    X = 0;
  end

  always
    #10  X = X+1;

 initial  begin
    $display("\t\t     \t_");
    $display("\t\ttime,\t \\db/_,\tconnected");
    $monitor("%d,\t%b,\t%d",$time, X, a );
  end

  initial
   #630  $finish;

endmodule

// iverilog -o hello hello.v                                                                      
// vvp hello                                                                                      

김 오후 스

매스 매 티카, 17 개 게이트

우리는 단순히 모든 규칙을 열거하고 부울 함수를 구성하며 NAND형식을 최소화합니다 .

#->If[Total@#<3||
       MemberQ[{{1,1,1,0,0,0},{1,0,0,1,1,0},{0,1,0,1,0,1},{0,0,1,0,1,1}},#]
       ,0,1] /.{1->True,0->False}& /@
     Tuples[{0,1},6];
BooleanMinimize[BooleanFunction[rule], "NAND"]

결과 :

(#1⊼#2⊼#4)⊼(#1⊼#2⊼#5)⊼(#1⊼#2⊼#6)⊼(#1⊼#3⊼#4)⊼ \
(#1⊼#3⊼#5)⊼(#1⊼#3⊼#6)⊼(#1⊼#4⊼#6)⊼(#1⊼#5⊼#6)⊼ \
(#2⊼#3⊼#4)⊼(#2⊼#3⊼#5)⊼(#2⊼#3⊼#6)⊼(#2⊼#4⊼#5)⊼ \
(#2⊼#5⊼#6)⊼(#3⊼#4⊼#5)⊼(#3⊼#4⊼#6)⊼(#4⊼#5⊼#6)&

여기서 #1...#6인수를위한 6 개의 슬롯이 있습니다.

테스트 사례 :

f=%; (* assign the function to symbol f *)

f[True, True, True, True, False, False]
(* True *)

f[True, True, False, True, False, False]
(* True *) (*, three Trues do not form a triangle *)

f[True, True, True, False, False, False]
(* False *) (*, three Trues form a triangle *)

64 개 낸드

6 개의 모서리는 3 쌍의 반대쪽 모서리로 분할 될 수 있습니다. 그래프를 연결하려면 두 개의 반대쪽 가장자리와 세 번째 가장자리 또는 같은 정점에 연결된 세 개의 가장자리가 있어야합니다.

       •
       U

   Z   •   Y  
    V     W 
 •     X     •

반대 쌍은 UX, VY, WZ입니다.

A = U+V   ;3 gates
B = W+X
C = Y+Z

D = UV(B+C)  ;2+2+3=7 gates
E = WX(A+C)
F = YZ(C+A)

Result = D+E+F+UVW+UYZ+XVZ+XWY ; 18 + 16 = 34 gates

일반적인 방식으로 AND 및 OR 게이트를 빌드 할 때 사용 된 총 게이트 수는 3*3+7*3+34= 64입니다.