NAND गेट्स का उपयोग करते हुए 4-वर्टेक्स कनेक्टेडनेस टेस्टर बनाएं


12

एक जुड़ा ग्राफ एक ग्राफ है कि किसी भी दो कोने के बीच एक रास्ता होता है।

चुनौती

एक [2-इनपुट नंद-द्वार] सर्किट का निर्माण करें जो यह निर्धारित करता है कि 4-वर्टेक्स ग्राफ जुड़ा हुआ है या नहीं।
(ए गेट के 2 आदानों कर सकते हैं एक ही इनपुट बिट या अन्य गेट हो।)
आउटपुट यह सच है, तो ग्राफ जुड़ा है, और झूठी अन्यथा।

इनपुट

4 सिरों के साथ एक सरल ग्राफ के छह संभावित किनारों :

[ , , , , , ]

जहां एक का प्रतिनिधित्व करता है वहाँ कोने के बीच बढ़त है कि क्या एक और

संबंध निम्न स्थितियों के बराबर है:

  • यदि 3 से कम इनपुट सत्य हैं तो आउटपुट गलत है।

  • यदि 3 से अधिक इनपुट ट्रू हैं तो आउटपुट ट्रू।

  • यदि वास्तव में 3 इनपुट ट्रू हैं और वे एक त्रिकोण बनाते हैं तो आउटपुट गलत है।

  • अन्यथा, आउटपुट True।

जवाब है कि सबसे कम द्वार का उपयोग करता है जीतता है।
सबसे कम सर्किट गहराई (इनपुट से आउटपुट तक की सबसे लंबी पथ (एस) की लंबाई से संबंध टूट जाएंगे ।


क्या आप इनपुट प्रारूप को आगे निर्दिष्ट कर सकते हैं?
लीजनमोनमाल 978

iej यह सच है या गलत है या नहीं इसके अनुसार वर्टेक्स i से वर्टेक्स j तक कोई बढ़त नहीं है ।

क्या इनपुट के रूप में 0और लिया जा सकता है 1? उत्पादन के बारे में कैसे?
कॉफ़ीचुप

3
@ TheCopyCup यह एक लॉजिक सर्किट डिज़ाइन समस्या है, कोड-गोल्फ नहीं
lirtosiast

@ThomasKwa वूप्स, ध्यान नहीं दिया।
कॉफ़ीचुप

जवाबों:


4

30 नंद

यह पूछने के बजाय कि हम कब 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. तीन आसन्न किनारों के लिए 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 नंद

स्तर 1: हम इनपुट में कुल इन्वर्टर (कुल 3 NANDS) डालकर एक NAND गेट से OR का निर्माण कर सकते हैं लेकिन जैसा कि हमने पहले ही 6 NANDS में निवेश किया था पिछले चरण में हम 7 NAND गेट से 7 या गेट बना सकते हैं। हमें 3 और गेट भी चाहिए। इनके लिए, हम केवल NANDs का उपयोग करेंगे और आउटपुट को उल्टा छोड़ देंगे। 10 NANDS

स्तर 2: फिर से हम नंद द्वार से 4 या द्वार बनाते हैं। प्रत्येक मामले में हमारे पास OR गेट से 1 इनपुट होता है, इसलिए हमें इसका उल्टा करना होगा। लेकिन अन्य इनपुट पहले से ही उलटा है (पिछले चरण में एक नंद से आने वाला है जो &तीन मामलों में एक प्रतीक से मेल खाता है , और पिछले एक पलटनेवाला से) इसलिए हमें प्रत्येक या कार्यक्षमता के लिए केवल 2 द्वार की आवश्यकता है। 4 * 2 = 8

स्तर 3: हमें अब और चार आउटपुट को एक साथ करने की आवश्यकता है। इसके लिए 3 और गेट की आवश्यकता होती है, प्रत्येक को 2 NANDs, 3 * 2 = 6 से बनाया जाता है

यह कुल 30 NAND द्वार है, जिसकी गहराई 1 + 2 + 4 = 8 NANDs है जिसकी शाखाएँ |1 या 3 + 1 + 4 = 8 NANDs हैं जिनकी शाखाएँ &1 स्तर पर हैं।

निम्न रूबी स्क्रिप्ट नेत्रहीन पुष्टि करती है कि उपरोक्त अभिव्यक्ति वैध है।

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 नंद

इससे सरल कोई सर्किट नहीं है।

चित्र के नीचे इसका परीक्षण करने के लिए कोड है। इसे समझने के लिए, यह मुश्किल है। वहाँ IF गेटों के एक जोड़े हैं, और आदानों को एक त्रिकोण में समूहीकृत किया जाता है, जिसमें मुफ्त कोने वाली लाइनें एक-एक करके विश्लेषण के लिए जोड़ी जाती हैं, लेकिन सरल तरीके से नहीं। अगर कोई इसे समझने में कामयाब होता है, तो मैं प्रभावित होऊंगा।

यहाँ छवि विवरण दर्ज करें

परीक्षण के साथ वेरिलोग कोड:

// 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                                                                                      

किम Øसह


क्या आपने इसे न्यूनतम साबित किया, और यदि ऐसा है तो कैसे?
lirtosiast

मैंने प्रमाण प्राप्त करने के लिए सांख्यिकीय परीक्षण का उपयोग किया कि यह न्यूनतम हो। अपेक्षाकृत सरल सर्किटों के लिए, यह एक की तरह, परीक्षण काफी निश्चित हैं।
किमियोहुस

1

गणितज्ञ, १। द्वार

हम बस सभी नियमों की गणना करते हैं, बूलियन फ़ंक्शन का निर्माण करते हैं, और इसे 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 *)

क्या इसका मतलब है not (p&q&r)? आपके परिणाम का अंतिम और मतलब क्या है?

@RickyDemer हां, का p⊼q⊼rअर्थ है (p⊼q)⊼r, जो इसके बराबर है !(p&&q&&r)
njpipeorgan

फाल्स, फाल्स, ट्रू में प्लग करना यह दर्शाता है कि (p⊼q)⊼rयह समकक्ष नहीं है !(p&&q&&r)

@ रिकीडेमर यह एक समस्या है ... मैंने इसे लिया।
njpipeorgan

इसके अलावा, कम से कम बूलियनमिनाइज़ का वुल्फरामाल्पा संस्करण [एक्सप्र, "नंद"] जरूरी नहीं कि नंद की संख्या कम से कम हो। (बूलियनमिनाइज़ करें [(((a NAND b) NAND (c NAND d)) NAND ((e NAND f) नंद (g NAND h)), "NAND"]।) क्या चल रहा है कि Mathematica एक आउटपुट देता है। अधिकतम 7 नंदों के साथ?

1

64 नंद

छह किनारों को विपरीत किनारों के तीन जोड़े में विभाजित किया जा सकता है। एक ग्राफ को जोड़ने के लिए, दो विपरीत किनारों के साथ-साथ एक तीसरे किनारे या एक ही शीर्ष से जुड़े तीन किनारे होने चाहिए।

       •
       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

सामान्य तरीके से बिल्डिंग और OR गेट्स, उपयोग किए जाने वाले गेटों की कुल संख्या 3*3+7*3+34= 64 है।


[सच, सच, गलत, सच्चा, गलत, गलत] बिना किसी विपरीत किनारों के जुड़ा हुआ ग्राफ देता है।

@ रिकीडेमर मुझे लगता है कि अब यह काम करता है ...
lirtosiast
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.