GPT-5.6 और Dinitz-Garg-Goemans अनुमेय

22 जुलाई, 2026 को, दिमित्री राइबिन ने X पर एक दावा पोस्ट किया जिसने एक ख़ास तरह के लोगों को अपना कॉफी कप नीचे रखवा दिया: GPT-5.6 Pro ने Dinitz-Garg-Goemans अनुमेय के लिए एक प्रतिवाद पेश किया, जो लगभग 30 सालों से संयोजकीय अनुकूलन में खुला था। अवधारणा का प्रमाण एक छोटा-सा ग्राफ था। आंशिक (फ्रैक्शनल) प्रवाह लागत 58, अविभाज्य (अनस्प्लिटेबल) प्रवाह लागत 60। दो अंक, तीन दशक, चार प्रॉम्प्ट।

ज़्यादातर कवरेज संख्याएँ तो दोहराता है, लेकिन उनके पीछे का तंत्र नहीं दिखाता—और असल सीख उसी तंत्र में छिपी है। यही वह जगह भी है जहाँ मुझे साफ़-साफ़ बताना है कि क्या सत्यापित हुआ है और क्या नहीं। संक्षेप में: अवधारणाएँ ठोस हैं, खबर एक दावा है—अभी प्रमेय नहीं; और यदि आप बैठकर वही सटीक ग्राफ शून्य से फिर बनाना चाहें, तो जैसे ही आपकी संरचना में कहीं से रिसाव होता है, आपको समझ आएगा कि ऐसे प्रश्न कठिन क्यों होते हैं।

त्वरित उत्तर

राइबिन बताते हैं कि चार प्रॉम्प्ट, कुल मिलाकर 60 शब्दों से कम, की मार्गदर्शना में GPT-5.6 Pro ने गोएमन्स की लागत-संबंधी अनुमेय के लिए एक कथित प्रतिवाद बनाया—एक समस्या जो लगभग 1999 से खुली थी। उनका उदाहरण एक छोटा निर्देशित ग्राफ है, एक स्रोत और तीन डिलीवरी टर्मिनल के साथ। उनका कहना है कि विभाज्य (फ्रैक्शनल) रूटिंग की लागत 58 आती है, जबकि कोई भी अविभाज्य रूटिंग जो भीड़ (कंजेशन) को तय बजट में रखे, उसकी लागत कम-से-कम 60 होगी। यह दो अंकों का अंतर, अगर औपचारिक समीक्षा में टिकता है, तो अनुमेय को डुबोने के लिए काफ़ी है।

यह पीयर रिव्यू से नहीं गुज़रा है। राइबिन ने पूरा ChatGPT वार्तालाप प्रकाशित किया है ताकि कोई भी निर्माण देख सके, और कई लोगों ने उनके गणित की जाँच कर उसे सुसंगत पाया है। पर दोहराने योग्य अंक-गणित और स्वीकृत प्रमाण अलग बातें हैं, और उनके बीच की दूरी ही इस लेख की पूरी कहानी है।

Dinitz-Garg-Goemans अनुमेय क्या है?

यह समझने से पहले कि क्या गिरा—या शायद गिरा—हमें जानना होगा कि अनुमेय कहती क्या है।

कल्पना कीजिए कि एक गोदाम सड़कों के नेटवर्क पर तीन कस्बों को माल भेज रहा है। अगर आपको एक शिपमेंट बाँटने की अनुमति है, तो आप आधा माल एक सड़क से और आधा दूसरी से भेज सकते हैं। इसे फ्रैक्शनल रूटिंग कहते हैं—यह लचीली होती है; आमतौर पर सस्ती राहें ढूँढ लेती है। पर असल माल अक्सर बाँटा नहीं जा सकता। एक ऑर्डर, एक ट्रक, एक सड़क, शुरू से अंत तक। यही अनस्प्लिटेबल फ्लो है—और वास्तविकता में एक माल ऑर्डर, एक नेटवर्क पैकेट, या एक शिपिंग कंटेनर को यही करना पड़ता है।

1999 से लोग जिस प्रश्न को चबा रहे हैं, वह कहना आसान है: यदि कोई सस्ती फ्रैक्शनल रूटिंग मौजूद है, तो क्या आप हमेशा ऐसी अविभाज्य रूटिंग पा सकते हैं जो भी सस्ती हो—बिना सड़कों को ज़्यादा ओवरलोड किए?

