Побудуйте тестер для підключення до 4 вершин за допомогою воріт NAND


12

Підключений граф являє собою графік , який містить шлях між будь-якими двома вершинами.

Виклик

Побудуйте ланцюг [2-вхідний NAND-шлюз], який визначає, чи підключено 4-вершинний графік.
(2 входи в ворота можуть бути тим самим вхідним бітом або іншим шлюзом.)
Вихід True, якщо графік підключений, і False в іншому випадку.

Вхідні дані

Шість можливих країв простого графіка з 4 вершинами:

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

де a e b позначає, чи є край між вершинами a і b

Зв'язок еквівалентний наступним умовам:

  • Якщо правда менше 3-х входів, тоді виводиться помилково.

  • Якщо більше 3-х входів вірно, то виведіть True.

  • Якщо вірно 3 входи істинні, і вони утворюють трикутник, то виводиться помилково.

  • В іншому випадку виведіть True.

Відповідь, яка використовує найменші ворота, виграє. Зв'язки будуть розбиті
на найменшу глибину ланцюга (довжина найдовшого шляху від входу до виходу).


Чи можете ви далі вказати формат введення?
LegionMammal978

iej - Істинно чи Невірно, залежно від того, існує чи немає ребра від вершини i до вершини j.

Чи можна ввести дані як 0і 1? Як щодо виходу?
TheCoffeeCup

3
@TheCoffeeCup Це проблема дизайну логічної схеми, а не код-гольф .
lirtosiast

@ThomasKwa Уотс, не помітив.
TheCoffeeCup

Відповіді:


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.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 НАНД

Рівень 1: Ми можемо створити АБО з воріт NAND, поставивши на вхід інвертор (всього 3 NANDS), але, як ми вже інвестували в 6 NANDS на попередньому кроці, ми можемо зробити 7 АБО воріт із 7 NAND воріт. Нам також потрібні 3 І ворота. Для цього ми просто використовуватимемо NAND і залишимо висновок перевернутим. 10 NANDS

Рівень 2: Знову ми будуємо 4 або АБО ворота з воріт NAND. У кожному випадку ми маємо 1 вхід із АБО, тож ми маємо це перевернути. Але інший вхід вже інвертований (надходить від одного з NAND на попередньому кроці, який відповідає &символу в трьох випадках, і від інвертора в останньому), тому нам потрібні лише 2 ворота для кожного функцій АБО. 4 * 2 = 8

Рівень 3: Тепер нам потрібно І чотири виходи разом. Для цього потрібні 3 ворота AND, кожна побудована з 2 NAND, 3 * 2 = 6

Це в цілому 30 воріт NAND з максимальною глибиною 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 НАНД

Немає простішої схеми, ніж ця.

Код для тестування його є нижче зображення. Щодо розуміння цього, то це важко. Там є декілька воріт 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

Математика, 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

Крім того, принаймні версія wolframalpha BooleanMinimize [expr, "NAND"] не обов'язково мінімізує кількість NANDS. (Спробуйте BooleanMinimize [(((NAND b) NAND (c NAND d)) NAND ((e NAND f) NAND (g NAND h))), "NAND"].) Чи виконує функція Mathematica результат максимум 7 NANDS?

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

Будуючи ворота AND і АБО звичайним способом, загальна кількість використаних воріт 3*3+7*3+34= 64.


[True, True, False, True, False, False] дає з'єднаний графік без протилежних ребер.

@RickyDemer Я думаю, що це працює зараз ...
lirtosiast
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.