السكر النحوي، وحساب كل دالة

«[في عام 1951] كان لديّ مُصرِّف (compiler) يعمل، ولم يقترب منه أحد لأنهم، كما قالوا بعناية، لا يمكن للحواسيب سوى أن تقوم بالحساب العددي (arithmetic)؛ إذ لا يمكنها تنفيذ البرامج.»، غريس موراي هوبِر، 1986.

«السكر النحوي يُسبّب سرطان الفاصلة المنقوطة.»، آلان بيرليس، 1982.

النماذج الحوسبية التي نظرناها حتى الآن في أبسط صورة ممكنة لها. على سبيل المثال، لا تمتلك «لغة البرمجة» NAND-CIRC لدينا سوى عملية واحدة وهي foo = NAND(bar,blah). في هذا الفصل سنرى أن هذه النماذج البسيطة هي في الواقع متكافئة مع نماذج أكثر تطوّرًا. الملاحظة المفتاحية هي أننا نستطيع تنفيذ سمات أكثر تعقيدًا باستخدام لبناتنا الأساسية، ثم نستخدم هذه السمات الجديدة بدورها لبناتٍ أكثر تعقيدًا. ويُعرف هذا بـ«السكر النحوي» (syntactic sugar) في مجال تصميم لغات البرمجة، لأننا لا نعدّل نموذج البرمجة الأساسي نفسه، بل نكتفي بتنفيذ سمات جديدة عبر تحويل برنامج يستعمل هذه السمات نحويًا إلى برنامج لا يستعملها.

يوفّر هذا الفصل «عدّة أدوات» (toolkit) يمكن استعمالها لإظهار أن كثيرًا من الدوال يمكن حسابها ببرامج NAND-CIRC، وبالتالي أيضًا بدوائر منطقية. وسنستعمل هذه العدّة أيضًا لإثبات مبرهنة أساسية: كل دالة متناهية $f:\{0,1\}^n \rightarrow \{0,1\}^m$ يمكن حسابها بدائرة منطقية، انظر مبرهنة — شمولية الدوائر المنطقية أدناه. ولأهمية عدّة السكر النحوي في ذاتها، يمكن أيضًا إثبات مبرهنة — شمولية الدوائر المنطقية مباشرة دون استعمال هذه العدّة. ونعرض هذا البرهان البديل في حساب كل دالة: برهان بديل. انظر الشكل التوضيحي لتجد ملخّص نتائج هذا الفصل.

بعض أمثلة السكر النحوي

نعرض الآن بعض أمثلة تحويلات «السكر النحوي» التي يمكننا استعمالها في بناء برامج مستقيمة أو دوائر. نركّز على رؤية «لغة البرمجة المستقيمة» (straight-line programming language) لنماذجنا الحوسبية، وتحديدًا (من أجل الاتّضاح) على لغة البرمجة NAND-CIRC. وهذا مريح لأن كثيرًا من تحويلات السكر النحوي التي نعرضها يسهل التفكير فيها بوصفها تطبيقات لعمليات «بحث واستبدال» (search and replace) على الشيفرة المصدرية لبرنامج. غير أنه، بموجب مبرهنة — التكافؤ بين نماذج الحوسبة المتناهية، تنطبق كل نتائجنا على الدوائر على قدم المساواة، سواء كانت دوائر تستعمل بوابات NAND أو دوائر منطقية تستعمل العمليات AND وOR وNOT. قد يكون استعراض أمثلة تحويلات السكر النحوي هذه مملًّا بعض الشيء، غير أننا نفعله لسببين:

1. كي نُقنعك بأنه، رغم بساطتها الظاهرة ومحدودياتها، فإن النماذج البسيطة مثل الدوائر المنطقية أو لغة البرمجة NAND-CIRC قوية في الواقع إلى حدٍّ كبير.

2. كي تدرك كم أنت محظوظ لأنك تدرس مساقًا في نظرية الحوسبة (theory of computation) لا مساقًا في مُصرِّفات المترجِمين (compilers)... :)

إجراءات معرَّفة من المستخدم