येफिम दिनित्ज़, naveen Garg और मिशेल गोएमन्स ने इसका आधा हिस्सा सुलझा दिया। बाकी आधे पर GPT-5.6 ने वार किया। यह फ़र्क क्यों बेहद मायने रखता है, यह समझने के लिए हमें सटीक होना होगा।

प्रमेय बनाम अनुमेय

यही वह फ़र्क है जिसे अधिकतर लेख उलझा देते हैं, इसलिए मैं इसे एक बार साफ़ कर दूँगा और फिर आगे इसी पर भरोसा करूँगा।

दिनित्ज़, गर्ग और गोएमन्स ने प्रमाणित किया था: यदि एक वैध फ्रैक्शनल फ्लो दिया हो, तो आप उसे हमेशा एक अविभाज्य फ्लो में बदल सकते हैं—ऐसे कि किसी भी सड़क की क्षमता अधिकतम सबसे बड़े माँग D से ज़्यादा न टूटे। यह प्रमेय निर्विवाद है और हमेशा रहा है।

गोएमन्स ने अलग से अनुमान लगाया था—एक और मजबूत, लागत-संवेदी संस्करण: कि वही रूपांतरण कुल लागत को भी नीचे रख सकता है, उसी समय जब वह भीड़ को भी नियंत्रित रखे। कंजेशन और लागत—दोनों पर सीमाएँ—एक ही रूटिंग में। केवल-भीड़ वाला प्रमेय सुरक्षित है। लागत-प्लस-भीड़ वाली अनुमेय वह कड़ी है जिसके गिरने का राइबिन दावा करते हैं। यदि आप इस लेख से एक वाक्य साथ ले जाएँ, तो वही हो। बहुत-सी उत्साहित कवरेज दोनों को चुपचाप अदल-बदल देती है, और उनके बीच का फ़र्क ही वह गणितीय दरार है जिसे बंद करने में 30 साल लगे।

GPT-5.6 ने दरअसल क्या बनाया

राइबिन का उदाहरण इतना छोटा है कि एक पैराग्राफ में आ जाए। एक स्रोत, कुछ मध्यवर्ती नोड जो एक साझा "रीढ़" बनाते हैं, और तीन टर्मिनल—हर एक के पास एक माँग। हर टर्मिनल के पास घर जाने के दो रास्ते हैं: एक महँगा सीधा रास्ता, या साझा रीढ़ से होकर एक मुफ़्त चक्कर।

तनाव संरचनात्मक है। सस्ते चक्कर रीढ़ पर जगह के लिए प्रतिस्पर्धा करते हैं, तो अगर ज़्यादा टर्मिनल एक साथ सस्ता चलना चाहें, तो रीढ़ की कोई सड़क भर जाती है। इसे पर्याप्त आगे धकेलें और किसी भी वैध अविभाज्य रूटिंग में केवल एक टर्मिनल ही अपना सस्ता रास्ता ले सकता है। बाकी को उनके महँगे सीधे रास्तों पर जाना पड़ता है, और लागत बढ़ती है। फ्रैक्शनल फ्लो, जिसे बाँटने की छूट है, हर माँग को दोनों रास्तों में फैलाकर एक साथ हर क्षमता के नीचे से निकल जाता है। इसी तरह फ्रैक्शनल लागत, सबसे सस्ती वैध अविभाज्य लागत से नीचे आ जाती है। राइबिन के आँकड़े उनके उदाहरण में 58 और 60 हैं।

यहाँ एक सीमा के बारे में ईमानदारी से कहूँ। मैं राइबिन का सटीक ग्राफ—ख़ास क्षमताएँ और जोड़ीदार टकराव—किसी प्राथमिक स्रोत से पुनर्निर्मित नहीं कर पाया हूँ। उनका ट्रांसक्रिप्ट एक पैरामीटर परिवार के किसी विशिष्ट बिंदु का वर्णन करता है, और जो व्यापक रूप से साझा किया गया "सात-नोड" विवरण है, वह उसका एक अमूर्तीकरण है—ऐसी संरचना नहीं जिसे मैंने किनारे-दर-किनारा सत्यापित किया हो। इसलिए मैं 58 की कोई सुथरी व्युत्पत्ति मंचित कर उसे उनका कहने का नाटक नहीं करूँगा। जो मैं कर सकता हूँ, वह यह है कि आपको एक आत्म-निहित उदाहरण दूँ जो वही तंत्र दिखाता है—इतना छोटा कि बलपूर्वक जाँच हो सके—ताकि आप अपनी आँखों से देख सकें कि "फ्रैक्शनल हर वैध अविभाज्य को पछाड़ता है" का अर्थ कैसा दिखता है। 

