零知识证明-基础数学(二）

零知识证明(Zero—Knowledge Proof)，是指一种密码学工具，允许互不信任的通信双方之间证明某个命题的有效性，同时不泄露任何额外信息

导数、偏导数 ,互质数，费马小定理，欧拉定理
1 导数
导数是微积分学中的重要概念，表示函数在某一点处的变化率。一元函数f(x)在点x处的导数f’(x)表示当自变量x在x处增加一个很小的量Δx时，函数值f(x)相应地增加的量Δy，即f’(x)=lim(Δx->0)(Δy/Δx)。导数是函数在某一点处的局部性质，可以刻画函数的斜率、单调性、极值、凹凸性等

f(x)= x²
函数x² 在 x = 3 处的切线斜率是 6

导数公式 （网上抄的）

ln10=loge 10， e=2.71828 ln10≈2.303

2 偏导数
多元函数降维时候的变化，比如二元函数固定y，只让x单独变化，从而看成是关于x的一元函数的变化来研究。
f(x,y)=x^2+y
x编导
y编导 = 1
3 互质数
质因数：一般地说，一个数的因数是质数，就叫做这个数的质因数。
18=2×3×3
互质数：两个或几个自然数，当它们的最大公约数是1的时候，这两个或几个数，就叫做互质数（也叫互素数）。
5和7，4和11，8和9，7、11和15，12、20和35

4 费马小定理
如果p是一个质数,而整数a不是p的倍数，则有a^p-1≡1（mod p） (就是 a的p-1次数mod p 等于1)
eg:p=7 a=20 20^7-1= 64000000 64000000 mod 7 = 1 //用计算器算下
a=18 18^7-1 = 34012224 34012224 mod 7 = 1
a=9 9^7-1 = 531441 531441 mod 7 = 1
a=12 12^7-1 = 2985984 2985984 mod 7 = 1

code

package main

import (
	"fmt"
	"strconv"
)

func main()  {
	stringnum := ""
	fmt.Printf("please input one prime number：")
	if _,err := fmt.Scan(&stringnum);err !=nil{
		fmt.Printf("input error")
		return
	}
	primenum,err1 := strconv.Atoi(stringnum)
	if err1 !=nil{
		fmt.Printf("input error")
		return
	}
	fmt.Printf("prime number:%v \n",primenum)
	for ;; {

		fmt.Printf("please input one integer：")
		if _,err := fmt.Scan(&stringnum);err !=nil{
			fmt.Printf("input error")
			break

		}
		intnum,err2:= strconv.Atoi(stringnum)
		if err2 !=nil{
			fmt.Printf("input error")
			break
		}
		fmt.Printf("%v mod %v =%v \n",intnum,primenum,intnum%primenum)
	}

	fmt.Printf("ready exit \n")

}

5欧拉定理
1>欧拉函数 记欧拉函数 φ(n) 为不超过 n 且与 n互质的数的个数
eg:φ(8)=4，因为1,3,5,7均和8互质(互质数：两个或几个自然数，当它们的最大公约数是1的时候)
2> 既约剩余系（简化剩余系S）
定义：说 S是模 n的简化剩余系，是指 S是由 φ(n)个数组成的集合,其中集合中的数都与 n互质且两两模 n不同余(就是余数不重复)
eg:模5的一个简化剩余系是1，2，3，4，
模7的一个简化剩余系是 1,2,3,4,5,6
模10的一个简化剩余系是1，3，7，9，
模18的一个简化剩余系是1，5，7，11，13，17
3>引理
<1>如果n为某一个素数p，则φ§=p-1 见上面的5,7 简化剩余系
<2>如果n=p*g, p,g 为素数 φ(n) =φ§*φ(g)
φ(15) 剩余系 1,2,4,7,8,11,13,14 一共8个
φ(15) = φ(3) * φ(5) = (3-1) * (5-1) = 2 * 4 = 8

<3>如果n为某一个素数p的幂次，那么φ(p^a^)=(p-1)*p^(a-1)^
  eg:p=7 a=2
    φ(7^2^) = (7-1)* 7^2-1^
   φ(7^2^) =  φ(49)   简化剩余系  p-1  个数减去49内 7的倍数的个数 = 49-1  减去 6{7,14,21,28,35,42} = 49-1-6 =42
   (7-1)  * 7^2-1^   等于  6* 7 = 42

<4>: n=p^a1p^a2 … p^ak φ(n)= n ∏^k i=1 (1- 1/pi)

公式难打 抄下别人的

eg: n= 120 = 2³ * 3 * 5
φ(120)= 120*(1- 1/2) * (1-1/3)* (1-1/5) = 120 * 1/2 * 2/3 * 4/5 =60 * 2/3 * 4/5 = 40 * 4/5=32

参考 https://zhuanlan.zhihu.com/p/536214853
最大公约数（greatest common divisor，简写为gcd)
定理1
设m是正整数。整数 a满足gcd(a,m)=1.若x 遍历模m的一个既约剩余系，则 ax也遍历模 m 的一个简化剩余系
eg: m=5 a=8
gcd(8,5) = 1
mod5 简化剩余系 1,2,3,4
x 为 简化剩余系 1,2,3,4
ax = 8,16,24,32 mod5 3,1,4,2 = 1,2,3,4 跟mod5 的简化剩余系 一样
定理 2
设m1,m2是两个互质的正整数。如果 x遍历模 m1的一个既约剩余系，
y遍历模m2的一个既约剩余系，则m1 y + m2 x 遍历模 m1 * m2 的一个简化剩余系**
eg: 互质数：两个或几个自然数，当它们的最大公约数是1的时候
m1 = 5 m2=8 40= 5 * 8 = 5 * 2³
mod5 简化剩余系 1,2,3,4
mod8 简化剩余系 1,3,5,7
mod40 简化剩余系 1,3,7,9,11,13,17,19,21,23,27,29,31,33,37,39 一共 16个
x = 1,2,3,4
y = 1,3,5,7
5* y + 8 * x = 5 * (1,3,5,7) +8 *(1,2,3,4) = （5,15,25,35） + （8,16,24,32） =
相当于做笛卡尔积
为什么呢，当 y=1时， x = (1,2,3,4) 有4种，而·y 为(1,3,5,7) 所以 4 * 4 =16