من أركان أي لغة برمجة تقريبًا القدرة على تعريف إجراءات (procedures) أو دوال فرعية (subroutines) ثم تنفيذها. (وتُسمّى هذه في بعض لغات البرمجة دوال (functions)، لكننا نفضّل اسم إجراءات (procedures) تفاديًا للالتباس مع الدالة التي يحسبها البرنامج.) ليس في لغة البرمجة NAND-CIRC هذه الآلية مُدمجة. غير أننا نستطيع تحقيق الأثر نفسه باستعمال التقنية العريقة «نسخ ولصق» (copy and paste). على وجه التحديد، يمكننا استبدال شيفرة تعرّف إجراءً مثل

def Proc(a,b):
    proc_code
    return c
some_code
f = Proc(d,e)
some_more_code

بالشيفرة التالية التي «نلصق» فيها شيفرة Proc

some_code
proc_code'
some_more_code

وحيث إنّ proc_code' يُنتَج باستبدال كل ورود لـ a بـ d، وb بـ e، وc بـ f. وعندئذٍ سنحتاج إلى التأكّد من أن بقية المتغيّرات الظاهرة في proc_code' لا تتداخل مع متغيّرات أخرى. ويمكننا دائمًا فعل ذلك بإعادة تسمية المتغيّرات إلى أسماء جديدة لم تُستعمل من قبل. ويؤدّي الاستدلال أعلاه إلى برهان المبرهنة التالية:

يمكن إثبات مبرهنة — سكر نحوي لتعريف الإجراءات باستعمال التحويل أعلاه، لكن بما أن البرهان الرسمي طويل ومملّ بعض الشيء، فإننا نُهمله هنا.

def NOT(a):
    return NAND(a,a)
def AND(a,b):
    temp = NAND(a,b)
    return NOT(temp)
def OR(a,b):
    temp1 = NOT(a)
    temp2 = NOT(b)
    return NAND(temp1,temp2)

def MAJ(a,b,c):
    and1 = AND(a,b)
    and2 = AND(a,c)
    and3 = AND(b,c)
    or1 = OR(and1,and2)
    return OR(or1,and3)

print(MAJ(0,1,1))
# 1

البرهان بـ Python (اختياري)

يمكننا كتابة برنامج بلغة Python يُنفّذ برهان مبرهنة — سكر نحوي لتعريف الإجراءات. وهذا برنامج Python يأخذ برنامج NAND-CIRC-PROC من الشكل $P$ الذي يتضمّن تعريفات إجراءات، ويستعمل «بحثًا واستبدالًا» بسيطًا (search and replace) لتحويل $P$ إلى برنامج NAND-CIRC معياري (أي «خالٍ من السكر») $P'$ يحسب الدالة نفسها التي يحسبها $P$ دون استعمال أي إجراء. والفكرة بسيطة: إذا احتوى البرنامج $P$ على تعريف إجراء Proc ذي وسيطين هما x وy، فعند كل ما نرى سطرًا من الشكل foo = Proc(bar,blah) يمكننا استبدال هذا السطر بـ:

1. جسم الإجراء Proc (مع استبدال كل ورود لـ x وy بـ bar وblah على الترتيب).

2. سطر foo = exp، حيث exp هو التعبير الوارد بعد عبارة return في تعريف الإجراء Proc.

ولجعل هذا أمتن، نضيف بادئةً إلى المتغيّرات الداخلية التي يستعملها Proc حتى لا تتنازع مع متغيّرات $P$؛ نبساطةٍ نُهمل هذه المسألة في الشيفرة أدناه مع أنها يمكن إضافتها بسهولة.

وتحقّق شيفرة الدالة desugar في Python أدناه هذا النوع من التحويلات.

def desugar(code, func_name, func_args,func_body):
    """
    Replaces all occurences of 
       foo = func_name(func_args) 
    with
       func_body[x->a,y->b]
       foo = [result returned in func_body]    
    """
    # Uses Python regular expressions to simplify the search and replace,
    # see https://docs.python.org/3/library/re.html and Chapter 9 of the book

    # regular expression for capturing a list of variable names separated by commas
    arglist = ",".join([r"([a-zA-Z0-9\_\[\]]+)" for i in range(len(func_args))])
    # regular expression for capturing a statement of the form
    # "variable = func_name(arguments)"
    regexp = fr'([a-zA-Z0-9\_\[\]]+)\s*=\s*{func_name}\({arglist}\)\s*$'
    while True:
        m = re.search(regexp, code, re.MULTILINE)
        if not m: break
        newcode = func_body 
        # replace function arguments by the variables from the function invocation
        for i in range(len(func_args)): 
            newcode = newcode.replace(func_args[i], m.group(i+2))
        # Splice the new code inside
        newcode = newcode.replace('return', m.group(1) + " = ")
        code = code[:m.start()] + newcode + code[m.end()+1:]
    return code