चार प्रॉम्प्ट, कई घंटे

प्रॉम्प्ट की गिनती इस कहानी का सबसे कम रोचक हिस्सा है—भले ही वही वायरल हुआ।

राइबिन द्वारा साझा की गई चैट लॉग दिखाती है कि मॉडल पहले असफल हुआ—और ईमानदारी से असफल हुआ। शुरुआती प्रॉम्प्ट ने उससे एक संरचित प्रतिवाद माँगा। वह तकरीबन एक घंटे तक काम करता रहा और खाली हाथ लौटा, साफ़-साफ़ कहते हुए कि जो उसके पास है उसे वैध प्रतिवाद बताना असत्य होगा।

आगे बढ़ने को कहने पर, उसने फिर चलाया—और फिर कुछ नहीं बताया, समझाते हुए कि हर आशाजनक निर्माण में, जब सभी पथ गिने गए, तो कोई छिपा अतिरिक्त रूटिंग विकल्प उभर आता था जो लागत-भीड़ अलगाव को खत्म कर देता था। तीसरे प्रॉम्प्ट में एक साफ़तर रणनीति माँगने पर उसे एक संकरा ढाँचा मिला—पर फिर भी कोई अंतिम नतीजा नहीं।

यह "चार प्रॉम्प्ट, पूरा" नहीं है। यह घंटों तक एक मॉडल का दीवारों से टकराना और उनके बारे में सच बताना है। जिस ख़ास दीवार से वह बार-बार टकरा रहा था—एक अतिरिक्त रास्ता दिखता है और अलगाव बिगाड़ देता है—वही वह चीज़ है जिसे अंतिम निर्माण ने रोकने के लिए बनाया: हर टर्मिनल को ठीक दो पथों से बाँधकर ताकि पूरी रूटिंग स्पेस आठ विकल्पों में सिमट जाए, जिन्हें आप हाथ से गिन सकें। इस विफलता-ढंग को याद रखिए; आप अभी इससे खुद टकराने वाले हैं।

चौथा प्रॉम्प्ट—बताया गया है कि कुछ इस तरह था "बस अब तुम्हारी नाकामियाँ बहुत हो गईं, कृपया एक पूर्ण, बिना शर्त प्रतिवाद के साथ खत्म करो"—वही था जिसने काम करने वाला निर्माण दिया, साथ में प्रूफ सर्टिफिकेट, एक एन्यूमरेशन प्रोग्राम, और पूरा LaTeX। धैर्य मायने रखता था। पहले के इंकार भी—वे ईमानदार आत्म-मूल्यांकन थे।

खुद जाँचिए

यहीं DataCamp कवरेज वह कर सकता है जो कोई खबर पोस्ट नहीं कर सकती: आपको सत्यापन चलाने देना।

कोड से पहले एक छोटा सा caveat। आगे जो है वह राइबिन का ग्राफ नहीं है। यह एक योजनाबद्ध उदाहरण है जो मैंने ईमानदारी से बनाया—जहाँ हर टर्मिनल के पास सचमुच ठीक दो रास्ते हैं, अंक-गणित बंद होता है, और अंतर वास्तविक है। यह ऐसे प्रतिवाद का ढाँचा और उसे जाँचने की तकनीक दिखाता है। यह अपने आप में कुछ भी खारिज नहीं करता—और क्यों, यह मैं ठीक आपके इसे चलाने के बाद बताऊँगा।

सेटअप: तीन टर्मिनल, हर एक 10 इकाई भेजता है, तो सबसे बड़ी माँग D = 10। हर एक के पास एक महँगा सीधा रास्ता (लागत 30) और एक मुफ़्त सस्ता रास्ता। सस्ते रास्ते इस तरह रखे गए हैं कि हर जोड़ी उनकी अपनी निजी बोतलनेक सड़क पर लड़ती है: सड़क A टर्मिनल 1 और 2 की साझा, सड़क B 1 और 3 की, सड़क C 2 और 3 की। फ्रैक्शनल फ्लो में, हर टर्मिनल अपनी माँग का 2/5 सस्ता और 3/5 महँगा भेजता है, जिसकी लागत 30 x 3/5 x 3 = 54 आती है। तब हर सड़क पर 4 + 4 = 8 इकाई फ्रैक्शनल लोड होता है, और कंजेशन बजट वह लोड प्लस D, यानी 18।