4>欧几里得算法 参考 https://blog.csdn.net/2201_75314884/article/details/131206814
欧几里得算法又称为辗转相除法，是指用于计算两个非负整数a，b的最大公约数。
两个整数的最大公约数是指能够同时整除它们的最大的正整数。
辗转相除法能够实现效果主要基于以下原理：两个整数的最大公约数等于其中较小的数和两数相除余数的最大公约数。
原理用用公式表示为：gcd(a,b) = gcd(b,a mod b)。
其中gcd为最大公约数的英文greatest common divisor的缩写
mod相当于取模运算符%
最大公约数：两个或多个整数共有的最大公约数，用于表示这些整数之间的最大公共因子。
gcd(a,0) = a 注意 a与零的 结果是 a

eg: 求 gcd(8,20) =
1>先用小数字当公约数 ，如果不是 大数 = 大数%小数 (重复这步)
2>如果是 完成
先用8 作为公约数 发现 20有余数
所以 8 不可以
20%8 = 4
用4 作为公约数
8%4 = 0 20%4=0 OK 4是最大公约数

代码实现

package main

import (
	"fmt"
)

// n <= m 调佣前 先检查
func gcd(n, m int32) int32{

	if m	%	n == 0 {
		return  n
	}
	return  gcd(m%n,n)
}