يبيّن الشكل التوضيحي نتيجة تطبيق desugar على برنامج مثال — حساب دالة الأغلبية انطلاقًا من NAND باستعمال السكر النحوي الذي يستعمل السكر النحوي لحساب دالة الأغلبية. وعلى وجه التحديد، نطبّق desugar أولًا لإزالة استعمال دالة OR، ثم نطبّقه لإزالة استعمال دالة AND، وأخيرًا نطبّقه ثالث مرة لإزالة استعمال دالة NOT.

def parse_func(code):
    """Parse a function definition into name, arguments and body"""
    lines = [l.strip() for l in code.split('\n')]
    regexp = r'def\s+([a-zA-Z\_0-9]+)\(([\sa-zA-Z0-9\_,]+)\)\s*:\s*'
    m = re.match(regexp,lines[0])
    return m.group(1), m.group(2).split(','), '\n'.join(lines[1:])

الجمل الشرطية

من السمات المفقودة بشدّة في NAND-CIRC الجملة الشرطية مثل بُنى if/then الموجودة في كثير من لغات البرمجة. غير أننا نستطيع، باستعمال الإجراءات، الحصول على بديل (ersatz) لبنية if/then. أوّلًا يمكننا حساب الدالة $IF:\{0,1\}^3 \rightarrow \{0,1\}$ بحيث تساوي $IF(a,b,c)$ القيمة $b$ إذا كان $a=1$ والقيمة $c$ إذا كان $a=0$.

يمكن تنفيذ الدالة $IF$ انطلاقًا من NANDs على النحو التالي (انظر تمرين — حساب MUX):

def IF(cond,a,b):
    notcond = NAND(cond,cond)
    temp = NAND(b,notcond)
    temp1 = NAND(a,cond)
    return NAND(temp,temp1)

وتُعرف الدالة $IF$ أيضًا باسم دالة التبادل (multiplexing)، إذ يمكن التفكير في cond بوصفه مفتاحًا يحدّد ما إذا كان الخرج موصولًا بـ $a$ أم بـ $b$. وبعد أن يتوفّر لدينا إجراء لحساب الدالة $IF$، يمكننا تنفيذ الجمل الشرطية في NAND. والفكرة أنك نستبدل شيفرة من الشكل

if (condition):  assign blah to variable foo

بالشيفرة من الشكل

foo   = IF(condition, blah, foo)

وهي شيفرة تُسند إلى foo قيمته القديمة عندما يساوي condition القيمة $0$، وتُسند إلى foo قيمة blah في غير ذلك. والأعمّ من ذلك، يمكننا استبدال شيفرة من الشكل

if (cond):
    a = ...
    b = ...
    c = ...

بالشيفرة من الشكل

temp_a = ...
temp_b = ...
temp_c = ...
a = IF(cond,temp_a,a)
b = IF(cond,temp_b,b)
c = IF(cond,temp_c,c)

وباستعمال تحويلات من هذا النوع، يمكننا إثبات المبرهنة التالية. ونُهمل مرة أخرى البرهان الرسمي الكامل (الذي لا يقدّم فكرة غير بديهية)، لكن انظر البرهان بـ Python (اختياري) لبعض القرائن على كيفية إتمامه.

مثال موسَّع: الجمع والضرب (اختياري)

باستعمال «السكر النحوي» يمكننا كتابة دالة جمع الأعداد الصحيحة على النحو التالي:

# Add two n-bit integers
# Use LSB first notation for simplicity
def ADD(A,B):
    Result = [0]*(n+1)
    Carry  = [0]*(n+1)
    Carry[0] = zero(A[0])
    for i in range(n):
        Result[i] = XOR(Carry[i],XOR(A[i],B[i]))
        Carry[i+1] = MAJ(Carry[i],A[i],B[i])
    Result[n] = Carry[n]
    return Result

