สร้างเครื่องทดสอบการเชื่อมต่อ 4 จุดยอดโดยใช้ประตู NAND


12

เชื่อมต่อกราฟเป็นกราฟที่ประกอบด้วยเส้นทางระหว่างสองจุดที่

ท้าทาย

สร้างวงจร [อินพุต NAND-gate] ที่กำหนดว่าจะเชื่อมต่อกราฟ 4 จุดยอดหรือไม่
(อินพุต 2 รายการของเกตสามารถเป็นบิตอินพุตเดียวกันหรือเกตอื่น ๆ )
เอาท์พุทเป็นจริงถ้ากราฟเชื่อมต่ออยู่และเท็จเป็นอย่างอื่น

อินพุต

หกขอบที่เป็นไปได้ของกราฟอย่างง่ายที่มี 4 จุดยอด:

[ 0 e 1 , 0 e 2 , 1 e 2 , 0 e 3 , 1 e 3 , 2 e 3 ]

ที่จหมายถึงว่ามีขอบระหว่างจุดและ

การเชื่อมต่อจะเทียบเท่ากับเงื่อนไขต่อไปนี้:

  • หากอินพุตน้อยกว่า 3 อินพุตเป็น True ให้เอาต์พุตเท็จ

  • หากมีมากกว่า 3 อินพุตเป็น True ให้เอาต์พุตเป็น True

  • หากอินพุต 3 รายการเป็น True จริงและสามเหลี่ยมเหล่านั้นจะแสดงผลลัพธ์เป็น False

  • มิฉะนั้นให้เอาต์พุต True

คำตอบที่ใช้ประตูน้อยที่สุดชนะ ความสัมพันธ์จะถูกทำลายโดย
ความลึกของวงจรต่ำสุด (ความยาวของเส้นทางที่ยาวที่สุดจากอินพุตไปยังเอาต์พุต)


คุณสามารถระบุรูปแบบการป้อนข้อมูลเพิ่มเติมได้หรือไม่
LegionMammal978

iej เป็นจริงหรือเท็จตามว่ามีหรือไม่มีขอบจากจุดยอด i ถึงจุดสุดยอด j

สามารถนำเข้าเป็น0และ1? เอาท์พุทเป็นอย่างไร
TheCoffeeCup

3
@TheCoffeeCup นี้เป็นปัญหาที่การออกแบบวงจรตรรกะไม่รหัสกอล์ฟ
lirtosiast

@ThomasKwa อ๊ะไม่ได้สังเกต
TheCoffeeCup

คำตอบ:


4

30 NANDS

แทนที่จะถามว่าเมื่อไหร่เราจะได้ 1 ฉันถามคำถามเมื่อเราได้ 0 เราควรถามด้วยวิธีนี้เพราะมี 0 น้อยกว่า 1

นี่คือการกระจายตามจำนวนขอบ (แถวที่ 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.A 0 สำหรับสามขอบที่อยู่ติดกัน (ทดสอบ 3 อินพุต)

2.A 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: เราสามารถสร้าง OR จากประตู NAND โดยใส่อินเวอร์เตอร์ที่อินพุต (รวม 3 NANDS) แต่เมื่อเราลงทุน 6 NANDS ในขั้นตอนก่อนหน้าเราสามารถสร้าง 7 หรือประตูจาก 7 ประตู NAND นอกจากนี้เรายังต้องการ 3 และประตู สำหรับสิ่งเหล่านี้เราจะใช้ NAND และปล่อยเอาต์พุตกลับด้าน 10 NANDS

ระดับ 2: เราสร้าง 4 ประตูขึ้นจาก NAND อีกครั้ง ในแต่ละกรณีเรามีอินพุต 1 ตัวจากประตู OR ดังนั้นเราจึงต้องกลับด้านนั้น แต่อินพุทอื่นกลับด้านแล้ว (มาจากหนึ่งใน NANDs ในขั้นตอนก่อนหน้าซึ่งสอดคล้องกับ&สัญลักษณ์ในสามกรณีและจากอินเวอร์เตอร์ในอันสุดท้าย) ดังนั้นเราจึงต้องการเพียง 2 ประตูสำหรับแต่ละฟังก์ชัน 4 * 2 = 8

ระดับ 3: ตอนนี้เราจำเป็นต้องและทั้งสี่ออกพร้อมกัน สิ่งนี้ต้องใช้ 3 ประตูและแต่ละสร้างจาก 2 NANDs, 3 * 2 = 6

นั่นคือประตู NAND ทั้งหมด 30 ประตูโดยมีความลึกสูงสุด 2 + 2 + 4 = 8 NAND สำหรับสาขา|ที่ระดับ 1 หรือ 3 + 1 + 4 = 8 NAND สำหรับสาขา&ที่ระดับ 1

สคริปต์ 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 NANDs

ไม่มีวงจรที่ง่ายกว่านี้

มีรหัสสำหรับทดสอบด้านล่างของภาพ สำหรับการทำความเข้าใจมันเป็นเรื่องยาก มีประตู 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                                                                                      

คิมØyhus


คุณพิสูจน์ได้ว่าน้อยที่สุดนี้และถ้าเป็นเช่นนั้นได้อย่างไร
lirtosiast

ฉันใช้การทดสอบทางสถิติเพื่อรับหลักฐานว่ามีน้อยที่สุด สำหรับวงจรที่ค่อนข้างเรียบง่ายเช่นนี้การทดสอบค่อนข้างแน่นอน
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

เสียบเท็จเท็จปรากฏทรูที่จะแสดงให้เห็นว่าจะไม่เทียบเท่ากับ(p⊼q)⊼r !(p&&q&&r)

@RickyDemer นั่นเป็นปัญหา ... ฉันได้รับสิทธิ์แล้ว
njpipeorgan

นอกจากนี้อย่างน้อยรุ่น Wolframalpha ของ BooleanMinimize [expr, "NAND"] ไม่จำเป็นต้องลดจำนวน NANDS ให้น้อยที่สุด (ลอง BooleanMinimize [(((a NAND b) NAND (c NAND d)) NAND ((E NAND f) NAND (g NAND h))), "NAND"]) การเรียกใช้บน Mathematica ให้เอาต์พุต มีมากที่สุด 7 NANDS

1

64 NAND

หกขอบสามารถแบ่งออกเป็นสามคู่ของขอบตรงกันข้าม สำหรับการเชื่อมต่อกราฟจะต้องมีขอบตรงข้ามสองเส้นรวมถึงขอบที่สามหรือสามขอบที่เชื่อมต่อกับจุดสุดยอดเดียวกัน

       •
       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


[จริง, จริง, เท็จ, จริง, เท็จ, เท็จ] ให้กราฟที่เชื่อมต่อโดยไม่มีขอบตรงข้าม

@RickyDemer ผมคิดว่างานนี้ในขณะนี้ ...
lirtosiast
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.