func main()  {
	numa,numb := 0,0

	for ;;{
		fmt.Printf("please intpu numbera and numberb:")
		if _,err := fmt.Scan(&numa,&numb);err !=nil{
			fmt.Printf("input error,please input interger \n")
			continue
		}
		if numa <= 0 || numb <= 0 {
			fmt.Printf("input error and exit")
			break
		}
		if numa == numb {
			fmt.Printf("gcd(%v,%v)=%v \n",numa,numb,numb)
			continue
		}
		if numa ==1  || numb ==1 {
			fmt.Printf("gcd(%v,%v)=%v \n",numa,numb,1)
			continue
		}

		if numa > numb { //交换 保证  numa < numb
			t := numb
			numb = numa
			numa = t
		}

		fmt.Printf("gcd(%v,%v)=%v \n",numa,numb,gcd(int32(numa),int32(numb)))

	}

	fmt.Printf("end \n")
}

5>mod逆元
逆元：在群中存在ab=e（其中为群的某个运算，e为此运算的单位元），则b为a的逆元
mod逆元：定义为1=a*b(mod m)，则b为a的模m逆元
(1)求法1 费马小定理(Fermat’s Little Theorem)
费马小定理：若p为素数，则有ap−1≡1(modp) ;
a^p−2 ∗ a≡1(modp) ;
a^p−2 就是a在mod p意义下的逆元。
eg: a=4 p=7 我们知道 是 逆元 = 2
4^7-2 = 4⁵ = 1024 mod 7 = 2

(2)判断素数 威尔逊定理(Wilson’s Theorem)
威尔逊定理如下
如果p 为素数那么( p − 1 ) ! ≡ − 1 ( m o d p )
判断
eg: p=7 6!=65432*1 = 720 = 720 mod 7 = 6 -1 mod7 = (1+7)mod7 = 6

（3）求法2 扩展欧几里得
ax+by = gcd(a,b)
当b 为 素数时， ax ≡ 1 mod b

package main

import "fmt"

//求mod 逆元
//暴力求解  大数不推荐
func modInverse( a  int, mod int)int{

	for x := 1; x <mod ; x++{
		if  (a % mod) * (x % mod) % mod  == 1 {
			return  x
		}
	}
	return 0
}


func  exgcd(a,m int,x *int ,y *int )int{
	//fmt.Printf("a=%v b=%v %v %v \n",a,b,*x,*y)
	if m == 0 {
		*x=1
		*y=0
		return a
	}
	x1,y1:= 0,0
	g := exgcd(m,a%m,&x1,&y1)
	*x = y1
	*y = x1 -(a/m)*y1
	return  g
}


//g 是 a 和 n 的最大公约数
// ax≡g(modn) g==1 有逆元
//当 a、n 互质时，g = 1 g = 1g=1，此时 x 就是解。当 g ≠ 1 , a 关于模 n 的模逆元不存在
//两数互质的充分必要条件是两数的最大公约数为 1
func inv(a,m int )int  {
	 x,y := 0,0
	g := exgcd(a,m,&x,&y)
	if g != 1{
		fmt.Printf("inv not exist \n")
		return -1
	}
	if  x < 0 {
		x += m
	}
	return  x % m

}


func main()  {
	numa,nummod := 0,0

	for ;;{
		fmt.Printf("please intpu number and modnumber:")
		if _,err := fmt.Scan(&numa,&nummod);err !=nil{
			fmt.Printf("input error,please input interger \n")
			continue
		}
		if numa <= 0 || nummod <= 0 {
			fmt.Printf("input error and exit")
			break
		}

		fmt.Printf("mod inv(%v,mod %v)=%v \n",numa,nummod,inv(numa,nummod))

	}

	fmt.Printf("end \n")
}

手算 逆元
参考 https://blog.csdn.net/Drifter_Galaxy/article/details/107593707

(2)欧拉定理
欧拉定理：若a、b互素，则有 a ^φ(b) ≡1(mod b) (费马小定理的一般形式)
a^φ(b)-1 ∗ a≡1(mod b)
a^φ(b)−1 就是a在mod b意义下的逆元。
求5模26的逆元 φ(b) 表示 简化剩余集 元素个数


6:如果觉得有用，麻烦点个赞，加个收藏