ADD([1,1,1,0,0],[1,0,0,0,0]);;
# [0, 0, 0, 1, 0, 0]

حيث zero هي دالة الصفر الثابت، وMAJ وXOR تمثّلان على الترتيب دالتي الأغلبية وXOR. ولأغراض الراحة نستعمل صياغة Python، لكنّ $n$ في هذا المثال عددٌ صحيح ثابت، ومن ثمّ فلكل قيمة من هذه القيم يكون ADD دالةً متناهية تأخذ $2n$ بتًّا مُدخلًا وتُخرج $n+1$ بتًّا. وبالذات، لكل $n$ يمكننا إزالة بِنية الحلقة for i in range(n) ببساطة بتكرار الشيفرة $n$ مرة، مع استبدال قيمة i بـ $0,1,2,\ldots,n-1$. وبفكّ كل السمات، لكل قيمة من $n$ يمكننا ترجمة البرنامج أعلاه إلى برنامج NAND-CIRC معياري («خالٍ من السكر»). ويصوّر الشكل التوضيحي ما نحصل عليه عند $n=2$.

وبمراجعة البرنامج أعلاه بعناية وحساب عدد البوابات، نرى أنّه يؤدّي إلى برهان المبرهنة التالية (انظر أيضًا الشكل التوضيحي):

وبعد أن يتوفّر لدينا الجمع، يمكننا استعمال خوارزمية المدرسة الابتدائية للحصول على الضرب أيضًا، وبذلك نحصل على المبرهنة التالية:

ونُهمل البرهان، لكنّنا في تمرين — الضرب نطلب منك تقديم «برهان بنائي» (constructive proof) على صورة برنامج (بلغتك البرمجية المفضّلة) يُدخل إليه عدد $n$ ويُخرج شيفرة برنامج NAND-CIRC من $1000n^2$ سطرًا على الأكثر يحسب دالة $MULT_n$. وفي الواقع، يمكننا استعمال خوارزمية كارا تسوبا (Karatsuba) لإظهار أنّ هناك برنامج NAND-CIRC من $O(n^{\log_2 3})$ سطرًا لحساب $MULT_n$ (ويمكننا أيضًا الحصول على تحسينات أُسّية (asymptotic) أبعد باستخدام خوارزميات أفضل).

دالة $LOOKUP$

ستلعب دالة $LOOKUP$ دورًا مهمًا في هذا الفصل وفيما بعده. وهي معرَّفة على النحو التالي:

انظر الشكل التوضيحي لتجد تصويرًا توضيحيًا لدالة LOOKUP. ويبيّن الأمر أنّ لكل $k$ يمكننا حساب $LOOKUP_k$ باستعمال برنامج NAND-CIRC:

ومن النتائج الفورية لـ مبرهنة — دالة البحث أنّ لكل $k>0$ يمكن حساب $LOOKUP_k$ بدائرة منطقية (ذات بوابات AND وOR وNOT) من $8 \cdot 2^k$ بوابة على الأكثر.

بناء برنامج NAND-CIRC لدالة $LOOKUP$

نُثبت مبرهنة — دالة البحث بالاستدلال (induction). في الحالة $k=1$، تُسقط $LOOKUP_1$ العنصر $(x_0,x_1,i) \in \{0,1\}^3$ على $x_i$. بعبارة أخرى، إذا كان $i=0$ فإنها تُخرج $x_0$، وإلّا فإنها تُخرج $x_1$، وهذا (حتى إعادة ترتيب المتغيّرات) هو نفسه الدالة $IF$ المعروضة في الجمل الشرطية، والتي يمكن حسابها ببرنامج NAND-CIRC من أربعة أسطر.

