大家都知道《Mastering bitcoin》这本书，在看完《Mastering bitcoin》之后，这里推荐Programmingbitcoin, 具体用代码来实现Bitcoin，可以让我们更好的理解Bitcoin和Blockchain。
https://github.com/jimmysong/programmingbitcoin

Programming-bitcoin

Preface

在一个fundamental的level teach you bitcoin。

Coding all the components is necessary for a bitcoin library。

ch01

Finite Fields

有时候学一个东西会lead you have to learn another, which in turn 导致你原来的事情还没理解。

这里本书跟王爽的汇编语言一样，先独立学习一个知识，切断知识间的联系。

Start with the basic math，先从Finite fields和ECC开始。

Elliptic curve cryptography gives us:

signing
verification algorithms

这些是一个Transaction的基石，而Trasaction是Bitcoin中价值转移的一个基本单位，所以ECC其实就是Bitcoin的核心。学习Finite fields和ECC能够让我们打下良好的概念基础。

Learning Higher-Level Math

数学让人感到恐惧，但是学习Finite Fields其实并不需要比代数更多的数学知识。

这一章和后面两章可能会让觉得无聊和不相关，但是希望你能够坚持下去。

The fundamental不仅能让你更好的理解Bitcoin，后面的Schnorr signatures、confidential transactions和其他最新的技术也更容易理解。

Finite Field Definition

数学上，一个Finite Field被定义为一个有限的集合，其中的两个操作+和*满足以下条件：

closed 集合中的元素a和b经过操作后得到的元素依然是集合中的
单位元 0 + a = a; 1 * a = a
逆元 a + (-a) = 0，相似的有乘法逆元

很好理解。然后定义一个数字P，which is 这个集合的规模有多大，叫做order of the set。

比如{0, 1, 2}就不满足1，2 + 2 = 4，不在集合中。当然我们可以自己定义一套乘法和加法来使这个集合是满足上面三条定义的。

the key concept here is that we can define addition and subtraction differently than the addition and subtraction you are familiar with.

2其实意味着单位元的性质，set中要有0和1。另外，利用3我们可以根据加法和乘法定义出减法和乘法。

Defining Finite Sets

In math notation the finite field set looks like this:

Fp = {0, 1, 2, ... p–1}（这些数字不一定是传统的数字，只是代表元素）

一些例子：

F11 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
F17= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
F983= {0, 1, 2, ... 982}

可以看到这里列举的P都是素数，事实上我们只关心素数order的Finite Sets。

Constructing a Finite Field in Python

在Python中，我们可以定义一个class FieldElement来代表有限域中的一个元素。

很简单，可以看到override了这个类的==操作符，只有当num和set的prime都相等时，才是相等的元素。

下面就是讲述各种Operation和Python的实现，可以参考原文。

大量的用了取模操作，比如加法，如果想让这个有限域上的加法是closed，我们就可以相加后取模，这样得到的结果必然是在域中的。

完整的代码如下：

class FieldElement:

    def __init__(self, num, prime):
        if num >= prime or num < 0:  # <1>
            error = 'Num {} not in field range 0 to {}'.format(
                num, prime - 1)
            raise ValueError(error)
        self.num = num  # <2>
        self.prime = prime

    def __repr__(self):
        return 'FieldElement_{}({})'.format(self.prime, self.num)

    def __eq__(self, other):
        if other is None:
            return False
        return self.num == other.num and self.prime == other.prime  # <3>
    # end::source1[]

    def __ne__(self, other):
        # this should be the inverse of the == operator
        if other is None:
            return False
        return not (self == other)

    # tag::source2[]
    def __add__(self, other):
        if self.prime != other.prime:  # <1>
            raise TypeError('Cannot add two numbers in different Fields')
        num = (self.num + other.num) % self.prime  # <2>
        return self.__class__(num, self.prime)  # <3>
    # end::source2[]

    def __sub__(self, other):
        if self.prime != other.prime:
            raise TypeError('Cannot subtract two numbers in different Fields')
        # self.num and other.num are the actual values
        # self.prime is what we need to mod against
        # We return an element of the same class
        num = (self.num - other.num) % self.prime
        return self.__class__(num, self.prime)

    def __mul__(self, other):
        if self.prime != other.prime:
            raise TypeError('Cannot multiply two numbers in different Fields')
        # self.num and other.num are the actual values
        # self.prime is what we need to mod against
        # We return an element of the same class
        num = (self.num * other.num) % self.prime
        return self.__class__(num, self.prime)

    # tag::source3[]
    def __pow__(self, exponent):
        n = exponent % (self.prime - 1)  # <1>
        num = pow(self.num, n, self.prime)
        return self.__class__(num, self.prime)
    # end::source3[]

    def __truediv__(self, other):
        if self.prime != other.prime:
            raise TypeError('Cannot divide two numbers in different Fields')
        # use fermat's little theorem:
        # self.num**(p-1) % p == 1
        # this means:
        # 1/n == pow(n, p-2, p)
        # We return an element of the same class
        num = self.num * pow(other.num, self.prime - 2, self.prime) % self.prime
        return self.__class__(num, self.prime)

Conclusion

本章学习了Finite Fields，并且用Python实现了。我们将在ECC中用到Finite Fields，下面我们将讲述ECC的另一个组件：elliptic curves。

参考

https://github.com/jimmysong/programmingbitcoin/blob/master/ch01.asciidoc

Programmingbitcoin-note1