अब देखिए अविभाज्य रूटिंग इसका क्या करती है। दो टर्मिनल दोनों सस्ते जाएँ तो अपनी साझा सड़क पर 10 + 10 = 20 इकाई डाल देते हैं, जो 18 के बजट से ऊपर है। तो अधिकतम एक ही टर्मिनल सस्ता रूट कर सकता है; बाकी दो 30-30 चुकाते हैं। न्यूनतम वैध अविभाज्य लागत: 60। जबकि फ्रैक्शनल 54। आठ रूटिंग्स हैं, तो हम बस सभी जाँच लेते हैं:

from itertools import product
	
# Three terminals, demand 10 each -> largest demand D = 10.
# Each has a cheap path (cost 0) and an expensive direct path (cost 30).
# Cheap paths pairwise share a PRIVATE bottleneck road, so every pair conflicts:
#   road A shared by {t1, t2},  road B by {t1, t3},  road C by {t2, t3}
# NOTE: this is a schematic instance to illustrate the check, not Rybin's graph.

demands = [10, 10, 10]
d_max = max(demands)          # congestion slack allowed on each road
cheap_frac = [2/5, 2/5, 2/5]  # expensive fraction is 3/5 each -> fractional cost 54
direct_cost = 30              # cost of one terminal's expensive path

# Which bottleneck roads each terminal's cheap path uses
uses = [
    {"A": True,  "B": True,  "C": False},  # t1: A, B
    {"A": True,  "B": False, "C": True},   # t2: A, C
    {"A": False, "B": True,  "C": True},   # t3: B, C
]

# The fractional flow saturates each road, so its load is that road's capacity
cap = {"A": 0.0, "B": 0.0, "C": 0.0}
for i in range(3):
    for road in cap:
        if uses[i][road]:
            cap[road] += cheap_frac[i] * demands[i]   # 8 units on each road

# Congestion rule: an unsplittable flow may exceed capacity by at most D
threshold = {road: cap[road] + d_max for road in cap}  # 18 on each road

fractional_cost = sum(direct_cost * (1 - cheap_frac[i]) for i in range(3))  # 54

print(f"Capacities (fractional load): {cap}")
print(f"Congestion budget per road  : {threshold}")
print(f"Fractional flow cost        : {fractional_cost}\n")
print(f"{'Route (0=cheap,1=exp)':22} {'Cost':>4} {'A':>3} {'B':>3} {'C':>3}  Valid")

valid_costs = []
for choices in product([0, 1], repeat=3):    # 0 = cheap, 1 = expensive
    cost = sum(direct_cost * c for c in choices)
    load = {"A": 0, "B": 0, "C": 0}
    for i, expensive in enumerate(choices):
        if expensive == 0:                    # this terminal takes its cheap path
            for road in load:
                if uses[i][road]:
                    load[road] += demands[i]
    ok = all(load[road] <= threshold[road] for road in load)
    tag = "OK" if ok else "overload"
    print(f"{str(choices):22} {cost:>4} {load['A']:>3} {load['B']:>3} {load['C']:>3}  {tag}")
    if ok:
        valid_costs.append(cost)

print(f"\nMin valid unsplittable cost: {min(valid_costs)}")
print(f"Gap: {min(valid_costs) - fractional_cost} (counterexample if > 0)")

इसे चलाइए और आपको 54 की फ्रैक्शनल लागत, 60 की न्यूनतम वैध अविभाज्य लागत, और 6 का अंतर मिलेगा। जो तीन पंक्तियाँ ओवरलोड होती हैं, वे वही तीन जोड़ीदार टकराव हैं; जो रूटिंग बचती हैं, वे अधिकतम एक ही टर्मिनल को सस्ता रखती हैं।