وتمرينًا تمهيديًا على الحالة العامة $k$، لننظر في الحالة $k=2$. إذا أُعطينا مُدخلًا $x=(x_0,x_1,x_2,x_3)$ لدالة $LOOKUP_2$ وفهرسًا $i=(i_0,i_1)$، وكان البتّ الأعلى قيمةً $i_0$ من الفهرس يساوي $0$، فإن $LOOKUP_2(x,i)$ تساوي $x_0$ إذا كان $i_1=0$ وتساوي $x_1$ إذا كان $i_1=1$. وبالمثل، إذا كان البتّ الأعلى قيمةً $i_0$ يساوي $1$، فإن $LOOKUP_2(x,i)$ تساوي $x_2$ إذا كان $i_1=0$ وتساوي $x_3$ إذا كان $i_1=1$. وتُقال هذه بطريقة أخرى، إنّنا نستطيع كتابة $LOOKUP_2$ على النحو التالي:

def LOOKUP2(X[0],X[1],X[2],X[3],i[0],i[1]):
    if i[0]==1:
        return LOOKUP1(X[2],X[3],i[1])
    else:
        return LOOKUP1(X[0],X[1],i[1])

أو بعبارة أخرى،

def LOOKUP2(X[0],X[1],X[2],X[3],i[0],i[1]):
    a = LOOKUP1(X[2],X[3],i[1])
    b = LOOKUP1(X[0],X[1],i[1])
    return IF( i[0],a,b)

والأعمّ من ذلك، كما تبيّن الملاحظة التالية، يمكننا حساب $LOOKUP_k$ باستعمال استدعاءين لـ $LOOKUP_{k-1}$ واستدعاء واحد لـ $IF$:

برهان مبرهنة — دالة البحث انطلاقًا من لمّة — تكرار دالة البحث. وبعد أن صار لدينا لمّة — تكرار دالة البحث، يمكننا إتمام برهان مبرهنة — دالة البحث. سنُثبت بالاستدلال على $k$ أنّ هناك برنامج NAND-CIRC من $4\cdot (2^k-1)$ سطرًا على الأكثر لـ $LOOKUP_k$. وبالنسبة إلى $k=1$، فإن ذلك يتّضح من برنامج $IF$ ذي الأربعة أسطر الذي رأيناه من قبل. وبالنسبة إلى $k>1$، نستعمل الشيفرة شبه البرمجية (pseudocode) التالية:

a = LOOKUP_(k-1)(X[0],...,X[2^(k-1)-1],i[1],...,i[k-1])
b = LOOKUP_(k-1)(X[2^(k-1)],...,X[2^(k-1)],i[1],...,i[k-1])
return IF(i[0],b,a)

إذا تركنا $L(k)$ تدلّ على عدد الأسطر المطلوبة لـ $LOOKUP_k$، فإن الشيفرة شبه البرمجية أعلاه تُظهر أنّ $$L(k) \leq 2L(k-1)+4 \;.$$ وبموجب فرضية الاستدلال لدينا $L(k-1) \leq 4(2^{k-1}-1)$، نحصل على أنّ $L(k) \leq 2\cdot 4 (2^{k-1}-1) + 4 = 4(2^k - 1)$ وهو ما كنا نريد إثباته. انظر الشكل التوضيحي لتجد رسمًا بيانيًا لعدد الأسطر الفعلي في تنقيذنا لدالة $LOOKUP_k$.

حساب كل دالة

حتى هذه اللحظة نعرف الحقائق التالية عن برامج NAND-CIRC (وعن الدوائر المنطقية، وبالتالي، وعن نماذجنا الأخرى المتكافئة معها):

1. إنّها تحسب على الأقل بعض الدوال غير البديهية.

2. إنّ ابتكار برامج NAND-CIRC لدوال مختلفة مهمّة بالغة.

لذلك لا ألوم القارئ إن لم يكن متلهّفًا على نحو خاص لمطَوّلة من الأمثلة للدوال التي يمكن حسابها ببرامج NAND-CIRC. غير أنّه تبيّن أنّنا لن نحتاج إلى هذا، إذ يمكننا في ضربة واحدة أن نبيّن أنّ برامج NAND-CIRC تستطيع حساب كل دالة متناهية:

وبموجب مبرهنة — التكافؤ بين نماذج الحوسبة المتناهية، فإن نماذج دوائر NAND وبرامج NAND-CIRC وبرامج AON-CIRC والدوائر المنطقية متكافئة فيما بينها جميعًا، ومن ثمّ فإن مبرهنة — شمولية NAND تنطبق على كل هذه النماذج. وبالذات، المبرهنة التالية تكافئ مبرهنة — شمولية NAND:

حدود محسّنة. وإن كانت أهميتها ليست بالغة بالنسبة لنا، فمن الممكن تحسين برهان مبرهنة — شمولية NAND وتشذيب عامل إضافي من $n$، فضلًا عن تحسين الثابت $c$، وبذلك نُثبت أنّ لكل $\epsilon>0$ و$m\in \N$ و$n$ كبير بما يكفي، إذا كانت $f:\{0,1\}^n \rightarrow \{0,1\}^m$ فإن $f$ يمكن حسابها بدائرة NAND من $(1+\epsilon)\tfrac{m\cdot 2^n}{n}$ بوابة على الأكثر. برهان هذه النتيجة خارج نطاق هذا الكتاب، لكنّنا نناقش في تحسين بمعامل n (اختياري) كيفية الحصول على حدٍّ من الشكل $O(\tfrac{m \cdot 2^n}{n})$؛ وانظر أيضًا الملاحظات الببليوغرافية.

برهان شمولية NAND

لإثبات مبرهنة — شمولية NAND، نحتاج إلى إعطاء دائرة NAND، أو بما يكافئها برنامج NAND-CIRC، لكل دالة ممكنة. سنقصر اهتمامنا على حالة الدوال المنطقية (أي $m=1$). يطلب منك تمرين — دوال متعدّدة البتات توسيع البرهان على جميع قيم $m$. يمكن تحديد دالة $F: \{0,1\}^n\rightarrow \{0,1\}$ بجدول من قيمها لكل واحد من الـ $2^n$ مُدخلًا. على سبيل المثال، يصف الجدول أدناه دالة بعينها $G: \{0,1\}^4 \rightarrow \{0,1\}$:^[2]

جدول: مثال على دالة $G:\{0,1\}^4 \rightarrow \{0,1\}$.

لكل $x\in \{0,1\}^4$، لدينا $G(x)=LOOKUP_4(1100100100001111,x)$، ومن ثمّ فالشيفرة التالية هي «شيفرة شبه برمجية» (pseudocode) بلغة NAND-CIRC لحساب $G$ باستعمال السكر النحوي للإجراء LOOKUP_4.

G0000 = 1
G1000 = 1
G0100 = 0
...
G0111 = 1
G1111 = 1
Y[0] = LOOKUP_4(G0000,G1000,...,G1111,
                X[0],X[1],X[2],X[3])

يمكننا ترجمة هذه الشيفرة شبه البرمجية إلى برنامج NAND-CIRC حقيقي بإضافة ثلاثة أسطر لتعريف المتغيّرين zero وone اللذين يُهيَّآن على $0$ و$1$ على الترتيب، ثم باستبدال عبارة مثل Gxxx = 0 بـ Gxxx = NAND(one,one)، وعبارة مثل Gxxx = 1 بـ Gxxx = NAND(zero,zero). وسيُستبدَل الاستدعاء إلى LOOKUP_4 ببرنامج NAND-CIRC الذي يحسب $LOOKUP_4$، مع تلقيم المُداخل المناسبة.

لم يكن في الاستدلال أعلاه شيء يخصّ الدالة $G$ بعينها. ولكل دالة $F: \{0,1\}^n \rightarrow \{0,1\}$، يمكننا كتابة برنامج NAND-CIRC يفعل ما يلي:

1. تهيئة $2^n$ متغيّرًا من الشكل F00...0 إلى F11...1 بحيث لكل $z\in\{0,1\}^n$ يُسنَد إلى المتغيّر المقابل لـ $z$ القيمة $F(z)$.

2. حساب $LOOKUP_n$ على الـ $2^n$ متغيّرًا المهيّأة في الخطوة السابقة، مع كون متغيّر الفهرس هو متغيّرات المُدخل X[$0$ ],...,X[$n-1$ ]. أي أنّنا، تمامًا كما في الشيفرة شبه البرمجية للدالة G أعلاه، نستعمل Y[0] = LOOKUP(F00..00,...,F11..1,X[0],..,X[$n-1$])

مجموع عدد الأسطر في البرنامج الناتج هو $3+2^n$ سطرًا لتهيئة المتغيّرات، إضافةً إلى $4\cdot 2^n$ سطرًا ندفع ثمنها مقابل حساب $LOOKUP_n$. وهذا يُتمّ برهان مبرهنة — شمولية NAND.

