精华内容
下载资源
问答
  • 有限域上环多项式的显式分解
  • 关于有限域多项式因式分解,和不错的,对有限域多项式概括很完整
  • 有限域多项式的多发送者认证码的新构造
  • 有限域的本原多项式

    千次阅读 2020-01-02 09:07:27
    查询有限域上的本原多项式: http://wims.unice.fr/wims/cn_tool~algebra~primpoly.cn.html
    展开全文
  • 对计算有限域上切比雪夫多项式的特征多项式算法(CPA)进行了改进,以提高算法的执行速度。首先用蒙哥马利模乘代替原有算法中的普通模乘运算,从而降低单次模乘运算的平均运行时间;其次对蒙哥马利模平方运算的算法流程...
  • 构建一阶谓词逻辑和有限域多项式方程的同构 基于命题逻辑的布尔可满足SAT存在描述能力弱、抽象层次低、求解复杂度高等问题,而基于一阶逻辑的可满足性模理论SMT(或称之为FOLMS问题:一阶逻辑的可满足性问题)采用...

    构建一阶谓词逻辑和有限域上多项式方程的同构

    基于命题逻辑的布尔可满足SAT存在描述能力弱、抽象层次低、求解复杂度高等问题,而基于一阶逻辑的可满足性模理论SMT(或称之为FOLMS问题:一阶逻辑的可满足性问题)采用高层建模语言,表达能力更强,更接近于字级设计, 避免将问题转化到位级求解,在硬件RTL级验证、程序验证与实时系统验证等领域得到了广泛应用;因此寻找一种一阶谓词逻辑和有限域上多项式方程的同构,将SMT问题和有限域上多项式方程组的求解问题进行相互转化具有重要的意义.

    在这里插入图片描述


    一阶谓词逻辑

    (定义:一阶谓词逻辑) 一阶逻辑(first order logic,FOL)也叫一阶谓词演算,允许量化陈述的公式.包含的符号有常量(Constant symbol),谓词符号(Predicate symbol),函数符号(Function symbol),变量(Variable),连词 ( ∧ , ∨ , → , ↔ ) (\wedge,\vee,\rightarrow,\leftrightarrow) (,,,),量词(Quantifiers) ∃ , ∀ \exists,\forall ,,例如:

    • Father(Mary) = = = Bob;
    • isFatherOf(Mary, Bob);

    (定义:FOLMS问题) FOLMS问题和FOLMS问题实例判断任意一阶公式是否是可满足的问题被称为一阶公式的可满足性问题(first-order logic Satisfiablity problem,简写为FOSAT 问题),它等价于该一阶公式是否存在模型的问题.所以,一阶逻辑公式的可满足性问题也可以被称为一阶逻辑公式的模型生成(first-order logic model generating)问题或模型搜索(first-order logic model searching,简写为 FOLMS)问题.一个具体的FOLMS问题被称为是一个FOLMS问题实例.

    由此可见,一阶逻辑是命题逻辑的一种推广(一阶逻辑包括命题逻辑).


    同构映射

    考虑一个同构映射 ρ : P → F 2 [ x 1 . . . x n ] \rho:\mathcal{P} \rightarrow \mathbb{F}_2[x_1...x_n] ρ:PF2[x1...xn],其中 P \mathcal{P} P是一阶谓词的集合, P \mathcal{P} P的变元域是 X \mathcal{X} X.接下来讨论怎么寻找这样的同构映射 ρ \rho ρ以及它的用途.

    在这里插入图片描述

    考虑 p ∈ p \in p一阶谓词的集合 P \mathcal{P} P:

    p : X → { True,False } tree,water ↦ needs(tree,water)=True \begin{aligned} p:& \mathcal{X} \rightarrow \{\text{True,False} \} \\ &\text{tree,water} \mapsto \text{needs(tree,water)=True} \end{aligned} p:X{True,False}tree,waterneeds(tree,water)=True

    那么和 p ∈ p \in p一一对映的有限域上的多项式函数 f ∈ F 2 [ x 1 . . . x n ] f \in \mathbb{F}_2[x_1...x_n] fF2[x1...xn]满足:

    f : F 2 n → { 1,0 } v 1 , v 2 ↦ f ( v 1 , v 2 ) = 1 \begin{aligned} f:& \mathbb{F}_2^n \rightarrow \{\text{1,0} \} \\ &v1,v2 \mapsto f(v_1,v_2)=1 \end{aligned} f:F2n{1,0}v1,v2f(v1,v2)=1

    也就是说同构映射 ρ \rho ρ满足:若 ρ ( p ) = f ∈ F 2 [ x 1 . . . x n ] \rho(p) = f \in \mathbb{F}_2[x_1...x_n] ρ(p)=fF2[x1...xn],则有:

    p ( w 1 , . . . , w m ) = True ⇔ f ( v 1 , . . . , v m ) = 1 p(w_1,...,w_m) = \text{True} \Leftrightarrow f(v_1,...,v_m)=1 p(w1,...,wm)=Truef(v1,...,vm)=1

    这里 p ( . . . ) p(...) p(...) m m m元谓词, v 1 , v 2 v1,v2 v1,v2 F 2 [ x 1 . . . x n ] \mathbb{F}_2[x_1...x_n] F2[x1...xn]上的 n n n维变量且和谓词的变元一一对应.

    为什么 ρ \rho ρ一定是同构不能仅仅是同态?这是因为我们希望将MQ问题转化为FOLMS问题求解后能够再等价转化回去,完成原问题的求解.


    总结

    在本文中我们展示了一种构建一阶谓词逻辑和有限域上多项式方程的同构的构想,事实上这可以看作SAT问题和MQ问题转化的一种泛化推广,因为一阶逻辑是命题逻辑的推广,而当一阶逻辑可满足问题和MQ问题转化中的一阶逻辑谓词为 0 0 0元谓词时,就直接退化成了SAT问题.

    展开全文
  • 对于有限域Z/(m)内的多项式f(x),其周期T应满足f(x)|x^T-1 我让T从1开始递增,目的是找到使得余式为0的最小的T 有限域多项式周期代码: <code>function [T] = Cycle(m,A) %m为有限域的模数,A为多项式系数向量...
  • 有限域上稀疏多项式的亚线性根检测和新的硬度结果
  • 该方案基于有限域上Chebyshev多项式良好的半群特性, 运用RSA算法巧妙地隐藏通信双方产生的有限域上的Chebyshev多项式值, 从而避免了以往的种种主动攻击, 保证了密钥协商的安全; 同时, 该密钥协商方案还实现了身份...
  • AES:有限域多项式乘法逆元求解

    千次阅读 2017-11-07 17:23:00
    cout多项式(";polynomialtostring(b);cout)mod(";polynomialtostring(m);cout)的乘法逆元是(";polynomialtostring(x);cout)"; system("pause"); return 0; } 运行结果如下图

    题目:


    求解算法,扩展的欧几里得算法

    /*
    @author tilltheendwjx
    @blog http://blog.csdn.net/wjh200821或者http://www.cnblogs.com/tilltheendwjx/ 
    */ 
    #include<iostream>
    using namespace std;
    int indexofmax1(int value)
    {
        int tmp=1;
        int count=0;
        for(int i=0;i<sizeof(int)*8;++i)
        {
              if((value&tmp))
                 count=i;
              tmp=tmp*2;
        }
        return count;
    }
    void polynomialtostring(int value)
    {
        int tmp=1;
        int flag=0;
        int c=indexofmax1(value);
        for(int i=0;i<sizeof(int)*8;++i)
        {
              if((value&tmp))
              {
                 if(i==0)
                 {
                   cout<<"1";
                 }else if(i==1)
                 {
                   cout<<"x";
                 }else
                 {
                   cout<<"x^"<<i;
                 }
                 flag=1;
                 if(i<c)
                   cout<<"+";
              }   
              tmp=tmp*2;
        }
        if(flag==0)
          cout<<"0";
    }
    int powofvalue(int value)
    {
        return 1<<(value);
    }
    int divide(int m,int b,int &remainvalue)
    {
        int mindex=indexofmax1(m);
        int vindex=indexofmax1(b);
        if(mindex<vindex)
        {
            remainvalue=m;
            return 0;
        }
        int c=mindex-vindex;
        int tmp=b;
        tmp=tmp<<c;
        m=m^tmp;
        return powofvalue(c)|divide(m,b,remainvalue);
    }
    int Tx(int ax,int q,int bx)
    {
        //cout<<endl;
        //cout<<ax<<"\t"<<bx<<"\t";
        int tmp=1;
        int value=0;
        for(int i=0;i<sizeof(int)*8;++i)
        {
              if((q&tmp))
              {
                 value=value^((bx<<i));   
              }   
              tmp=tmp*2;
        }
        //cout<<ax<<"\t"<<value<<"\t";
        //cout<<endl;
        return ax^(value);
    }
    int extent_gcd(int m,int b,int &x,int &y)
    {
       int a1=1,a2=0,a3=m;
       int b1=0,b2=1,b3=b;
       int remainvalue=0;
       while(1)
       {
               polynomialtostring(a1);
               cout<<"    ";
               polynomialtostring(a2);
               cout<<"    ";
               polynomialtostring(a3);
               cout<<"    ";
               polynomialtostring(b1);
               cout<<"    ";
               polynomialtostring(b2);
               cout<<"    ";
               polynomialtostring(b3);
               cout<<"    ";
              if(b3==0)
                  return a3;
              if(b3==1)
                   return b3;
              int q=divide(a3,b3,remainvalue);
              int t1=Tx(a1,q,b1);
              int t2=Tx(a2,q,b2);
              int t3=remainvalue;
              cout<<t1<<endl;
              cout<<t2<<endl;
              a1=b1;a2=b2;a3=b3;
              b1=t1;b2=t2;b3=t3;
              x=b2;y=b3;
              polynomialtostring(q);
              cout<<endl;
       } 
    }
    int main(void)
    {
    int m=283,b=83,x=0,y=0;
    cout<<"中间结果如下:"<<endl; 
    cout<<"a1   a2    a3    b1    b2    b3    q"<<endl;
    int reault=extent_gcd(m,b,x,y);
    cout<<endl;
    cout<<"多项式(";polynomialtostring(b);cout<<")mod(";polynomialtostring(m);cout<<")的乘法逆元是(";polynomialtostring(x);cout<<")"<<endl;
    system("pause"); 
    return 0;
    }
    

    运行结果如下图


    展开全文
  • typedef struct polyNode//多项式节点项 { int coef; int power; }polyNode; void CreatePoly(vector&poly);//构造多项式 void SortPolyByPower(vector&poly);//对多项式排序,按照降幂 vector PolyAdd(vectorp1,...
    今年网络安全的一个小作业,简单用C++实现了下 有些粗糙 先放这儿吧 ^_^

     

    算法描述 考完试再附上
    ExEuclid简单实现/*
    * 文件名称:myecu.cpp
    * 摘 要:Extend Euclid Algorithm
    * 作者:ld
    * 完成日期:25th June,2010
    */
    
    #include "stdafx.h"
    #include 
    #include 
    #include 
    #include 
    #include 
    
    using namespace std;
    
    typedef struct polyNode//多项式节点项
    {
    	int coef;
    	int power;
    }polyNode;
    
    void CreatePoly(vector&poly);//构造多项式
    void SortPolyByPower(vector&poly);//对多项式排序,按照降幂
    vector PolyAdd(vectorp1,vectorp2);//多项式加法
    vector PolySub(vectorp1,vectorp2);//多项式减法
    vector PolyMultiply(vectorp1,vectorp2);//多项式乘法
    vector PolyDiv(vector&p1,vectorp2);//多项式除法
    vector Eculid(vector&p1,vector&p2);//扩展欧几里得算法
    
    
    void SortPolyByPower(vector&poly)//OK
    {
    	vector::iterator iter,tmpIter;
    	iter = poly.begin();
    	for (; iter != poly.end(); iter++)//按照幂数高低排序
    	{
    		tmpIter = iter + 1;
    		int maxPower = (*iter).power;
    		for (; tmpIter != poly.end(); tmpIter++)
    		{
    			if ((*tmpIter).power > (*iter).power)
    			{
    				iter_swap(iter,tmpIter);
    			}
    		}	
    	}
    
    }
    
    void CreatePoly(vector&poly)//OK
    {
    	static int itemCount = 0;
    	cout<<"Please input the itemCount of the poly:"<>itemCount; 
    	for (int t = 0; t < itemCount; t++)
    	{
    		static polyNode tmpItem;
    		cout<<"Please input the coef and power:"<>tmpItem.coef>>tmpItem.power;
    		poly.push_back(tmpItem);
    
    	}
    	SortPolyByPower(poly);
    	cout<<"原始多项式为:"<::iterator iter;
    	for ( iter = poly.begin();iter!= poly.end();iter++)
    	{
    		cout<<"X^"<<(*iter).power<<"+";
    	}
    	cout< PolyAdd(vectorp1,vectorp2)//OK
    {
    	vector tmpPolyAdd;
    	vector::iterator iter1,iter2;
    	iter1 = p1.begin();
    	iter2 = p2.begin();
    	if (p1.size() == 0)
    	{
    		tmpPolyAdd.clear();
    		tmpPolyAdd = p2;
    		return tmpPolyAdd;
    	}
    	else if(p2.size() == 0)
    	{
    		tmpPolyAdd.clear();
    		tmpPolyAdd = p1;
    		return tmpPolyAdd;
    	}
    	else
    	{
    		tmpPolyAdd.clear();
    		for (; iter1 != p1.end() && iter2 != p2.end();)
    		{
    			if ((*iter1).power > (*iter2).power)
    			{
    				tmpPolyAdd.push_back(*iter1);
    				iter1++;
    			}
    			else if ((*iter1).power == (*iter2).power)
    			{
    				polyNode tmp;
    				tmp.coef = ((*iter1).coef + (*iter2).coef)%2;
    				tmp.power = (*iter1).power;
    				if (tmp.coef != 0)
    				{
    					tmpPolyAdd.push_back(tmp);
    				}
    				else;
    				iter1++;
    				iter2++;
    			}
    			else if ((*iter1).power < (*iter2).power)
    			{
    				tmpPolyAdd.push_back(*iter2);
    				iter2++;
    			}
    		}
    		if (iter2 != p2.end())
    		{
    			for (;iter2 != p2.end();iter2++)
    			{
    				tmpPolyAdd.push_back(*iter2);
    			}
    			SortPolyByPower(tmpPolyAdd);
    			return tmpPolyAdd;
    		}
    		else if(iter1 != p1.end())
    		{
    			for (;iter1 != p1.end();iter1++)
    			{
    				tmpPolyAdd.push_back(*iter1);
    			}
    			SortPolyByPower(tmpPolyAdd);
    			return tmpPolyAdd;
    		}
    		else 
    		{
    			SortPolyByPower(tmpPolyAdd);
    			return tmpPolyAdd;
    		}
    
    	}
    }
    
    vector PolySub(vectorp1,vectorp2)//OK
    {
    	vector tmpPolySub;
    	vector::iterator iter1,iter2;
    	iter1 = p1.begin();
    	iter2 = p2.begin();
    	for (; iter1 != p1.end() && iter2 != p2.end();)
    	{
    		if ((*iter1).power > (*iter2).power)
    		{
    			tmpPolySub.push_back(*iter1);
    			iter1++;
    		}
    		else if ((*iter1).power == (*iter2).power)
    		{
    			polyNode tmp;
    			tmp.coef = ((*iter1).coef - (*iter2).coef)%2;
    			tmp.power = (*iter1).power;
    			if (tmp.coef != 0)
    			{
    				tmpPolySub.push_back(tmp);
    			}
    			else;
    
    			iter1++;
    			iter2++;
    		}
    		else if ((*iter1).power < (*iter2).power)
    		{
    			tmpPolySub.push_back(*iter2);
    			iter2++;
    		}
    	}
    	if (iter2 == p2.end())
    	{
    		for (;iter1 != p1.end();iter1++)
    		{
    			tmpPolySub.push_back(*iter1);
    		}
    	}
    	else if(iter1 == p1.end())
    	{
    		for (;iter2 != p2.end();iter2++)
    		{
    			tmpPolySub.push_back(*iter2);
    		}
    	}
    	SortPolyByPower(tmpPolySub);
    	return tmpPolySub;
    }
    
    vector PolyMultiply( vectorp1, vectorp2)//OK
    {
    	vector tmpPolyMul;
    	tmpPolyMul.clear();
    	vector itemPoly;
    	polyNode tmp;
    
    	vector::iterator iter1,iter2;
    	iter1 = p1.begin();
    	iter2 = p2.begin();
    	for (; iter2 != p2.end(); iter2++)
    	{
    		for (;iter1 != p1.end(); iter1++)
    		{
    			tmp.coef = (*iter1).coef * (*iter2).coef;
    			tmp.power = (*iter1).power + (*iter2).power;
    			itemPoly.push_back(tmp);
    		}
    		SortPolyByPower(itemPoly);
    		iter1 = p1.begin();		
    		tmpPolyMul = PolyAdd(tmpPolyMul,itemPoly);
    		itemPoly.clear();
    	}
    	SortPolyByPower(tmpPolyMul);
    	return tmpPolyMul;
    
    }
    
    vector PolyDiv(vector&p1, vectorp2)//OK
    {
    	polyNode tmpItem;
    	vector tmpP1 = p1;
    	vector tmpP2 = p2;
    	static vector result;
    	static vector ret;
    	vector tmpMultiply;
    	vector tmpResult;
    	static vector rPoly;
    
    	vector::iterator iter1;
    	vector::iterator iter2;
    	iter1 = tmpP1.begin();
    	iter2 = tmpP2.begin();
    	while ((*iter1).power >= (*iter2).power)
    	{
    		for (;iter2!=tmpP2.end();iter2++)
    		{
    			tmpItem.coef = abs((*iter1).coef / (*iter2).coef);
    			tmpItem.power = (*iter1).power - (*iter2).power;
    			tmpResult.push_back(tmpItem);
    			result.push_back(tmpItem);
    
    			tmpMultiply = PolyMultiply(p2,tmpResult);
    			vector::iterator tmpIter;
    			tmpIter = tmpMultiply.begin();
    			tmpResult.clear();
    			rPoly= PolySub(tmpP1,tmpMultiply);
    
    			p1 = rPoly;
    			rPoly.clear();
    			return PolyDiv(p1,p2);
    		}
    	}
    	SortPolyByPower(result);
    	ret = result;
    	result.clear();
    	return ret;
    }
    
    vector Eculid(vector&mx,vector&bx)//OK
    {
    	vector a1x;
    	vector a2x;
    	vector a3x;
    	vector a3xcp;
    
    	vector b1x;
    	vector b2x;
    	vector b3x;
    
    	vector t1x;
    	vector t2x;
    	vector t3x;
    
    	vector qx;
    	vector gcd;
    	vector inverse;
    	vector::iterator iter;
    
    	static polyNode tmpItem;
    	tmpItem.coef = 1;
    	tmpItem.power = 0;
    	a1x.push_back(tmpItem);
    	a3x.clear();
    	a3x = mx;
    
    	b1x.clear();
    	tmpItem.coef = 1;
    	tmpItem.power = 0;
    	b2x.push_back(tmpItem);
    	b3x = bx;
    	do 
    	{
    		iter = b3x.begin();
    		if (b3x.empty())
    		{
    			cout<<"No inverse!!!"<else if (b3x.size() == 1 && ((*iter).coef == 1 && (*iter).power == 0))
    		{
    			inverse = b2x;
    			return inverse;
    		}
    		a3xcp = a3x;
    		qx = PolyDiv(a3x,b3x);
    		a3x = a3xcp;
    
    		t1x = PolySub(a1x,PolyMultiply(qx,b1x));
    		t2x = PolySub(a2x,PolyMultiply(qx,b2x));
    		t3x = PolySub(a3x,PolyMultiply(qx,b3x));
    
    		a1x = b1x;
    		a2x = b2x;
    		a3x = b3x;
    
    		b1x = t1x;
    		b2x = t2x;
    		b3x = t3x;
    	} while (1);
    
    }
    
    
    int main()
    {
    	vector polynomial1;
    	vector polynomial2;
    	vector inverse;
    	vector ::iterator iter;
    	vector r;
    	CreatePoly(polynomial1);
    	CreatePoly(polynomial2);
    	inverse = Eculid(polynomial1,polynomial2);
    	SortPolyByPower(inverse);
    	iter = inverse.begin();
    	cout<<"求得的逆为:"<for (;iter!=inverse.end();iter++)
    	{
    		cout<<"X^"<<(*iter).power<<"+"<

    展开全文
  • 本文利用具有线性结构的多项式和线性化多项式得到了一种形式为L1(x)+ L-1(γ)h(f(x))的置换多项式,该结果推广了Kyureghyan在2011年得到的一个结果.本文还利用具有线性结构的多项式和核的维数为k+1线性化多项式构造...
  • 有限域上低重不可约多项式生成及判断算法,程序
  • 有限域上的一类新的置换多项式
  • 最近在复习现代密码理论中的AES,AES中的字节变换的核心操作就是求GF(28)GF(2^8)GF(28)上的多项式逆元,这个问题困扰了我一段时间,今天终于得到解决,其实计算方式和数论中求两个数的Bezout算法是一样的,这里感谢...
  • 利用有限域多项式理论的有关结果,得到了有限域F8上的置换多项式是正形置换多项式的一个判定定理,进一步利用这个定理得到了有限域F8上的正形置换多项式的具体表示形式与计数
  • [原]有限域多项式乘法逆元求解

    千次阅读 2012-05-15 22:13:00
    cout多项式(";polynomialtostring(b);cout)mod(";polynomialtostring(m);cout)的乘法逆元是(";polynomialtostring(x);cout)"; system("pause"); return 0; } 运行结果如下图 作者:wjh200821 发表于2012...
  • ![图片说明]... 如图计算九阶分圆多项式求和在mod p的结果(不知道自己理解的有没有问题) 九阶分圆多项式是x^6+x^3+1,有没有大佬告诉我该怎么做。。。
  • 对于给定的置换多项式f(x)∈Fq[x],研究f(x)是否Fqr(r>1)上的置换多项式,是研究有限域上置换多项式的主要问题之一.本文改进了Carlitz和万大庆的方法,完全解决了形如x q-1/4+1+ax的多项式是否Fqr上置换多项式的...
  • 版权申明:本文为博主窗户(Colin Cai)原创,欢迎转帖。如要转贴,必须注明原文网址  ...  作者:窗户 ... 接着上两章内容,我们还是得继续寻找有限域的构造方法。上章证明矩阵环...
  • 本文证明了定理设F是一个特征为P的含P~a个元的有限域.f(x)=f_1(x)~l1…f_k(x)~lk是f(x)在多项式环F[x]中的标准分解式,f_i(x)是最高系数为1、次数为n_i的不可约多项式.那么f(x)有原根的充分必要条件为当p≥3时:k=1...
  • 利用有限域上二元多项式构造了一个带仲裁的认证码,并计算了所构造码的参数。当编码规则按等概率分布选取时,计算出了敌方与收方成功模仿攻击和成功替换攻击的最大概率,以及发方成功模仿攻击的最大概率。
  • GF⁡(2r)\operatorname {GF}(2^r)GF(2r)中元素的α\alphaα方幂与向量表示 例如:r=4r=4r=4,GF⁡(24)=F2[x]/(x4+x+1)\operatorname {GF}(2^4)=F_2[x]/(x^4+x+1)GF(24...根据本原多项式x4+x+1x^4+x+1x4+x+1,得α4+α+1
  • 我们通过使用F-pk值多项式对n的几个相同或不同因子k描述有限域F-pn上置换和完整置换多项式的递归构造。 结果,我们获得了一些特定的置换多项式,这些多项式统一并概括了几种先前的构造。
  • 有限域中的算术和多项式运算。 安装 $ npm install @guildofweavers/galois --save 例子 import * as galois from '@guildofweavers/galois' ; // create a prime field with a large modulus const field = galois...
  • 利用更为简明的方法证明了有关有限域上的以 为周期的次不可约多项式的个数的结论,另外,本文结合初等数论知识得到了前面这个结论的几 个推论,并对利用低次不可约多项式构造高次不可约多项式进行了研究
  • 本文给出了有限域F9上满足条件f(g(x))-h(f(x;的多项式f(x)的通解表示公式及在degf条件下的f(二)的个数计算公式,此地班二)和h(二)是F9上给定的两个多项式,其中之一是置换多项式这一结果推广了文献[3]的主要结果,而...
  • 因加密的大部分步骤中只用到了有限域的加法运算,因此该算法的加密效率较高。该加密方法不 仅有安全性高和便于图像的局部加密等优点,还可以方便地推广到视频的图像加密领域,具有很好的应用前景。
  • 文章目录一、前言二、数学基础1、GF(2⁸)有限域内的多项式2、不可约多项式3、多项式模运算3、乘法逆元三、算法步骤1、扩展欧几里得算法2、多项式除法3、多项式乘法四、代码实现1、多项式除法2、多项式乘法3、...
  • 证明了对任意给定正整数n和k,如果满足k

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,607
精华内容 2,242
关键字:

有限域的多项式