तो क्या अनुमेय मर गई? अभी नहीं—और यही वह हिस्सा है जिसका मैंने वादा किया था। यह आठ-पंक्ति गणना तभी सच बताती है जब हर टर्मिनल के पास वास्तव में केवल दो रास्ते हों—न उससे अधिक। इस ग्राफ को असल सड़कों और नोड से बनाइए, तो चतुराई से कहीं न कहीं एक चौथा सस्ता रास्ता दिख जाता है। कोई टर्मिनल तीसरा सस्ता घर-रास्ता ढूँढ लेता है जो बजट में रहता है—और अंतर बंद हो जाता है। यही अतिरिक्त रास्ता वह सटीक विफलता है जिसका मॉडल ने पहले तीन प्रयासों में ज़िक्र किया था। एक साफ़-सुथरा, सममित गैजेट जो आठ पंक्तियों के Python में 30-वर्षीय अनुमेय तोड़ दे—यह सच होने के लिए बहुत अच्छा लगता—और सच नहीं है। ऊपर का कोड यह सिद्ध करता है कि जाँच पद्धति ठोस है और लक्ष्य-गुण वास्तविक। किसी दिए गए ग्राफ में वह गुण बिना रिसाव के है या नहीं—यह कठिन भाग है, और यही कारण है कि राइबिन का असली उदाहरण एक पैरामीटर परिवार का सधा हुआ बिंदु है, न कि कोई सुथरा त्रिभुज।

क्या अब भी अनसुलझा है

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

ठीक-ठीक प्रकाशित ग्राफ—जहाँ तक मुझे मिला—किसी प्राथमिक स्रोत से स्वतंत्र रूप से फिर नहीं बनाया गया। जो संख्याएँ चल रही हैं, वे उनकी पोस्ट और साझा ट्रांसक्रिप्ट से आती हैं। कई शोधकर्ताओं ने उनके अंक-गणित की जाँच कर उसे सुसंगत कहा है, और एक ने दिखाया कि उनका उदाहरण उन्हीं नोड पर एक अनंत त्रि-पैरामीटर परिवार के भीतर बैठता है—जो परिणाम को एक आकस्मिक संयोग से अधिक समृद्ध बना देगा। हौसला-अफ़ज़ा, पर यह अनौपचारिक सामुदायिक जाँच है—रेफ़री रिपोर्ट नहीं। 58-बनाम-60 को एक दृढ़ दावे की तरह लीजिए, किसी तयशुदा तथ्य की तरह नहीं।

1999 का कंजेशन प्रमेय इन सबसे अप्रभावित है।

एक पैटर्न का हिस्सा

यह कहानी कोई अकेला डेटा बिंदु नहीं है। यह लगभग तीन महीनों में AI-सहायता से गिरी तीसरी अनुमेय बताई जा रही है—और यह पैटर्न गौर करने लायक है।

20 जुलाई को, Claude Fable 5 ने कथित तौर पर गणितज्ञ लेवेंट अल्पोज़े की मदद की जैकॉबियन अनुमेय के प्रतिवाद तक पहुँचने में—87 साल पुरानी समस्या। उससे पहले, मई में, कहा गया कि एक OpenAI मॉडल ने 80 साल पुरानी एर्ड़ोश यूनिट-डिस्टेंस अनुमेय को गलत साबित किया। इसी हफ़्ते, एक कोलंबिया के पीएचडी छात्र ने GPT-5.6 को संरचित Codex वर्कफ़्लो के साथ इस्तेमाल कर पाँच दिनों में एर्ड़ोश की छह खुली समस्याएँ सुलझाईं। साझा धागा, जैसा एक शोधकर्ता ने कहा, यह है कि ये प्रणालियाँ खण्डन में, सिद्ध करने की तुलना में, बेहतर हैं। एक प्रतिवाद एक अकेला साक्षी है जिसे आप जाँच सकते हैं; एक प्रमाण को हर स्थिति ढकनी होती है। यही विषमता तय करती दिखती है कि कौन-सी समस्याएँ पहले गिरती हैं।

व्यावहारिक निचोड़ यह नहीं है कि "AI गणित सुलझा देता है।" हम जो देख रहे हैं वह है AI एक धैर्यवान, संयोजकीय रूप से व्यापक खोज-सहयोगी के रूप में काम करते हुए: जो पैरामीटर परिवारों का एन्यूमरेशन कर सके, विफलता-ढंगों को प्रयास-दर-प्रयास कार्यशील स्मृति में रख सके, और जब कोई निर्माण बंद नहीं होता तो सच बता सके। यह एक विशिष्ट, उपयोगी क्षमता है। और यदि आप समझना चाहते हैं कि यह आगे कहाँ वार कर सकता है, तो सवाल यह नहीं होना चाहिए कि कौन-सी अनुमेय सबसे पुरानी हैं—बल्कि यह कि किन्हें किसी एक जाँचने योग्य साक्षी से तोड़ा जा सकता है।