【欧拉猜想】是否有无穷多个不可约分的正整数解

作者: 光剑书架上的书 | 来源:发表于2018-05-04 01:59 被阅读123次

证明或否定: 不定方程 a^4 + b^4 + c^4 = d^4 (*)有正整数解。

形如

a^3+b^3=c^3
a^4+b^4+c^4=d^4
a^5+b^5+c^5+d^5=e^5
……

这样的不定方程，是否有正整数解？

这类问题被称为：欧拉猜想, 其中4和5的都有正整数解, 3的被证明了无整数解,其它的都还不知道。

欧拉猜想

欧拉猜想是欧拉提出的对费马最后定理引出的猜想，欧拉猜想每个大于2的整数n，任何n- 1个正整数的n次幂的和都不是某正整数的n次幂，1966年L. J. Lander和T. R. Parkin推翻了这一猜想。

这猜想在1966年被L. J. Lander和T. R. Parkin推翻。他们找出n= 5的反例：

27^5+ 84^5+ 110^5+ 133^5= 144^5

我们可以使用 Kotlin 代码花差不多3min 的时间，算出来这组数字来：

    @Test
    fun test3() {
        var list1 = arrayListOf<Pair<Long, String>>()
        var list2 = arrayListOf<Pair<Long, String>>()

        val start1 = System.currentTimeMillis()
        // 假设： a<b<c<d, 肯定有： e > {a,b,c,d}
        for (a in 1..200L) {
            for (b in a..200L) {
                for (c in b..200L) {
                    Propositions.f3(a, b, c)
                    list1.add(Pair(Propositions.f3(a, b, c), "a=$a,b=$b,c=$c"))
                }
            }
        }
        val end1 = System.currentTimeMillis()
        println("Using Time1: ${(end1 - start1)} ms")
        println("list1.size=${list1.size}")

        val start2 = System.currentTimeMillis()
        for (d in 1..200L) {
            (d..200L).mapTo(list2) { Pair(Propositions.f4(it, d), "e=$it,d=$d") }
        }
        val end2 = System.currentTimeMillis()
        println("Using Time2: ${(end2 - start2)} ms")
        println("list2.size=${list2.size}")

        /*
        首先想到的，遍历所有元素，穷举判断；更进一层：平均切割 List，每一段开启1个线程计算。
        val start3 = System.currentTimeMillis()
        loop@ for (x in list2) {
            if (list1.contains(x)) {
                println("x=$x")
                break@loop
            }
        }
        val end3 = System.currentTimeMillis()
        println("Using Time3: ${(end3 - start3)} ms")
        */

        val start3 = System.currentTimeMillis()
        var list1n = arrayListOf<List<Pair<Long, String>>>()
        val segment = 10_0000
        val step = list1.size / segment
        for (i in 1..segment) {
            var listi = arrayListOf<Pair<Long, String>>()
            for (j in ((i - 1) * step)..(i * step - 1)) {
                listi.add(list1[j])
            }
            list1n.add(listi)
        }
        println("list1n.size=${list1n.size}")
        val end3 = System.currentTimeMillis()
        println("Using Time3: ${(end3 - start3)} ms")

        val start4 = System.currentTimeMillis()
        var threadList = arrayListOf<Thread>()
        list1n.forEach {
            threadList.add(Thread {
                for (x in list2) {
                    it.filter { x.first == it.first }
                            .forEach { println("$x,$it") }
                }
            })
        }
        println("threadList.size=${threadList.size}")
        for (thread in threadList) {
            thread.start()
            thread.join()
        }
        val end4 = System.currentTimeMillis()
        println("Using Time4: ${(end4 - start4)} ms")
    }

其中，f3,f4函数定义如下：

    fun f3(a: Long, b: Long, c: Long): Long {
        return a * a * a * a * a +
                b * b * b * b * b +
                c * c * c * c * c
    }

    fun f4(e: Long, d: Long): Long {
        return e * e * e * e * e - d * d * d * d * d
    }

运行的结果是：

Using Time1: 3247 ms
list1.size=1353400
Using Time2: 19 ms
list2.size=20100
list1n.size=100000
Using Time3: 72 ms
threadList.size=100000
(20301568331, e=144,d=133),(20301568331, a=27,b=84,c=110)
(45812264224, e=144,d=110),(45812264224, a=27,b=84,c=133)
(57735244800, e=144,d=84),(57735244800, a=27,b=110,c=133)
(61903015317, e=144,d=27),(61903015317, a=84,b=110,c=133)
Using Time4: 238898 ms

也就是（27，84，110，133，144）。

但是，当数字非常的大的时候，这种单机遍历循环，恐怕在有限时间内，难以胜任。这个时候，也许超大规模并行网络计算机、量子计算机会解决这种问题。但是，数字是无穷大的本身这件事情，就非常奥妙无穷了。

1988年，Noam Elkies找出一个对n= 4制造反例的方法。他给出的反例中最小的如下：

2682440^4+ 15365639^4+ 18796760^4= 20615673^4

Roger Frye以Elkies的技巧用电脑直接搜索，找出n= 4时最小的反例：

95800^4+ 217519^4+ 414560^4= 422481^4

同时，Noam Elkies 也证明了这个方程有无穷多个解 (椭圆曲线理论)。自此，欧拉猜想也有了结论。

现在仍未知道当n> 5时的反例。

其实这样的例子并不少，主要是当时提出这个猜想的时候，推翻猜想的反例却远远超出人类自身的计算能力，就必须得依靠计算机的大量计算，才能判断到时是对是错。

我们今天先从最有名的欧拉来讲起，作为中世纪著名的数学家，欧拉一生的创作极为丰富，只要不是艺术类和语言类的同学，相信都对欧拉念念不忘（有一些痛，一辈子都忘不了）。

欧拉是一些产出极为丰富的数学家，他也曾提出过这么一个猜想（欧拉猜想）：

image.png

当欧拉提出这个猜想的时候，声称该方程没有正整数解。

在这个猜想提出来之后，欧拉并没有证实是否正确就已离去，而在欧拉离世后的两百多年里，大批数学家都尝试去解开这道谜题，但并没有人成功，谁也无法证明欧拉猜想是对的，同时也无法举一个例子来证明这个是错误的。

即便在计算机出现后，由于算力不足，依旧没办法找到一个反例来证明欧拉猜想是错的，而这似乎也让人们更加相信欧拉猜想是正确的。

伴随着计算算力的提升，欧拉猜想正式被证伪：

1988年，哈佛大学的Noam Elkies在一次计算中，发现了这个等式：

image.png

此时，这也就正式宣传欧拉猜想是错误的。但思想的堤坝有了出口，思维便一发不可收拾，在随后的深入研究中，Noam Elkies发现该方程存在无穷多个正数解。

尽管欧拉猜想两百多年来屹立不倒，但最终还是被推翻了，两百多年来，各路豪强用尽脑力也无法破解的谜题，终究被计算机所打破，而这也正入Simon Singh 所著的《费马大定理：一个困惑了世间智者358年的谜》中的那句话：“这里的教训是，你不能通过只对前一百万个数字来证明一个猜想对所有的数都成立。”

其实，数学上的证伪和证实都是一个非常有趣的过程，我们不断的用例子来证明这个猜想是对的，到后来你会发现，即便是一百万个对的例子却敌不过一个反例。

这也和我们的人生一样啊！

【参考阅读】

世界三大猜想

费马猜想

【欧拉猜想】是否有无穷多个不可约分的正整数解

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

计算机中的数学

编程笔记