NANDゲートを使用して4頂点の接続性テスターを構築する


12

接続グラフは、任意の2つの頂点間のパスを含むグラフです。

チャレンジ

4頂点グラフが接続されているかどうかを判断する[2入力NANDゲート]回路を構築します。
(ゲートの2つの入力、同じ入力ビットまたは他のゲートにすることできます。)
グラフが接続されている場合はTrue、そうでない場合はFalseを出力します。

入力

4つの頂点を持つ単純なグラフの6つの可能なエッジ:

[ 0、E 10、E 21、E 20 E 31、E 32、E 3 ]

ここで、a e bは、頂点abの間にエッジがあるかどうかを表します

接続性は、次の条件と同等です。

  • 3つ未満の入力がTrueの場合、Falseを出力します。

  • 3つ以上の入力がTrueの場合、Trueを出力します。

  • 正確に3つの入力がTrueで三角形を形成する場合、Falseを出力します。

  • それ以外の場合は、Trueを出力します。

最も少ないゲートを使用する答えが勝ちです。ネクタイは
、最低の回路の深さ(入力から出力までの最長パスの長さ)によって切断さ れます。


入力フォーマットをさらに指定できますか?
LegionMammal978

iejは、頂点 iから頂点 j へのエッジがあるかどうかによってTrueまたはFalse です。

入力は0and として受け取れます1か?出力はどうですか?
TheCoffeeCup

3
@TheCoffeeCupこれは論理回路設計の問題であり、code-golfではありません。
リルトシアスト

@ThomasKwaおっと、気づかなかった。
TheCoffeeCup

回答:


4

30個のNAND

1をいつ取得するのかを尋ねる代わりに、0を取得するのはいつかを質問しました。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.エッジの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

&or のスコア|は、シンボルの下に配置され、次のように正当化されます。

レベル0:入力ごとにインバーターに投資します:6 NAND

レベル1:入力にインバーター(合計3つのNAND)を配置することにより、NANDゲートからORを構築できますが、前のステップで6つのNANDに既に投資したように、7つのNANDゲートから7つのORゲートを作成できます。また、3つのANDゲートが必要です。これらの場合、NANDを使用し、出力を反転したままにします。10個のNAND

レベル2:ここでも、NANDゲートから4つのORゲートを構築します。いずれの場合も、ORゲートからの入力は1つなので、それを反転する必要があります。しかし、もう一方の入力はすでに反転しているため(前のステップで&は3つのケースのシンボルに対応するNANDの1つから、最後のケースではインバーターから)、各OR機能に必要なゲートは2つだけです。4 * 2 = 8

レベル3:4つの出力をANDで結合する必要があります。これには3つのANDゲートが必要で、それぞれが2つのNANDから構築され、3 * 2 = 6

これは合計30のNANDゲートであり|、レベル1のブランチの最大深さは2 + 2 + 4 = 8 NAND 、レベル1のブランチの3 + 1 + 4 = 8 NAND &です。

次の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}__\\|


"
}

7

19個のNAND

これほど簡単な回路はありません。

写真の下にテスト用のコードがあります。それを理解することに関しては、それは難しいです。そこにはいくつかのIFゲートがあり、入力はちょっとした三角形にグループ化されており、簡単な方法ではなく、分析のために自由なコーナーラインが1つずつ追加されています。誰もがそれを理解することができれば、私は感銘を受けます。

ここに画像の説明を入力してください

テスト付きの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                                                                                      

キム・オイフス


これを最小限に抑えましたか?
リトシアスト

統計的テストを使用して、それが最小限であることの証拠を得ました。このような比較的単純な回路の場合、テストはかなり確実です。
-KimOyhus

1

Mathematica、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 *)

p⊼q⊼rはどういう意味not (p&q&r)ですか?あなたの結果の最終とはどういう意味ですか?

@RickyDemerはい、p⊼q⊼rという意味です。(p⊼q)⊼rこれはと同等!(p&&q&&r)です。
njpipeorgan

False、False、Trueをプラグインすると、(p⊼q)⊼rと同等ではないことが示され!(p&&q&&r)ます。

@RickyDemerそれは問題だ...私はそれを当たり前だと思った。
njpipeorgan

また、少なくともBooleanMinimize [expr、 "NAND"]のwolframalphaバージョンは、NAND の数を必ずしも最小化しませ。(BooleanMinimize [(((a NAND b)NAND(c NAND d))NAND((e NAND f)NAND(g NAND h))))、 "NAND"]を試してください。)Mathematicaで実行すると出力が得られます最大7つのNANDを使用しますか?

1

64個のNAND

6つのエッジを3対の反対側のエッジに分割できます。グラフを接続するには、2つの反対側のエッジと3番目のエッジ、または同じ頂点に接続された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+3464です。


[True、True、False、True、False、False]は、反対のエッジのない接続グラフを提供します。

私は@RickyDemer だと思うこれが機能するようになりました...
lirtosiast
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.