यूलेरियन संख्या: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 1: Line 1:
{{distinguish|Euler number|Euler's number}}
{{distinguish|यूलर संख्या|यूलर की संख्या}}


{{Short description|Polynomial sequence}}
{{Short description|Polynomial sequence}}
[[साहचर्य]] में, यूलेरियन संख्या <math display="inline">A(n,k)</math> 1 से संख्याओं के क्रम[[परिवर्तन]] की संख्या है<math display="inline">n</math>जिसमें बिल्कुल<math display="inline">k</math>तत्व पिछले तत्व से बड़े हैं (क्रमपरिवर्तन के साथ)।<math display="inline">k</math>आरोहण ).


[[लियोनहार्ड यूलर]] ने अपनी 1755 की पुस्तक [[विभेदक कैलकुलस की संस्थाएँ]] में उनकी और संबंधित बहुपदों की जांच की।


[[Image:EulerianPolynomialsByEuler1755.png|right|303px|thumb|1755 से यूलर के कार्य में बहुपदों को वर्तमान में यूलरियन बहुपद के रूप में जाना जाता है, इंस्टीट्यूशन्स कैलकुली डिफरेंशियल, भाग 2, पृष्ठ। 485/6. इन बहुपदों के गुणांकों को यूलेरियन संख्याएँ कहा जाता है।]]के लिए अन्य संकेतन <math display="inline">A(n,k)</math> हैं <math display="inline">E(n,k)</math> और <math>\textstyle \left\langle {n \atop k} \right\rangle</math>.
कॉम्बिनेटरिक्स में, '''यूलेरियन संख्या''' <math display="inline">A(n,k)</math> 1 से <math display="inline">n</math> तक की संख्याओं के क्रमपरिवर्तन की संख्या है जिसमें बिल्कुल <math display="inline">k</math> अवयव पिछले अवयव से बड़े होते हैं (<math display="inline">k</math> "आरोही" के साथ क्रमपरिवर्तन)।
 
[[लियोनहार्ड यूलर]] ने अपनी 1755 की पुस्तक [[विभेदक कैलकुलस की संस्थाएँ|कैलकुली डिफरेंशियलिस संस्थाएँ]]  में उनकी और संबंधित बहुपदों की जांच की थी।
 
[[Image:EulerianPolynomialsByEuler1755.png|right|303px|thumb|1755 से यूलर के कार्य में बहुपदों को वर्तमान में यूलरियन बहुपद के रूप में जाना जाता है, इंस्टीट्यूशन्स कैलकुली डिफरेंशियल, भाग 2, पृष्ठ। 485/6. इन बहुपदों के गुणांकों को यूलेरियन संख्याएँ कहा जाता है।]]<math display="inline">A(n,k)</math> के लिए अन्य संकेतन <math display="inline">E(n,k)</math> और <math>\textstyle \left\langle {n \atop k} \right\rangle</math> हैं


==परिभाषा==
==परिभाषा==
यूलेरियन बहुपदों को घातीय जनरेटिंग फ़ंक्शन द्वारा परिभाषित किया गया है
यूलेरियन बहुपदों को घातीय जनरेटिंग फलन द्वारा परिभाषित किया गया है
:<math>\sum_{n=0}^{\infty} A_{n}(t) \,\frac{x^n}{n!} = \frac{t-1}{t - e^{(t-1)\,x}}.</math>
:<math>\sum_{n=0}^{\infty} A_{n}(t) \,\frac{x^n}{n!} = \frac{t-1}{t - e^{(t-1)\,x}}.</math>
यूलेरियन संख्याओं को यूलेरियन बहुपदों के गुणांक के रूप में परिभाषित किया जा सकता है:
यूलेरियन संख्याओं को यूलेरियन बहुपदों के गुणांक के रूप में परिभाषित किया जा सकता है:
:<math>A_{n}(t) = \sum_{k=0}^n A(n,k)\,t^k.</math>
:<math>A_{n}(t) = \sum_{k=0}^n A(n,k)\,t^k.</math>
के लिए स्पष्ट सूत्र <math display="inline">A(n,k)</math> है<ref>(L. Comtet 1974, p. 243)</ref>
<math display="inline">A(n,k)</math> के लिए स्पष्ट सूत्र  है<ref>(L. Comtet 1974, p. 243)</ref>
:<math>A(n,k)=\sum_{i=0}^{k}(-1)^i \binom{n+1}{i} (k+1-i)^n.</math>
:<math>A(n,k)=\sum_{i=0}^{k}(-1)^i \binom{n+1}{i} (k+1-i)^n.</math>




==बुनियादी गुण==
==मूलभूत गुण==
* तय के लिए<math display="inline">n</math>एक एकल क्रमपरिवर्तन है जिसमें 0 आरोहण हैं: <math display="inline">(n, n-1, n-2, \ldots, 1)</math>. वास्तव में, जैसे <math>{\tbinom n 0}=1</math> सभी के लिए <math>n</math>, <math display="inline">A(n, 0) = 1</math>. इसमें औपचारिक रूप से संख्याओं का खाली संग्रह शामिल है, <math display="inline">n=0</math>. इसलिए <math display="inline">A_0(t)=A_1(t)=1</math>.
*निश्चित <math display="inline">n</math> के लिए एक एकल क्रमचय है जिसमें 0 आरोह हैं: <math display="inline">(n, n-1, n-2, \ldots, 1)</math> वास्तव में, सभी के लिए <math>{\tbinom n 0}=1</math> के रूप में। इसमें औपचारिक रूप से संख्याओं का रिक्त संग्रह, <math display="inline">A(n, 0) = 1</math> सम्मिलित है। इसलिए <math display="inline">A_0(t)=A_1(t)=1</math>
* के लिए <math display="inline">k=1</math> स्पष्ट सूत्र का तात्पर्य है <math display="inline">A(n,1)=2^n-(n+1)</math>, में क्रम <math>n</math> वह पढ़ता है <math display="inline">0, 0, 1, 4, 11, 26, 57, \dots</math>.
*<math display="inline">k=1</math> के लिए स्पष्ट सूत्र का तात्पर्य <math display="inline">A(n,1)=2^n-(n+1)</math> है, <math>n</math> में एक अनुक्रम जो <math display="inline">0, 0, 1, 4, 11, 26, 57, \dots</math> पढ़ता है
* के साथ क्रमपरिवर्तन को पूरी तरह से उलट देना<math display="inline">k</math>आरोहण और क्रमपरिवर्तन बनाता है जिसमें मौजूद हैं<math display="inline">n-k-1</math>आरोहण। इसलिए <math display="inline">A(n, k) = A(n, n-k-1)</math>. तो वहाँ भी ही क्रमपरिवर्तन है जो है<math display="inline">n-1</math>आरोहण, अर्थात् बढ़ती क्रमपरिवर्तन <math display="inline">(1, 2, \ldots, n)</math>. इसलिए भी <math display="inline">A(n, n-1)</math> के बराबर होती है <math>1</math>.
*<math display="inline">k</math> आरोही के साथ एक क्रमपरिवर्तन को पूरी तरह उलटने से एक और क्रमपरिवर्तन बनता है जिसमें <math display="inline">n-k-1</math> आरोही होते हैं। इसलिए <math display="inline">A(n, k) = A(n, n-k-1)</math> तो एक एकल क्रमपरिवर्तन भी है जिसमें <math display="inline">n-1</math> आरोही है, अर्थात् आरोही क्रमपरिवर्तन <math display="inline">(1, 2, \ldots, n)</math> अतः <math display="inline">A(n, n-1)</math> भी <math>1</math> के समान है
* एक भव्य ऊपरी सीमा है <math display="inline">A(n, k) \le (k+1)^n\cdot(n+2)^k</math>. अभी चर्चा की गई सीमाओं के बीच, मान अधिक हो गया है <math>1</math>.
*एक लविश ऊपरी सीमा <math display="inline">A(n, k) \le (k+1)^n\cdot(n+2)^k</math> है। अभी चर्चा की गई सीमाओं के बीच, मान <math>1</math> से अधिक है
* के लिए <math display="inline">k\ge n > 0</math>, मान औपचारिक रूप से शून्य हैं, जिसका अर्थ है कई योग <math display="inline">k</math> तक ही ऊपरी सूचकांक के साथ लिखा जा सकता है <math display="inline">n-1</math>. इसका मतलब यह भी है कि बहुपद <math>A_{n}(t)</math> वास्तव में बहुपद की डिग्री के हैं <math display="inline">n-1</math> के लिए <math display="inline">n>0</math>.
*<math display="inline">k\ge n > 0</math> के लिए, मान औपचारिक रूप से शून्य हैं, जिसका अर्थ है कि <math display="inline">k</math> के ऊपर कई रकम केवल <math display="inline">n-1</math> तक के ऊपरी सूचकांक के साथ लिखी जा सकती हैं। इसका यह भी अर्थ है कि बहुपद <math>A_{n}(t)</math> वास्तव में <math display="inline">n-1</math> के लिए डिग्री <math display="inline">n>0</math> हैं


[[त्रिकोणीय सरणी]] में संख्याओं के सारणीकरण को यूलर त्रिकोण या यूलर का त्रिकोण कहा जाता है। यह पास्कल के त्रिकोण के साथ कुछ सामान्य विशेषताएं साझा करता है। के मान <math display="inline">A(n, k)</math> {{OEIS|id=A008292}} के लिए <math display="inline">0 \le n \le 9</math> हैं:
[[त्रिकोणीय सरणी]] में संख्याओं के सारणीकरण को यूलर त्रिकोण या यूलर का त्रिकोण कहा जाता है। यह पास्कल के त्रिकोण के साथ कुछ सामान्य विशेषताएं साझा करता है। <math display="inline">A(n, k)</math> {{OEIS|id=A008292}} के लिए <math display="inline">0 \le n \le 9</math> हैं:


:{| class="wikitable" style="text-align:right;"
:{| class="wikitable" style="text-align:right;"
Line 72: Line 74:


==गणना==
==गणना==
के बड़े मूल्यों के लिए <math display="inline">n</math>, <math display="inline">A(n,k)</math> पुनरावृत्ति सूत्र का उपयोग करके भी गणना की जा सकती है
<math display="inline">n</math>, <math display="inline">A(n,k)</math> के बड़े मानों की गणना पुनरावर्ती सूत्र का उपयोग करके भी की जा सकती है
:<math>A(n,k)=(n-k)\,A(n-1,k-1) + (k+1)\,A(n-1,k).</math>
:<math>A(n,k)=(n-k)\,A(n-1,k-1) + (k+1)\,A(n-1,k).</math>
इस सूत्र को संयोजक परिभाषा से प्रेरित किया जा सकता है और इस प्रकार यह सिद्धांत के लिए प्राकृतिक प्रारंभिक बिंदु के रूप में कार्य करता है।
इस सूत्र को संयोजक परिभाषा से प्रेरित किया जा सकता है और इस प्रकार यह सिद्धांत के लिए प्राकृतिक प्रारंभिक बिंदु के रूप में कार्य करता है।


के छोटे मूल्यों के लिए<math display="inline">n</math>और<math display="inline">k</math>, के मूल्य <math display="inline">A(n,k)</math> हाथ से गणना की जा सकती है. उदाहरण के लिए
<math display="inline">n</math> और <math display="inline">k</math>, के छोटे मानों के लिए, <math display="inline">A(n,k)</math> के मानों की गणना हाथ से की जा सकती है। उदाहरण के लिए


:{| class="wikitable"
:{| class="wikitable"
Line 82: Line 84:
! ''n''
! ''n''
! ''k''
! ''k''
! Permutations
! क्रमपरिवर्तन
! ''A''(''n'', ''k'')
! ''A''(''n'', ''k'')
|-
|-
Line 112: Line 114:
| ''A''(3,2) = 1
| ''A''(3,2) = 1
|}
|}
पुनरावृत्ति को उदाहरण पर लागू करने पर, हम पा सकते हैं
पुनरावृत्ति को उदाहरण पर प्रयुक्त करने पर, हम पा सकते हैं
:<math>A(4,1)=(4-1)\,A(3,0) + (1+1)\,A(3,1)=3 \cdot 1 + 2 \cdot 4 = 11.</math>
:<math>A(4,1)=(4-1)\,A(3,0) + (1+1)\,A(3,1)=3 \cdot 1 + 2 \cdot 4 = 11.</math>
इसी प्रकार, यूलेरियन बहुपद की गणना पुनरावृत्ति द्वारा की जा सकती है
इसी प्रकार, यूलेरियन बहुपद की गणना पुनरावृत्ति द्वारा की जा सकती है
:<math>A_{0}(t) = 1,</math>
:<math>A_{0}(t) = 1,</math>
:<math>A_{n}(t) = A_{n-1}'(t)\cdot t\,(1-t) + A_{n-1}(t)\cdot (1+(n-1)\,t),\text{ for } n > 1.</math>
:<math>A_{n}(t) = A_{n-1}'(t)\cdot t\,(1-t) + A_{n-1}(t)\cdot (1+(n-1)\,t),\text{ for } n > 1.</math>
दूसरे सूत्र को आगमनात्मक रूप में ढाला जा सकता है,
दूसरे सूत्र को धनात्मक रूप में परिवर्तित किया जा सकता है,
:<math>A_{n}(t) = \sum_{k=0}^{n-1} \binom{n}{k} A_{k}(t)\cdot (t-1)^{n-1-k}, \text{ for } n > 1.</math>
:<math>A_{n}(t) = \sum_{k=0}^{n-1} \binom{n}{k} A_{k}(t)\cdot (t-1)^{n-1-k}, \text{ for } n > 1.</math>
निम्नलिखित [[पायथन भाषा]] है।
निम्नलिखित [[पायथन भाषा|पायथन कार्यान्वयन]] है।
<सिंटैक्सहाइलाइट लैंग= सुन्न लाइन= 1 >
आयात गणित # पायथन 3.8
 
def Ank(n, k) -> int:
     
    स्पष्ट सूत्र का उपयोग करके A(n, k) की गणना करें।
     
    डीईएफ़ सारांश(i):
        वापसी (-1) ** i * गणित.comb(n + 1, i) * (k + 1 - i) ** n
    वापसी योग (मानचित्र (सारांश, श्रेणी (k + 1)))


def Anks(n) -> सूची:
<syntaxhighlight lang="abl" line="1">
     
import math  # python 3.8                                                                                         
     n'वें बहुपद A_n(t) के लिए गुणांक सूची।
                                                                                                                     
     
def Ank(n, k) -> int:                                                                                            
     वापसी [1] यदि n == 0 अन्यथा [श्रेणी (n) में k के लिए अंक (n, k)]
    """
     Compute A(n, k) using the explicit formula.                                                                           
    """                                                                                                             
     def summand(i):                                                                                                         
        return (-1) ** i * math.comb(n + 1, i) * (k + 1 - i) ** n                                                       
    return sum(map(summand, range(k + 1)))                                                                          


def eval_बहुपद(coeffs, t):
def Anks(n) -> list:                                                                                                  
     
    """
     बहुपद मूल्यांकन कार्य.
     Coefficient list for the n'th polynomial A_n(t).                                                                    
     
    """                                                                                                                 
     रिटर्न योग (c * t ** k for k, c in enumerate (coeffs))
     return [1] if n == 0 else [Ank(n, k) for k in range(n)]                                                                 


def An(n, t: फ्लोट) -> फ्लोट:
def eval_polynomial(coeffs, t):                                                                                           
     
    """                                                                                                           
     बहुपद A_n(t).
    Polynomial evaluation function.                                                                                 
     
    """                                                                                                           
     वापसी eval_बहुपद(Anks(n), t)
    return sum(c * t ** k for k, c in enumerate(coeffs))                                                                     
                                                                                                                     
def An(n, t: float) -> float:                                                                                          
    """
     Polynomial A_n(t).                                                                                                      
    """                                                                                                                     
     return eval_polynomial(Anks(n), t)                                                                              


# पहले कुछ बहुपद प्रिंट करें
# Print the first few polynomials                                                                                       
सुपर = लैम्ब्डा एन: str(n).translate(str.maketrans( 0123456789, ⁰¹²³⁴⁵⁶⁷⁸⁹ ))
sup = lambda n: str(n).translate(str.maketrans("0123456789", "⁰¹²³⁴⁵⁶⁷⁸⁹"))                                                
उप = लैम्ब्डा एन: str(n).translate(str.maketrans( 0123456789 , ₀₁₂₃₄₅₆₇₈₉ ))
sub = lambda n: str(n).translate(str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉"))                                                


संख्या = 8
NUM = 8                                                                                                            
रेंज में n के लिए (NUM):
for n in range(NUM):                                                                                                  
     print(f A{sub(n)}(t) = + + .join(f {ank} t{sup(k)} for k, ank in enumerate(Anks(n))))
     print(f"A{sub(n)}(t) = " + " + ".join(f"{ank} t{sup(k)}" for k, ank in enumerate(Anks(n))))                            
     # उदा. A₇(t) = 1 t⁰ + 120 t¹ + 1191 t² + 2416 t³ + 1191 t⁴ + 120 t⁵ + 1 t⁶
     # E.g. A₇(t) = 1 t⁰ + 120 t¹ + 1191 t² + 2416 t³ + 1191 t⁴ + 120 t⁵ + 1 t⁶                                          


     #स्वच्छता की जाँच
     # Sanity checks                                                                                                           
     जोर अंक(एन, 1) == 2 ** एन - (एन + 1)
     assert Ank(n, 1) == 2 ** n - (n + 1)                                                                              
     जोर से n == 0 या An(n, 1) == गणित.तथ्यात्मक(n) # कार्डिनैलिटी जांच
     assert n == 0 or An(n, 1) == math.factorial(n) # Cardinality check                                                   
     अल्टरनेटिंग_सम: फ्लोट = योग((-1)**k * अंक(एन, के) / गणित.कॉम्ब(एन - 1, के) रेंज में के के लिए(एन))
     alternating_sum: float = sum((-1)**k * Ank(n, k) / math.comb(n - 1, k) for k in range(n))                            
     एन <2 या एबीएस(अल्टरनेटिंग_सम) <1ई-13 पर जोर दें
     assert n < 2 or abs(alternating_sum) < 1e-13                                                                                      
</सिंटैक्सहाइलाइट>
</syntaxhighlight>


==पहचान==
==पहचान==
किसी परिमित सेट को सीमित रूप से कई छोटे सेटों में विभाजित करने वाली किसी भी संपत्ति के लिए, छोटे सेटों की कार्डिनैलिटी का योग बड़े सेट की कार्डिनैलिटी के बराबर होता है। यूलेरियन संख्याएँ क्रमपरिवर्तन को विभाजित करती हैं <math>n</math> तत्व, इसलिए उनका योग भाज्य के बराबर होता है <math>n!</math>. अर्थात।
किसी परिमित सेट को सीमित रूप से कई छोटे सेटों में विभाजित करने वाली किसी भी संपत्ति के लिए, छोटे सेटों की कार्डिनैलिटी का योग बड़े सेट की कार्डिनैलिटी के समान होता है। यूलेरियन संख्याएँ क्रमपरिवर्तन को विभाजित करती हैं <math>n</math> अवयव, इसलिए उनका योग भाज्य के समान होता है <math>n!</math>. अर्थात।
:<math>\sum_{k=0}^{n-1} A(n,k) = n!, \text{ for }n > 0.</math>
:<math>\sum_{k=0}^{n-1} A(n,k) = n!, \text{ for }n > 0.</math>
साथ ही <math>A(0,0)=0!</math>. रिक्त योग परिपाटी के साथ टकराव से बचने के लिए, केवल प्रमेयों को बताना सुविधाजनक है <math>n>0</math> केवल।
साथ ही <math>A(0,0)=0!</math>. रिक्त योग परिपाटी के साथ टकराव से बचने के लिए, केवल प्रमेयों को बताना सुविधाजनक है <math>n>0</math> केवल।
Line 190: Line 193:
समरूपता गुण का तात्पर्य है:
समरूपता गुण का तात्पर्य है:
:<math>A_n(t) = t^{n-1} A_n(t^{-1}) </math>
:<math>A_n(t) = t^{n-1} A_n(t^{-1}) </math>
यूलेरियन संख्याएँ n के अनुक्रम के लिए [[जनरेटिंग फ़ंक्शन]] में शामिल हैं<sup>द</सुपर>शक्तियाँ:
यूलेरियन संख्याएँ n के अनुक्रम के लिए [[जनरेटिंग फ़ंक्शन|जनरेटिंग फलन]] में सम्मिलित हैं<sup>द</सुपर>शक्तियाँ:
:<math>\sum_{i=1}^\infty i^n x^i = \frac{1}{(1-x)^{n+1}}\sum_{k=0}^n A(n,k)\,x^{k+1} = \frac{x}{(1-x)^{n+1}}A_n(x)</math>
:<math>\sum_{i=1}^\infty i^n x^i = \frac{1}{(1-x)^{n+1}}\sum_{k=0}^n A(n,k)\,x^{k+1} = \frac{x}{(1-x)^{n+1}}A_n(x)</math>
यह भी मानता है कि,
यह भी मानता है कि,
Line 198: Line 201:
==दूसरे क्रम की यूलेरियन संख्याएँ==
==दूसरे क्रम की यूलेरियन संख्याएँ==
[[मल्टीसेट]] का क्रमपरिवर्तन <math display="inline">\{1, 1, 2, 2, \ldots, n, n\}</math> जिसमें यह गुण है कि प्रत्येक k के लिए, क्रमपरिवर्तन में k की दो घटनाओं के बीच दिखाई देने वाली सभी संख्याएँ k से अधिक होती हैं, जिन्हें दोहरे भाज्य संख्या द्वारा गिना जाता है <math display="inline">(2n-1)!!</math>.
[[मल्टीसेट]] का क्रमपरिवर्तन <math display="inline">\{1, 1, 2, 2, \ldots, n, n\}</math> जिसमें यह गुण है कि प्रत्येक k के लिए, क्रमपरिवर्तन में k की दो घटनाओं के बीच दिखाई देने वाली सभी संख्याएँ k से अधिक होती हैं, जिन्हें दोहरे भाज्य संख्या द्वारा गिना जाता है <math display="inline">(2n-1)!!</math>.
दूसरे क्रम की यूलेरियन संख्या, निरूपित <math> \scriptstyle \left\langle \! \left\langle {n \atop m} \right\rangle \! \right\rangle </math>, ऐसे सभी क्रमपरिवर्तनों की संख्या की गणना करता है जिनका बिल्कुल m आरोहण है। उदाहरण के लिए, n = 3 के लिए 15 ऐसे क्रमपरिवर्तन हैं, 1 बिना आरोह के, 8 एकल आरोह के साथ, और 6 दो आरोह के साथ:
दूसरे क्रम की यूलेरियन संख्या, निरूपित <math> \scriptstyle \left\langle \! \left\langle {n \atop m} \right\rangle \! \right\rangle </math>, ऐसे सभी क्रमपरिवर्तनों की संख्या की गणना करता है जिनका बिल्कुल m आरोही है। उदाहरण के लिए, n = 3 के लिए 15 ऐसे क्रमपरिवर्तन हैं, 1 बिना आरोह के, 8 एकल आरोह के साथ, और 6 दो आरोह के साथ:


: 332211,
: 332211,

Revision as of 12:39, 23 July 2023


कॉम्बिनेटरिक्स में, यूलेरियन संख्या 1 से तक की संख्याओं के क्रमपरिवर्तन की संख्या है जिसमें बिल्कुल अवयव पिछले अवयव से बड़े होते हैं ( "आरोही" के साथ क्रमपरिवर्तन)।

लियोनहार्ड यूलर ने अपनी 1755 की पुस्तक कैलकुली डिफरेंशियलिस संस्थाएँ में उनकी और संबंधित बहुपदों की जांच की थी।

1755 से यूलर के कार्य में बहुपदों को वर्तमान में यूलरियन बहुपद के रूप में जाना जाता है, इंस्टीट्यूशन्स कैलकुली डिफरेंशियल, भाग 2, पृष्ठ। 485/6. इन बहुपदों के गुणांकों को यूलेरियन संख्याएँ कहा जाता है।

के लिए अन्य संकेतन और हैं

परिभाषा

यूलेरियन बहुपदों को घातीय जनरेटिंग फलन द्वारा परिभाषित किया गया है

यूलेरियन संख्याओं को यूलेरियन बहुपदों के गुणांक के रूप में परिभाषित किया जा सकता है:

के लिए स्पष्ट सूत्र है[1]


मूलभूत गुण

  • निश्चित के लिए एक एकल क्रमचय है जिसमें 0 आरोह हैं: वास्तव में, सभी के लिए के रूप में। इसमें औपचारिक रूप से संख्याओं का रिक्त संग्रह, सम्मिलित है। इसलिए
  • के लिए स्पष्ट सूत्र का तात्पर्य है, में एक अनुक्रम जो पढ़ता है
  • आरोही के साथ एक क्रमपरिवर्तन को पूरी तरह उलटने से एक और क्रमपरिवर्तन बनता है जिसमें आरोही होते हैं। इसलिए तो एक एकल क्रमपरिवर्तन भी है जिसमें आरोही है, अर्थात् आरोही क्रमपरिवर्तन अतः भी के समान है
  • एक लविश ऊपरी सीमा है। अभी चर्चा की गई सीमाओं के बीच, मान से अधिक है
  • के लिए, मान औपचारिक रूप से शून्य हैं, जिसका अर्थ है कि के ऊपर कई रकम केवल तक के ऊपरी सूचकांक के साथ लिखी जा सकती हैं। इसका यह भी अर्थ है कि बहुपद वास्तव में के लिए डिग्री हैं

त्रिकोणीय सरणी में संख्याओं के सारणीकरण को यूलर त्रिकोण या यूलर का त्रिकोण कहा जाता है। यह पास्कल के त्रिकोण के साथ कुछ सामान्य विशेषताएं साझा करता है। (sequence A008292 in the OEIS) के लिए हैं:

 k
n 
0 1 2 3 4 5 6 7 8
0 1
1 1
2 1 1
3 1 4 1
4 1 11 11 1
5 1 26 66 26 1
6 1 57 302 302 57 1
7 1 120 1191 2416 1191 120 1
8 1 247 4293 15619 15619 4293 247 1
9 1 502 14608 88234 156190 88234 14608 502 1


गणना

, के बड़े मानों की गणना पुनरावर्ती सूत्र का उपयोग करके भी की जा सकती है

इस सूत्र को संयोजक परिभाषा से प्रेरित किया जा सकता है और इस प्रकार यह सिद्धांत के लिए प्राकृतिक प्रारंभिक बिंदु के रूप में कार्य करता है।

और , के छोटे मानों के लिए, के मानों की गणना हाथ से की जा सकती है। उदाहरण के लिए

n k क्रमपरिवर्तन A(n, k)
1 0 (1) A(1,0) = 1
2 0 (2, 1) A(2,0) = 1
1 (1, 2) A(2,1) = 1
3 0 (3, 2, 1) A(3,0) = 1
1 (1, 3, 2), (2, 1, 3), (2, 3, 1) and (3, 1, 2) A(3,1) = 4
2 (1, 2, 3) A(3,2) = 1

पुनरावृत्ति को उदाहरण पर प्रयुक्त करने पर, हम पा सकते हैं

इसी प्रकार, यूलेरियन बहुपद की गणना पुनरावृत्ति द्वारा की जा सकती है

दूसरे सूत्र को धनात्मक रूप में परिवर्तित किया जा सकता है,

निम्नलिखित पायथन कार्यान्वयन है।

import math  # python 3.8                                                                                           
                                                                                                                      
def Ank(n, k) -> int:                                                                                             
    """
    Compute A(n, k) using the explicit formula.                                                                             
    """                                                                                                               
    def summand(i):                                                                                                          
        return (-1) ** i * math.comb(n + 1, i) * (k + 1 - i) ** n                                                        
    return sum(map(summand, range(k + 1)))                                                                           

def Anks(n) -> list:                                                                                                    
    """
    Coefficient list for the n'th polynomial A_n(t).                                                                      
    """                                                                                                                   
    return [1] if n == 0 else [Ank(n, k) for k in range(n)]                                                                  

def eval_polynomial(coeffs, t):                                                                                             
    """                                                                                                             
    Polynomial evaluation function.                                                                                   
    """                                                                                                             
    return sum(c * t ** k for k, c in enumerate(coeffs))                                                                      
                                                                                                                      
def An(n, t: float) -> float:                                                                                            
    """
    Polynomial A_n(t).                                                                                                       
    """                                                                                                                       
    return eval_polynomial(Anks(n), t)                                                                                

# Print the first few polynomials                                                                                         
sup = lambda n: str(n).translate(str.maketrans("0123456789", "⁰¹²³⁴⁵⁶⁷⁸⁹"))                                                 
sub = lambda n: str(n).translate(str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉"))                                                  

NUM = 8                                                                                                              
for n in range(NUM):                                                                                                   
    print(f"A{sub(n)}(t) = " + " + ".join(f"{ank} t{sup(k)}" for k, ank in enumerate(Anks(n))))                             
    # E.g. A₇(t) = 1 t⁰ + 120  + 1191  + 2416  + 1191 t⁴ + 120 t⁵ + 1 t⁶                                            

    # Sanity checks                                                                                                            
    assert Ank(n, 1) == 2 ** n - (n + 1)                                                                                
    assert n == 0 or An(n, 1) == math.factorial(n)  # Cardinality check                                                     
    alternating_sum: float = sum((-1)**k * Ank(n, k) / math.comb(n - 1, k) for k in range(n))                             
    assert n < 2 or abs(alternating_sum) < 1e-13

पहचान

किसी परिमित सेट को सीमित रूप से कई छोटे सेटों में विभाजित करने वाली किसी भी संपत्ति के लिए, छोटे सेटों की कार्डिनैलिटी का योग बड़े सेट की कार्डिनैलिटी के समान होता है। यूलेरियन संख्याएँ क्रमपरिवर्तन को विभाजित करती हैं अवयव, इसलिए उनका योग भाज्य के समान होता है . अर्थात।

साथ ही . रिक्त योग परिपाटी के साथ टकराव से बचने के लिए, केवल प्रमेयों को बताना सुविधाजनक है केवल।

एक निश्चित कार्य के लिए, अधिक सामान्यतः अंतराल पर अभिन्न [2]

वर्पिट्ज़की की पहचान[3] एक्सप्रेस द्विपद गुणांकों के साथ यूलेरियन संख्याओं के रैखिक संयोजन के रूप में:

इससे यह निष्कर्ष निकलता है


प्रत्यावर्ती योगों वाले सूत्र

के निश्चित मान के लिए यूलेरियन संख्याओं का प्रत्यावर्ती योगबर्नौली संख्या से संबंधित है

आगे,

और


बहुपदों से जुड़े सूत्र

समरूपता गुण का तात्पर्य है:

यूलेरियन संख्याएँ n के अनुक्रम के लिए जनरेटिंग फलन में सम्मिलित हैंद</सुपर>शक्तियाँ:

यह भी मानता है कि,


दूसरे क्रम की यूलेरियन संख्याएँ

मल्टीसेट का क्रमपरिवर्तन जिसमें यह गुण है कि प्रत्येक k के लिए, क्रमपरिवर्तन में k की दो घटनाओं के बीच दिखाई देने वाली सभी संख्याएँ k से अधिक होती हैं, जिन्हें दोहरे भाज्य संख्या द्वारा गिना जाता है . दूसरे क्रम की यूलेरियन संख्या, निरूपित , ऐसे सभी क्रमपरिवर्तनों की संख्या की गणना करता है जिनका बिल्कुल m आरोही है। उदाहरण के लिए, n = 3 के लिए 15 ऐसे क्रमपरिवर्तन हैं, 1 बिना आरोह के, 8 एकल आरोह के साथ, और 6 दो आरोह के साथ:

332211,
221133, 221331, 223311, 233211, 113322, 133221, 331122, 331221,
112233, 122133, 112332, 123321, 133122, 122331।

दूसरे क्रम की यूलेरियन संख्याएँ पुनरावृत्ति संबंध को संतुष्ट करती हैं, जो उपरोक्त परिभाषा से सीधे अनुसरण करती है:

एन = 0 के लिए प्रारंभिक शर्त के साथ, इवरसन ब्रैकेट नोटेशन में व्यक्त किया गया:

तदनुसार, दूसरे क्रम का यूलेरियन बहुपद, यहाँ P को दर्शाता हैn (उनके लिए कोई मानक संकेतन मौजूद नहीं है) हैं

और उपरोक्त पुनरावृत्ति संबंधों को अनुक्रम पी के लिए पुनरावृत्ति संबंध में अनुवादित किया गया हैn(एक्स):

प्रारंभिक शर्त के साथ . बाद की पुनरावृत्ति को एकीकृत कारक के माध्यम से कुछ हद तक अधिक संक्षिप्त रूप में लिखा जा सकता है:

ताकि तर्कसंगत कार्य हो सके

एक साधारण स्वायत्त पुनरावृत्ति को संतुष्ट करता है:

जहाँ से दूसरे क्रम के यूलेरियन बहुपद प्राप्त होते हैं , और उनके गुणांक के रूप में दूसरे क्रम की यूलेरियन संख्याएँ।

निम्न तालिका पहले कुछ दूसरे क्रम के यूलेरियन संख्याओं को प्रदर्शित करती है:

 k
n 
0 1 2 3 4 5 6 7 8
0 1
1 1
2 1 2
3 1 8 6
4 1 22 58 24
5 1 52 328 444 120
6 1 114 1452 4400 3708 720
7 1 240 5610 32120 58140 33984 5040
8 1 494 19950 195800 644020 785304 341136 40320
9 1 1004 67260 1062500 5765500 12440064 11026296 3733920 362880

n-वीं पंक्ति का योग, जो मान भी है , है .

दूसरे क्रम के यूलेरियन संख्याओं का अनुक्रमण तीन स्वादों में आता है:

  • (sequence A008517 in the OEIS) रिओर्डन और कॉमटेट का अनुसरण करते हुए,
  • (sequence A201637 in the OEIS) ग्राहम, नुथ और पाटश्निक का अनुसरण करते हुए,
  • (sequence A340556 in the OEIS), गेसल और स्टेनली की परिभाषा का विस्तार।

संदर्भ

  • Eulerus, Leonardus [Leonhard Euler] (1755). Institutiones calculi differentialis cum eius usu in analysi finitorum ac doctrina serierum [Foundations of differential calculus, with applications to finite analysis and series]. Academia imperialis scientiarum Petropolitana; Berolini: Officina Michaelis.
  • Carlitz, L. (1959). "Eulerian Numbers and polynomials". Math. Mag. 32 (5): 247–260. doi:10.2307/3029225. JSTOR 3029225.
  • Gould, H. W. (1978). "Evaluation of sums of convolved powers using Stirling and Eulerian Numbers". Fib. Quart. 16 (6): 488–497.
  • Desarmenien, Jacques; Foata, Dominique (1992). "The signed Eulerian numbers". Discrete Math. 99 (1–3): 49–58. doi:10.1016/0012-365X(92)90364-L.
  • Lesieur, Leonce; Nicolas, Jean-Louis (1992). "On the Eulerian Numbers M=max (A(n,k))". Europ. J. Combinat. 13 (5): 379–399. doi:10.1016/S0195-6698(05)80018-6.
  • Butzer, P. L.; Hauss, M. (1993). "Eulerian numbers with fractional order parameters". Aequationes Mathematicae. 46 (1–2): 119–142. doi:10.1007/bf01834003. S2CID 121868847.
  • Koutras, M.V. (1994). "Eulerian numbers associated with sequences of polynomials". Fib. Quart. 32 (1): 44.
  • Graham; Knuth; Patashnik (1994). Concrete Mathematics: A Foundation for Computer Science (2nd ed.). Addison-Wesley. pp. 267–272.
  • Hsu, Leetsch C.; Jau-Shyong Shiue, Peter (1999). "On certain summation problems and generalizations of Eulerian polynomials and numbers". Discrete Math. 204 (1–3): 237–247. doi:10.1016/S0012-365X(98)00379-3.
  • Boyadzhiev, Khristo N. (2007). "Apostol-Bernoulli functions, derivative polynomials and Eulerian polynomials". arXiv:0710.1124 [math.CA].
  • Petersen, T. Kyle (2015). Eulerian Numbers. Birkhäuser Advanced Texts Basler Lehrbücher. Birkhäuser. pp. 3–18. doi:10.1007/978-1-4939-3091-3_1. ISBN 978-1-4939-3090-6.


उद्धरण

  1. (L. Comtet 1974, p. 243)
  2. Exercise 6.65 in Concrete Mathematics by Graham, Knuth and Patashnik.
  3. Worpitzky, J. (1883). "Studien über die Bernoullischen und Eulerschen Zahlen". Journal für die reine und angewandte Mathematik. 94: 203–232.


बाहरी संबंध