تحسين بمعامل $n$ (اختياري)

بمزيد من العناية قليلًا، يمكننا تحسين حدّ مبرهنة — شمولية NAND وإظهار أنّ كل دالة $F:\{0,1\}^n \rightarrow \{0,1\}^m$ يمكن حسابها ببرنامج NAND-CIRC من $O(m 2^n/n)$ سطرًا على الأكثر. بعبارة أخرى، يمكننا إثبات الصيغة المحسّنة التالية:

وباستعمال الصلة بين برامج NAND-CIRC والدوائر المنطقية، فإنّ النتيجة الفورية لـ مبرهنة — شمولية دوائر NAND، بحدّ محسّن هي التحسين التالي لـ مبرهنة — شمولية الدوائر المنطقية:

حساب كل دالة: برهان بديل

مبرهنة — شمولية الدوائر المنطقية نتيجة أساسية في نظرية الحوسبة (وفي ممارستها أيضًا!). في هذا القسم نعرض برهانًا بديلًا لهذه الحقيقة الأساسية القائلة إنّ الدوائر المنطقية تستطيع حساب كل دالة متناهية. ويعطي هذا البرهان البديل حدًّا كمّيًا أضعف قليلًا لعدد البوابات، لكنّ له ميزة أنّه أبسط، إذ يعمل مباشرةً مع الدوائر ويتفادى استعمال آليات السكر النحوي بأسرها. (غير أنّ تلك الآليات مفيدة في ذاتها، وستجد لها تطبيقات أخرى لاحقًا.)

الصنف $SIZE_{n,m}(s)$

لقد رأينا أنّ كل دالة $f:\{0,1\}^n \rightarrow \{0,1\}^m$ يمكن حسابها بدائرة بحجم $O(m\cdot 2^n)$، وأنّ بعض الدوال (مثل الجمع والضرب) يمكن حسابها بدوائر أصغر بكثير. نُعرِّف $SIZE_{n,m}(s)$ لتكون مجموعة الدوال التي تُسقط $n$ بتًّا على $m$ بتًّا والتي يمكن حسابها بدوائر NAND من $s$ بوابة على الأكثر (أو بما يكافئها، ببرامج NAND-CIRC من $s$ سطرًا على الأكثر). والتعريف الرسمي هو كما يلي:

يصوّر الشكل التوضيحي المجموعة $SIZE_{n,1}(s)$. لاحظ أنّ $SIZE_{n,m}(s)$ مجموعة دوال لا مجموعة برامج! فالسؤال عمّا إذا كان برنامج أو دائرة عضوًا في $SIZE_{n,m}(s)$ هو خطأ في التصنيف (category error) بالمعنى المذكور في الشكل التوضيحي. وكما ناقشنا في المواصفة مقابل التنفيذ (مرة أخرى) (وميّزوا الدوال عن البرامج!)، فإنّ التمييز بين البرامج و_الدوال_ بالغ الأهمية. وينبغي أن تتذكّر دائمًا أنّ البرنامج يحسب الدالة، لكنه ليس مساويًا لها. وبالذات، كما رأينا، قد يوجد أكثر من برنامج واحد يحسب الدالة نفسها.

ولأَنّنا عرّفنا $SIZE_n(s)$ بالنسبة إلى بوابات NAND، فسنحصل على الصنف نفسه جوهريًا لو عرّفناه بالنسبة إلى بوابات AND/OR/NOT:

يمكن صياغة النتائج التي رأيناها في هذا الفصل على صورة أنّ $ADD_n \in SIZE_{2n,n+1}(100 n)$ و$MULT_n \in SIZE_{2n,2n}(10000 n^{\log_2 3})$. وتُظهر مبرهنة — شمولية NAND أنّه لبعض الثابت $c$، تكون $SIZE_{n,m}(c m 2^n)$ مساوية لمجموعة كل الدوال من $\{0,1\}^n$ إلى $\{0,1\}^m$.

Y[0] = NAND(temp,temp)

t = NAND(X[2],X[2])
u = NAND(X[0],t)
v = NAND(X[1],X[2])
Y[0] = NAND(u,v)