scheme - यिन-यांग पहेली कैसे काम करती है?




callcc (4)

मैं योजना में कॉल / सीसी के शब्दार्थ को समझने की कोशिश कर रहा हूं, और निरंतरता पर विकिपीडिया पृष्ठ उदाहरण के रूप में यिन-यांग पहेली को दर्शाता है:

(let* ((yin
         ((lambda (cc) (display #\@) cc) (call-with-current-continuation (lambda (c) c))))
       (yang
         ((lambda (cc) (display #\*) cc) (call-with-current-continuation (lambda (c) c)))) )
    (yin yang))

यह @*@**@***@****@... उत्पादन करना चाहिए, लेकिन मुझे समझ नहीं आता कि क्यों; मुझे उम्मीद है कि यह आउटपुट @*@********* ...

क्या कोई इस बारे में विस्तार से बता सकता है कि यिन-यांग पहेली जिस तरह से काम करती है वह क्यों काम करती है?


समझ योजना

मुझे लगता है कि इस पहेली को समझने में कम से कम आधी समस्या स्कीम सिंटैक्स की है, जो कि ज्यादातर परिचित नहीं हैं।

सबसे पहले, मैं व्यक्तिगत रूप से call/cc x को समकक्ष विकल्प की तुलना में कठिन समझने के लिए पाता हूं, x get/cc । यह अभी भी x को कॉल करता है, इसे वर्तमान निरंतरता से गुजर रहा है , लेकिन किसी तरह मेरे मस्तिष्क सर्किटरी में प्रतिनिधित्व करने के लिए अधिक उत्तरदायी है।

उस के साथ, निर्माण (call-with-current-continuation (lambda (c) c)) बस get-cc हो जाता है। अब हम इसके लिए नीचे हैं:

(let* ((yin
         ((lambda (cc) (display #\@) cc) get-cc))
       (yang
         ((lambda (cc) (display #\*) cc) get-cc)) )
    (yin yang))

अगला चरण आंतरिक लंबो का शरीर है। (display #\@) cc , अधिक परिचित वाक्यविन्यास में (मेरे लिए, वैसे भी) का अर्थ है print @; return cc; print @; return cc; । जब हम इस पर होते हैं, तो चलिए lambda (cc) body को function (arg) { body } रूप में फिर से लिखते हैं, कोष्ठक के एक समूह को हटाते हैं, और इसे प्राप्त करने के लिए फ़ंक्शन कॉल को C- जैसे सिंटैक्स में बदलते हैं:

(let*  yin =
         (function(arg) { print @; return arg; })(get-cc)
       yang =
         (function(arg) { print *; return arg; })(get-cc)
    yin(yang))

यह अब अधिक समझ में आने लगा है। इसे प्राप्त करने के लिए अब यह पूरी तरह से सी-सी सिंटैक्स (या जावास्क्रिप्ट-जैसे, यदि आप चाहें) में फिर से लिखने के लिए एक छोटा कदम है:

var yin, yang;
yin = (function(arg) { print @; return arg; })(get-cc);
yang = (function(arg) { print *; return arg; })(get-cc);
yin(yang);

सबसे कठिन हिस्सा अब खत्म हो गया है, हमने स्कीम से इसे डिकोड कर लिया है! मजाक कर रहा हूं; यह केवल कठिन था क्योंकि मेरे पास स्कीम का कोई पिछला अनुभव नहीं था। तो, चलो यह पता लगाने के लिए कि यह वास्तव में कैसे काम करता है।

निरंतरता पर एक प्राइमर

यिन और यांग के अजीब रूप से तैयार किए गए कोर का निरीक्षण करें: यह एक फ़ंक्शन को परिभाषित करता है और फिर तुरंत इसे कॉल करता है । यह सिर्फ (function(a,b) { return a+b; })(2, 3) तरह दिखता है, जिसे 5 सरलीकृत किया जा सकता है। लेकिन यिन / यांग के अंदर कॉल को सरल बनाना एक गलती होगी, क्योंकि हम इसे एक साधारण मूल्य नहीं दे रहे हैं। हम फ़ंक्शन को एक निरंतरता दे रहे हैं

एक निरंतरता पहली नजर में एक अजीब जानवर है। बहुत सरल कार्यक्रम पर विचार करें:

var x = get-cc;
print x;
x(5);

प्रारंभ में x वर्तमान निरंतरता ऑब्जेक्ट (मेरे साथ सहन) पर सेट होता है, और print x निष्पादित हो जाता है, कुछ प्रिंट करता है जैसे <ContinuationObject> । अब तक सब ठीक है।

लेकिन एक निरंतरता एक समारोह की तरह है; इसे एक तर्क के साथ कहा जा सकता है। यह क्या करता है: तर्क ले लो, और फिर उस जगह पर कूदो जहां भी निरंतरता बनाई गई थी, सभी संदर्भों को बहाल करते हुए, और इसे बनाते हुए ताकि get-cc इस तर्क को वापस कर दे।

हमारे उदाहरण में, तर्क 5 , इसलिए हम अनिवार्य रूप से उस var x = get-cc स्टेटमेंट के मध्य में वापस कूदते हैं, केवल इस बार get-cc रिटर्न 5 । तो x 5 हो जाता है, और अगला कथन प्रिंट 5 पर जाता है। उसके बाद हम 5(5) को कॉल करने का प्रयास करते हैं, जो एक प्रकार की त्रुटि है, और प्रोग्राम क्रैश हो जाता है।

निरीक्षण करें कि कॉल को जारी रखना एक छलांग है , कॉल नहीं। यह कभी नहीं लौटता जहां निरंतरता को बुलाया गया था। वह महत्वपूर्ण है।

कार्यक्रम कैसे काम करता है

यदि आपने उसका अनुसरण किया है, तो अपनी उम्मीदों पर खरा न उतरें: यह हिस्सा वास्तव में सबसे कठिन है। यहाँ हमारा कार्यक्रम फिर से है, चर घोषणाओं को छोड़ देना क्योंकि यह वैसे भी छद्म कोड है:

yin = (function(arg) { print @; return arg; })(get-cc);
yang = (function(arg) { print *; return arg; })(get-cc);
yin(yang);

पहली बार पंक्ति 1 और 2 हिट होती हैं, वे अब सरल हैं: निरंतरता प्राप्त करें, फ़ंक्शन को कॉल करें (arg), प्रिंट @ , वापसी, yin में उस निरंतरता को संग्रहीत करें। yang साथ भी। हमने अब @* छाप दिया है।

अगला, हम yin में निरंतरता कहते हैं, इसे yang पास करते हुए। यह हमें उस गेट-सी सी के अंदर, लाइन 1 पर जाने के लिए कूदता है, और इसकी बजाय वापसी yang बनाता है। yang मूल्य को अब फंक्शन में पास किया जाता है, जो @ प्रिंट करता है, और फिर yang के मूल्य को वापस करता है। अब yin को वह निरंतरता दी गई है जो yang पास है। अगला हम सिर्फ 2 पंक्ति में आगे बढ़ते हैं: c / c प्राप्त करें, प्रिंट करें * , yang में c / c स्टोर करें। अब हमारे पास @*@* । और अंत में, हम पंक्ति 3 पर जाते हैं।

याद रखें कि yin अब से निरंतरता है जब लाइन 2 को पहले निष्पादित किया गया था। तो हम लाइन 2 पर कूदते हैं, एक दूसरा प्रिंट करते हैं और yang अपडेट करते हैं। अब हमारे पास @*@** । अंत में, yin निरंतरता को फिर से कॉल करें, जो एक @ प्रिंट करते हुए, लाइन 1 पर कूद जाएगा। और इसी तरह। सच कहूं तो, इस समय मेरा दिमाग एक आउटऑफमेरी अपवाद को फेंकता है और मैं सब कुछ खो देता हूं। लेकिन कम से कम हमें @*@** मिल गया!

यह पालन करना कठिन है और समझाने में कठिन भी है। ऐसा करने का सही तरीका एक डिबगर में इसके माध्यम से कदम रखना होगा जो निरंतरता का प्रतिनिधित्व कर सकता है, लेकिन अफसोस, मुझे किसी का भी पता नहीं है। मुझे आशा है कि आपको यह पसंद आया होगा; मेरे पास निश्चित रूप से है।


जैसा कि एक अन्य उत्तर में कहा गया है, हम पहले गेट get-cc (call-with-current-continuation (lambda (c) c)) को सरल करते get-cc

(let* ((yin
         ((lambda (cc) (display #\@) cc) get-cc))
       (yang
         ((lambda (cc) (display #\*) cc) get-cc)) )
    (yin yang))

अब, दो लैम्ब्डा साइड-इफेक्ट्स से जुड़े एक समान कार्य हैं। आइए उन फ़ंक्शंस को कॉल करें f ( display #\@ ) और g ( display #\* )।

(let* ((yin (f get-cc))
       (yang (g get-cc)))
    (yin yang))

आगे हमें मूल्यांकन क्रम पर काम करने की जरूरत है। स्पष्ट होने के लिए, मैं एक "स्टेप एक्सप्रेशन" पेश करूंगा जो हर मूल्यांकन चरण को स्पष्ट करता है। पहले पूछते हैं: उपरोक्त फ़ंक्शन की आवश्यकता क्या है?

इसके लिए f और g की परिभाषाएं चाहिए। स्टेप एक्सप्रेशन में, हम लिखते हैं

s0 f g =>

पहला कदम yin गणना करना है, लेकिन इसके लिए मूल्यांकन की आवश्यकता होती है (f get-cc) , और बाद में get-cc आवश्यकता होती है।

मोटे तौर पर, गेट get-cc आपको एक ऐसा मूल्य देता है जो "वर्तमान निरंतरता" का प्रतिनिधित्व करता है। मान लीजिए कि यह s1 क्योंकि यह अगला चरण है। इसलिए हम लिखते हैं

s0 f g => s1 f g ?
s1 f g cc =>

ध्यान दें कि पैरामीटर स्कोपलेस हैं, जिसका अर्थ है कि s0 और s1 में f और g समान नहीं हैं और वे केवल वर्तमान चरण के भीतर ही उपयोग किए जाने वाले हैं। यह संदर्भ जानकारी को स्पष्ट करता है। अब, cc का मान क्या है? चूंकि यह "वर्तमान निरंतरता" है, इसलिए यह समान मूल्य के लिए f और g साथ समान s1 की तरह है।

s0 f g => s1 f g (s1 f g)
s1 f g cc =>

एक बार हमारे पास cc , हम f get-cc मूल्यांकन कर सकते हैं। साथ ही, चूंकि f का उपयोग निम्नलिखित कोड में नहीं किया गया है, इसलिए हमें इस मूल्य पर पास होने की आवश्यकता नहीं है।

s0 f g => s1 f g (s1 f g)
s1 f g cc => s2 g (f cc)
s2 g yin =>

अगला yang लिए समान है। लेकिन अब हमारे पास पास करने के लिए एक और मूल्य है: yin

s0 f g => s1 f g (s1 f g)
s1 f g cc => s2 g (f cc)
s2 g yin => s3 g yin (s3 g yin)
s3 g yin cc => s4 yin (g cc)
s4 yin yang => 

अंत में, yang से yin को लागू करने के लिए अंतिम चरण है।

s0 f g => s1 f g (s1 f g)
s1 f g cc => s2 g (f cc)
s2 g yin => s3 g yin (s3 g yin)
s3 g yin cc => s4 yin (g cc)
s4 yin yang => yin yang

इसने चरण अभिव्यक्ति का निर्माण समाप्त कर दिया। योजना में इसका अनुवाद सरल है:

(let* ([s4 (lambda (yin yang) (yin yang))]
       [s3 (lambda (yin cc) (s4 yin (g cc))]
       [s2 (lambda (yin) (s3 yin ((lambda (cc) (s3 yin cc))))]
       [s1 (lambda (cc) (s2 (f cc)))])
      (s1 s1))

विस्तृत मूल्यांकन आदेश (यहाँ s2 के शरीर के अंदर का लैम्ब्डा केवल आंशिक मूल्यांकन s3 yin बजाय व्यक्त किया गया था (lambda (cc) (s3 yin cc)) ):

(s1 s1)
=> (s2 (f s1))
=> @|(s2 s1)
=> @|(s3 s1 (s3 s1))
=> @|(s4 s1 (g (s3 s1)))
=> @*|(s4 s1 (s3 s1))
=> @*|(s1 (s3 s1))
=> @*|(s2 (f (s3 s1)))
=> @*@|(s2 (s3 s1))
=> @*@|(s2 (s3 s1))
=> @*@|(s3 (s3 s1) (s3 (s3 s1)))
=> @*@|(s4 (s3 s1) (g (s3 (s3 s1))))
=> @*@*|(s4 (s3 s1) (s3 (s3 s1)))
=> @*@*|(s3 s1 (s3 (s3 s1)))
=> @*@*|(s4 s1 (g (s3 (s3 s1))))
=> @*@**|(s4 s1 (s3 (s3 s1)))
=> @*@**|(s1 (s3 (s3 s1)))
=> ...

(याद रखें, s2 या s4 मूल्यांकन करते समय, पैरामीटर का मूल्यांकन पहले किया जाएगा


यह उस्ताद डेविड मैडोर के गुरु की एक पुरानी पहेली है, जिसने अनलैम्ब्डा बनाया। पहेली कई बार comp.lang.scheme पर चर्चा की गई है।

टेलर कैम्पबेल का एक अच्छा समाधान: https://groups.google.com/d/msg/comp.lang.scheme/pUedvrKYY5w/uIjTc_T1LOEJ

डेविड मदोर (1999) की मूल पोस्ट: https://groups.google.com/d/msg/comp.lang.scheme/Fysq_Wplxsw/awxEZ_uxW20J


यिनयांग पहेली स्कीम में लिखा गया है। मुझे लगता है कि आप स्कीम के मूल सिंटैक्स को जानते हैं।

लेकिन मुझे लगता है कि आपको पता नहीं है कि let* या call-with-current-continuation , मैं इन दो खोजशब्दों को समझाऊंगा।

स्पष्ट let*

यदि आप पहले से ही जानते हैं कि, आप Explain call-with-current-continuation टू Explain call-with-current-continuation कंटीन्यू को Explain call-with-current-continuation करना छोड़ सकते हैं

let* , जो कि let की तरह दिखता है, let की तरह कार्य करता है, लेकिन इसके परिभाषित चरों ( (yin ...) और (yang ...) ) का एक-एक करके और उत्सुकता से मूल्यांकन करेगा। इसका मतलब है, यह पहले yin मूल्यांकन करेगा, और yang तुलना में।

आप यहाँ और अधिक पढ़ सकते हैं: Let Let Let in Scheme

call-with-current-continuation व्याख्या call-with-current-continuation

यदि आप पहले से ही जानते हैं कि, आप Yin-Yang puzzle को छोड़ सकते हैं।

call-with-current-continuation को समझाना थोड़ा कठिन है। इसलिए मैं इसे समझाने के लिए एक रूपक का उपयोग करूंगा।

एक जादूगर की छवि जो एक जादू जानता था, जो call-with-current-continuation । एक बार जब वह जादू कर देता, तो वह एक नया ब्रह्मांड बना देता, और उसे अपने पास भेज देता। लेकिन वह नए ब्रह्मांड में कुछ नहीं कर सकता था, लेकिन किसी को उसके नाम का इंतजार था। एक बार कहा जाता है , जादूगर मूल ब्रह्मांड में वापस आ जाएगा, गरीब आदमी - 'किसी' - हाथ में, और अपने जादूगर जीवन पर चलते हैं। यदि नया ब्रह्माण्ड समाप्त नहीं होता है, तो बुलाया नहीं जाता है, विज़ार्ड भी मूल ब्रह्मांड में लौट आया है।

ठीक है, चलो और अधिक तकनीकी हो।

call-with-current-continuation एक फ़ंक्शन है जो किसी फ़ंक्शन को पैरामीटर के रूप में स्वीकार करता है। एक बार जब आप किसी फ़ंक्शन F call-with-current-continuation टू call-with-current-continuation करते हैं, तो यह चालू रनिंग वातावरण को पैक करेगा, जिसे current-continuation कहा जाता है, एक पैरामीटर C , और इसे फ़ंक्शन F भेजें, और F निष्पादित करें। तो पूरा कार्यक्रम (FC) बन जाता है। या अधिक जावास्क्रिप्ट होना: F(C);C एक फंक्शन की तरह काम करता है। यदि C को F में नहीं बुलाया जाता है, तो यह एक सामान्य कार्यक्रम है, जब F रिटर्न, call-with-current-continuation का मूल्य F रिटर्न रिटर्न के रूप में होता है। लेकिन अगर C को एक पैरामीटर V साथ बुलाया जाता है, तो यह पूरे कार्यक्रम को फिर से बदल देगा। जब call-with-current-continuation कहा जाता है, तो प्रोग्राम वापस स्थिति में बदल जाता है। लेकिन अब call-with-current-continuation एक मूल्य देता है, जो कि V । और कार्यक्रम जारी है।

एक उदाहरण लेते हैं।

(define (f return)
  (return 2)
  3)
(display (f whatever)) ;; 3
(display (call-with-current-continuation f)) ;; 2
(display (call-with-current-continuation (lambda (x) 4))) ;; 4

पहला display आउटपुट 3 , कारण का।

लेकिन दूसरा display आउटपुट 2 । क्यूं कर?

इसमें गोता लगाते हैं।

मूल्यांकन करते समय (display (call-with-current-continuation f)) , यह पहले मूल्यांकन करेगा (call-with-current-continuation f) । हम जानते हैं कि यह पूरे कार्यक्रम को बदल देगा

(f C)

f लिए परिभाषा को ध्यान में रखते हुए, इसमें ए (return 2) । हमें मूल्यांकन करना चाहिए (C 2) । जब कि continuation कहा जा रहा है। तो यह पूरे कार्यक्रम को वापस बदल देता है

(display (call-with-current-continuation f))

लेकिन अब, call-with-current-continuation का मान 2 । तो कार्यक्रम बन जाता है:

(display 2)

यिन-यांग पहेली

आइए पहेली को देखें।

(let* ((yin
         ((lambda (cc) (display #\@) cc) (call-with-current-continuation (lambda (c) c))))
       (yang
         ((lambda (cc) (display #\*) cc) (call-with-current-continuation (lambda (c) c)))))
      (yin yang))

इसे और अधिक पठनीय बनाते हैं।

(define (id c) c)
(define (f cc) (display #\@) cc)
(define (g cc) (display #\*) cc)
(let* ((yin
         (f (call-with-current-continuation id)))
       (yang
         (g (call-with-current-continuation id))))
      (yin yang))

आइए हमारे मस्तिष्क में कार्यक्रम चलाएं।

गोल ०

let* हमें पहले yin का मूल्यांकन करने के लिए बनाते हैं। yin है

(f (call-with-current-continuation id))

इसलिए हम पहले (call-with-current-continuation id) मूल्यांकन करते हैं। यह वर्तमान वातावरण को पैक करता है, जिसे हम समय-रेखा में अन्य निरंतरता के साथ भेद करने के लिए C_0 कहते हैं, और यह एक पूरे नए ब्रह्मांड में प्रवेश करता है: id । लेकिन id सिर्फ C_0 लौटाता है।

हमें याद रखना चाहिए कि C_0 क्या है। C_0 इस तरह एक कार्यक्रम है:

(let* ((yin
         (f ###))
       (yang
         (g (call-with-current-continuation id))))
      (yin yang))

### एक प्लेसहोल्डर है, जो भविष्य में उस मूल्य से भर जाएगा जिसे C_0 वापस लेता है।

लेकिन id सिर्फ C_0 लौटाता है। यह C_0 कॉल नहीं करता है। यदि यह कॉल करता है, तो हम C_0 के ब्रह्मांड में प्रवेश करेंगे। लेकिन ऐसा नहीं हुआ, इसलिए हम yin का मूल्यांकन करना जारी रखते हैं।

(f C_0) ;; yields C_0

f एक फंक्शन है जैसे id , लेकिन इसका एक साइड इफेक्ट है - outputting @

तो प्रोग्राम आउटपुट @ और yin को C_0 होने C_0 । अब प्रोग्राम बन गया

(let* ((yin C_0)
       (yang
         (g (call-with-current-continuation id))))
      (yin yang))

yin मूल्यांकन के बाद, हम yang का मूल्यांकन करना शुरू करते हैं। yang है

(g (call-with-current-continuation id))

call-with-current-continuation यहाँ एक और निरंतरता बनाते हैं, जिसका नाम C_1C_1 है:

(let* ((yin C_0)
       (yang
         (g ###)))
      (yin yang))

### प्लेसहोल्डर है। ध्यान दें कि इस निरंतरता में, yin का मूल्य निर्धारित किया जाता है (यही वह है जो let* करते हैं)। हमें यकीन है कि yin का मूल्य यहाँ C_0 है।

चूंकि (id C_1) C_1 , इसलिए yang का मूल्य है

(g C_1)

g का साइड इफेक्ट है - outputting * । तो कार्यक्रम करता है।

yang का मान अब C_1

अब तक, हमने @* प्रदर्शित किया है

तो अब यह बन जाता है:

(let* ((yin C_0)
       (yang C_1))
      (yin yang))

जैसा कि yin और yang दोनों को हल किया जाता है, हमें मूल्यांकन करना चाहिए (yin yang) । आईटी इस

(C_0 C_1)

पवित्र एसएच * टी!

लेकिन अंत में, C_0 कहा जाता है। तो हम C_0 ब्रह्मांड में C_0 हैं और इन श * ts के बारे में सब भूल जाते हैं। हम फिर कभी इस ब्रह्मांड में वापस नहीं जाएंगे।

राउंड 1

C_0 वापस C_1 साथ C_1 । कार्यक्रम अब बन जाता है (यदि आप भूल जाते हैं कि C_0 क्या है, तो इसे देखने के लिए वापस जाएं):

(let* ((yin
         (f C_1))
       (yang
         (g (call-with-current-continuation id))))
      (yin yang))

आह, हम पाते हैं कि yin का मूल्य अभी तक निर्धारित नहीं है। इसलिए हम इसका मूल्यांकन करते हैं। yin के मूल्यांकन की प्रक्रिया में, हम f के साइड इफेक्ट के रूप में एक @ उत्पादन करते हैं। और हम जानते हैं कि yin अभी C_1 है।

हम yang का मूल्यांकन करना शुरू करते हैं, हम फिर से call-with-current-continuation आए। हमें अभ्यास कराया जाता है। हम एक निरंतरता C_2 बनाते हैं जो C_2 के लिए है:

(let* ((yin C_1)
       (yang
         (g ###)))
      (yin yang))

और हम एक * g निष्पादन के रूप में प्रदर्शित करते हैं। और हम यहां आते हैं

(let* ((yin C_1)
       (yang C_2))
      (yin yang))

तो हमें मिल गया:

(C_1 C_2)

आप जानते हैं कि हम कहां जा रहे हैं। हम C_1 के ब्रह्मांड में जा रहे हैं। हम इसे मेमोरी से याद करते हैं (या वेबपेज से कॉपी और पेस्ट करते हैं)। यह अभी है:

(let* ((yin C_0)
       (yang
         (g C_2)))
      (yin yang))

हम C_1 के ब्रह्मांड में जानते हैं, yin का मूल्य निर्धारित किया गया है। इसलिए हम yang का मूल्यांकन करना शुरू करते हैं। जैसा कि हम अभ्यास कर रहे हैं, मैं आपको सीधे बताऊंगा कि यह * और प्रदर्शित करता है:

(C_0 C_2)

अब हमने @*@** प्रिंट किया है, और हम C_0 के ब्रह्मांड को C_2 साथ ले जा रहे हैं।

दूसरा दौर

जैसा कि हम अभ्यास कर रहे हैं, मैं आपको बताऊंगा कि हम '@' प्रदर्शित करते हैं, yin C_2 , और हम एक नई निरंतरता C_3 , जो इसके लिए है:

(let* ((yin C_2)
       (yang
         (g ###)))
      (yin yang))

और हम प्रदर्शित करते हैं * , yang C_3 , और यह बन जाता है

(C_2 C_3)

और हम जारी रख सकते हैं। लेकिन मैं यहां रुकूंगा, मैंने आपको दिखाया है कि यिन-यांग पहेली के पहले कई आउटपुट क्या हैं।

* की संख्या क्यों बढ़ जाती है?

अब आपका सिर विवरण से भरा है। मैं आपके लिए एक सारांश बनाऊंगा।

मैं सरल बनाने के लिए सिंटैक्स जैसे हास्केल का उपयोग करूंगा। और cc call-with-current-continuation

जब #C_i# को #C_i# ब्रैकेटेड किया जाता है, इसका मतलब है कि निरंतरता यहां बनाई गई है। ; उत्पादन का मतलब है

yin = f cc id
yang = g cc id
yin yang

---

yin = f #C_0# ; @
yang = g cc id
yin yang

---

yin = C_0
yang = g #C_1# ; *
yin yang

---

C_0 C_1

---

yin = f C_1 ; @
yang = g #C_2# ; *
yin yang

---

C_1 C_2

---

yin = C_0
yang = g C_2 ; *
yin yang

---

C_0 C_2

---

yin = f C_2 ; @
yang = g #C_3#; *
yin yang

---

C_2 C_3

---

yin = C_1
yang = g C_3 ; *
yin yang

---

C_1 C_3

---

yin = C_0
yang = g C_3 ; *
yin yang

---

C_0 C_3

यदि आप ध्यान से देखते हैं, तो यह आपके लिए स्पष्ट होगा

  1. बहुत सारे ब्रह्मांड हैं (वास्तव में अनंत), लेकिन C_0 एकमात्र ब्रह्मांड है जो f द्वारा शुरू किया गया f । दूसरों को g द्वारा शुरू किया जाता है।
  2. C_0 C_n हमेशा एक नई निरंतरता C_max बनाता है। ऐसा इसलिए है क्योंकि C_0 पहला ब्रह्मांड है जिसे g cc id निष्पादित नहीं किया गया है।
  3. C_0 C_n भी @ प्रदर्शित करते हैं। C_n C_m जो n 0 नहीं है वह * प्रदर्शित करेगा।
  4. समय-समय पर कार्यक्रम C_0 C_n लिए C_0 C_n , और मैं यह साबित कर C_0 C_n कि C_0 C_n अधिक से अधिक अन्य अभिव्यक्ति से अलग हो गया है, जो @*@**@***... ओर जाता है @*@**@***...

थोड़ा सा गणित

मान लीजिये (n! = 0) सभी निरंतरताओं में सबसे बड़ी संख्या है, और फिर C_0 C_n कहा जाता है।

धारणा: जब C_0 C_n कहा जाता है, तो C_0 C_n वर्तमान अधिकतम क्रमांकित निरंतरता है।

अभी व C_0 C_n द्वारा इस तरह बनाया गया है:

yin = f C_n ; @
yang = g #C_{n+1}#
yin yang

तो हम यह निष्कर्ष निकालते हैं:

प्रमेय I. यदि C_0 C_n कहा जाता है, तो यह एक निरंतरता उत्पन्न करेगा , जिसमें yin C_n

फिर अगला चरण C_n C_{n+1}

yin = C_{n-1}
yang = g C_{n+1} ; *
yin yang

yin C_{n-1} कारण है कि जब C_n बनाया जा रहा है तो यह प्रमेय I का पालन करता है

और फिर C_{n-1} C_{n+1} कहा जाता है, और हम जानते हैं कि जब C_{n-1} बनाया जाता है, तो यह भी प्रमेय I का पालन करता है । इसलिए हमारे पास C_{n-2} C_{n+1}

C_{n+1} की भिन्नता है। तो हमारे पास दूसरा प्रमेय है:

प्रमेय II। यदि C_n C_m जिसे n < m और n > 0 कहा जाता है, तो यह C_{n-1} C_m

और हमने मैन्युअल रूप से C_0 C_1 C_2 C_3 जाँच की है। वे अनुमान और सभी सिद्धांतों का पालन करते हैं। और हम जानते हैं कि कैसे पहले @ और * बनाया जाता है।

तो हम नीचे पैटर्न लिख सकते हैं।

C_0 C_1 ; @ *
C_[1-0] C_2 ; @ * *
C_[2-0] C_3 ; @ * * *
...

यह इतना सख्त नहीं है, लेकिन मैं लिखना चाहूंगा:

QED