D:\SixCocos2d-xVC2012\Cocos2d-x\XWH\cstest>csc Ideal.cs IRing.cs
D:\SixCocos2d-xVC2012\Cocos2d-x\XWH\cstest>Ideal
6階環:
[0,3]構成理想,不是冪零理想,是素理想,是準素理想
[0,2,4]構成理想,不是冪零理想,是素理想,是準素理想
和:[0,1,2,3,4,5],不是冪零理想,不是素理想,不是準素理想
積:[0],是冪零理想(m=1),是素理想,是準素理想
交:[0],是冪零理想(m=1),是素理想,是準素理想
和:[0,3],不是冪零理想,是素理想,是準素理想
積:[0,3],不是冪零理想,是素理想,是準素理想
交:[0,3],不是冪零理想,是素理想,是準素理想
和:[0,2,4],不是冪零理想,是素理想,是準素理想
積:[0,2,4],不是冪零理想,是素理想,是準素理想
交:[0,2,4],不是冪零理想,是素理想,是準素理想
12階環:
[0,3,6,9]構成理想,不是冪零理想,是素理想,是準素理想
[0,4,8]構成理想,不是冪零理想,不是素理想,是準素理想
和:[0,1,2,3,4,5,6,7,8,9,10,11],不是冪零理想,不是素理想,不是準素理想
積:[0],是冪零理想(m=1),是素理想,是準素理想
交:[0],是冪零理想(m=1),是素理想,是準素理想
和:[0,3,6,9],不是冪零理想,是素理想,是準素理想
積:[0,3,6,9],不是冪零理想,是素理想,是準素理想
交:[0,3,6,9],不是冪零理想,是素理想,是準素理想
和:[0,4,8],不是冪零理想,不是素理想,是準素理想
積:[0,4,8],不是冪零理想,不是素理想,是準素理想
交:[0,4,8],不是冪零理想,不是素理想,是準素理想
12階環:
[0,3,6,9]構成理想,不是冪零理想,是素理想,是準素理想
[0,2,4,6,8,10]構成理想,不是冪零理想,是素理想,是準素理想
和:[0,1,2,3,4,5,6,7,8,9,10,11],不是冪零理想,不是素理想,不是準素理想
積:[0,6],是冪零理想(m=2),不是素理想,不是準素理想
交:[0,6],是冪零理想(m=2),不是素理想,不是準素理想
和:[0,3,6,9],不是冪零理想,是素理想,是準素理想
積:[0,3,6,9],不是冪零理想,是素理想,是準素理想
交:[0,3,6,9],不是冪零理想,是素理想,是準素理想
和:[0,2,4,6,8,10],不是冪零理想,是素理想,是準素理想
積:[0,4,8],不是冪零理想,不是素理想,是準素理想
交:[0,2,4,6,8,10],不是冪零理想,是素理想,是準素理想
using System;
using System.Collections.Generic;
namespace gap
{
class rutil
{
// ascending=true表示升序，false表示降序
public static void pibub(List<int> p,bool ascending)
{
int temp,i,j;
int n=p.Count;
for(i=0;i<n;i++)
{
for(j=0;j<i;j++)
{
if(p[j]>p[i]==ascending)
{
temp=p[i];
//插入
for(int k=i;k>=j;k--)
p[k]=p[k-1];
p[j]=temp;
}
}
}
}
public static string V2S(List<int> v){
string str="[";
int n=v.Count;
for(int i=0;i<n;i++)
{
str+=v[i].ToString();
if(i<n-1)
str+=",";
}
str+="]";
return str;
}
public static bool IsEqual(List<int> a,List<int> b){
int na=a.Count;
int nb=b.Count;
if(na!=nb)
return false;
for(int i=0;i<na;i++)
if(a[i]!=b[i])
return false;
return true;
}
// 判斷集合I是否是環r的理想
public static int IsIdeal(IRing r,List<int> I){
//I是r的子環
Subring s=new Subring(r,I);
bool bE=IsEqual(I,s.m_Set);
if(!bE){
return 0;// 子環也不是
}
//進一步判斷是否是理想
for(int i=0;i<r.size();i++){//任意純量環元素c
for(int j=0;j<I.Count;j++){//任意向量模元素a
int ca=r.mul(i,I[j]);
int ac=r.mul(I[j],i);
int p=Subring.getidx(I,ca);
if(p==-1){
return 2;// 是子環但不是理想
}
int p1=Subring.getidx(I,ac);
if(p1==-1){
return 2;// 是子環但不是理想
}
}
}
return 1;//是理想
}
public static string IsIdealRetInfo(int iret){
string[] str={"不構成環","構成理想","構成非理想子環"};
return str[iret];
}
/*
我們把理想A,B,…的最大公因子或和理解爲由它們的並所生成的理想(A,B,…)，同樣地，把它們的最小公倍理解爲交[A,B,…]=A∩B∩…。
定理：設R爲環，I，J都是R的理想。則I與J的和與交都是R的理想。
定理：(1)環R的任意有限多個理想的和還是理想；(2)環R的任意(有限或無限)多個理想的交還是R的理想。
由兩個理想I,J的和生成的理想(I,J)稱爲這兩個理想的最大公因子（g.c.d.），它是它們的公因子，並且每個公因子都能整除它。(I,J)也稱爲這兩個理想的和，因爲它顯然是由所有的元素a+b組成，其中a∈I，b∈J。
理想I,J的交I∩J稱爲它們的最小公倍（l.c.m.），它是它們的公倍並且能整除它們的每個公倍。
定義：理想數[a_1b_1,…,a_1b_r,a_2b_1,…,a_2b_r,…,a_qb_1,…,a_qb_r]稱爲理想數A=[a_1,,a_q]及B=[b_1,,b_r]的乘積，以AB記之。
定義：設R爲環，I，J都是R的理想，集合I+J:={a+b|a∈I,b∈J}，I·J:={∑a_ib_i|a_i∈I,b_i∈J}與I∩J分別稱爲理想I與J的和、積、交。
易知I+J,I·J,I∩J都是理想，並有(a)+(b)=(a,b),(a)·(b)=(ab)，I·J包含於I∩J。
*/
// 理想的和gcd
public static List<int> SumIdeals(IRing r,List<int> I,List<int> J){
List<int> L=new List<int>();
for(int i=0;i<I.Count;i++){
for(int j=0;j<J.Count;j++){
int ij=r.add(I[i],J[j]);
if(Subring.getidx(L,ij)==-1)
L.Add(ij);
}
}
pibub(L,true);
return L;
}
// 理想的積
public static List<int> MultipleIdeals(IRing r,List<int> I,List<int> J){
List<int> L=new List<int>();
for(int i=0;i<I.Count;i++){
for(int j=0;j<J.Count;j++){
int ij=r.mul(I[i],J[j]);
if(Subring.getidx(L,ij)==-1)
L.Add(ij);
}
}
pibub(L,true);
return L;
}
// 理想的交lcm
public static List<int> IntersectIdeals(IRing r,List<int> I,List<int> J){
return IntersectSet(I,J);
}
// 集合的交
public static List<int> IntersectSet(List<int> I,List<int> J){
List<int> L=new List<int>();
for(int i=0;i<I.Count;i++){
if(Subring.getidx(J,I[i])>-1)
L.Add(I[i]);
}
return L;
}
// 一個（左或右）理想I稱爲冪零的，如果它的某個冪I^m是零理想。
public static int IsNilpotentIdeal(IRing r,List<int> I){
List<int> O=new List<int>{0};
List<int> I1=new List<int>(I);
List<int> Ii=MultipleIdeals(r,I1,I);
int cnt1=I1.Count;
int cnti=Ii.Count;
int m=1;
while(cnti!=cnt1)
{
cnt1=Ii.Count;
Ii=MultipleIdeals(r,Ii,I);
m++;
cnti=Ii.Count;
}
if(IsEqual(Ii,O))
return m;// 是冪零理想
return 0;//不是冪零理想
}
public static string IsNilpotentIdealRetInfo(int iret){
string[] str={"不是冪零理想",string.Format("是冪零理想(m={0:G})",iret)};
if(iret!=0)
iret=1;
return str[iret];
}
/*
環r的真理想I(也即I≠r,{0}也算真理想)被稱爲素理想，若對任意r上的理想A,B，有AB包含於I推導出A包含於I或B包含於I。
r的理想I是素理想，當且僅當它是一個真理想，且對於r的任何兩個理想A和B使得AB包含於I，都有A包含於I或B包含於I。
素理想對交換環有一個較簡單的描述：如果r是一個交換環，那麼r的理想I是素理想，如果它具有以下兩個性質：
1、只要a,b是r的兩個元素，使得它們的乘積ab位於I內，那麼要麼a位於I內，要麼b位於I內。
2、I不等於整個環r。
*/
public static bool IsPrimeIdeal(IRing r,List<int> I){
if(I.Count==r.size())
return false;
if(I.Count==1 && I[0]==0)
return true;
for(int i=0;i<r.size();i++){
for(int j=0;j<r.size();j++){
int ij=r.mul(i,j);
if(Subring.getidx(I,ij)>-1){
if(Subring.getidx(I,i)==-1 && Subring.getidx(I,j)==-1){
return false;
}
}
}
}
return true;
}
public static string IsPrimeIdealRetInfo(bool bret){
return bret?"是素理想":"不是素理想";
}
/*
準素理想：環r的真理想I。若對任意r上的理想A，有A^2包含於I推導出A包含於I，稱I是r的準素理想。
一個理想叫做準素的，如果在它的同餘類環裏每一個零因子都是冪零的。
這個定義是素理想定義的一個微小改變。在以一個素理想爲模的同餘類環裏，每一個零因子不僅是冪零的，而且本身就是零。
素理想是準素理想，反之不成立。
定理：每一個不可約理想都是準素的。
因爲每一理想都可以表示成有限個不可約理想的交，而每一不可約理想都是準素的，所以
定理：每一理想都可以被表示成有限個準素理想的交。
準素理想對交換環有一個較簡單的描述：如果r是一個交換環，那麼r的理想I是準素理想，如果它具有以下兩個性質：
1、只要a,b是r的兩個元素，使得它們的乘積ab位於I內，且a不位於I內，那麼存在正整數n，使得b^n位於I內。
2、I不等於整個環r。
*/
public static bool IsPrimaryIdeal(IRing r,List<int> I){
if(I.Count==r.size())
return false;
if(I.Count==1 && I[0]==0)
return true;
for(int i=0;i<r.size();i++){
for(int j=0;j<r.size();j++){
int ij=r.mul(i,j);
if(Subring.getidx(I,ij)>-1 && Subring.getidx(I,i)==-1){
List<int> J=Na(r,j);
List<int> IJ=IntersectSet(I,J);
if(IJ.Count==0){
return false;
}
}
}
}
return true;
}
public static string IsPrimaryIdealRetInfo(bool bret){
return bret?"是準素理想":"不是準素理想";
}
// {a^n|a屬於r,n是正整數}
public static List<int> Na(IRing r,int a)
{
List<int> L=new List<int>();
int mi=a;
while(Subring.getidx(L,mi)==-1)
{
L.Add(mi);
mi=r.mul(mi,a);
}
return L;
}
}
// 一個環r的子環s
class Subring:IRing
{
// 靜態函數
public static int getidx(List<int> L,int a)
{
for(int i=0;i<L.Count;i++)
if(L[i]==a)
return i;
return -1;
}
// 實現抽象基類的方法
public override void printTable()
{
util.printRing(this);
}
public override int add(int a,int b)
{
int ij=m_r.add(m_Set[a],m_Set[b]);
int IJ=getidx(m_Set,ij);
return IJ;
}
public override int mul(int a,int b)
{
int ij=m_r.mul(m_Set[a],m_Set[b]);
int IJ=getidx(m_Set,ij);
return IJ;
}
public override int size()
{
return m_Set.Count;
}
// 構造函數
public Subring(IRing r,List<int> gens)
{
m_r=r;
m_Set=new List<int>();
int E=0;
m_Set.Add(E);
for(int i=0;i<gens.Count;i++)
{
if(gens[i]!=E)
m_Set.Add(gens[i]);
}
int R=m_Set.Count;
int cnt=R;
int cnt1=R;
do{
cnt=m_Set.Count;
for(int i=0;i<cnt;i++)
{
for(int j=0;j<cnt;j++)
{
int IJ=m_r.mul(m_Set[i],m_Set[j]);
int p=getidx(m_Set,IJ);
if(p==-1){
m_Set.Add(IJ);
}
int IJ1=m_r.add(m_Set[i],m_Set[j]);
int p1=getidx(m_Set,IJ1);
if(p1==-1){
m_Set.Add(IJ1);
}
}
}
cnt1=m_Set.Count;
}while(cnt1>cnt);
}
// 成員函數
// 成員變量
public List<int> m_Set;
IRing m_r;
};
/// <summary>
/// Summary description for Class1.
/// </summary>
class testIdeal
{
static void test(IRing r,List<int> L1,List<int> L2)
{
Console.WriteLine(string.Format("{0:G}階環:",r.size()));
List<int> sum=rutil.SumIdeals(r,L1,L2);
List<int> mul=rutil.MultipleIdeals(r,L1,L2);
List<int> inter=rutil.IntersectIdeals(r,L1,L2);
int i1=rutil.IsIdeal(r,L1);
int i2=rutil.IsIdeal(r,L2);
int n1=rutil.IsNilpotentIdeal(r,L1);
int n2=rutil.IsNilpotentIdeal(r,L2);
int nsum=rutil.IsNilpotentIdeal(r,sum);
int nmul=rutil.IsNilpotentIdeal(r,mul);
int ninter=rutil.IsNilpotentIdeal(r,inter);
bool b1=rutil.IsPrimeIdeal(r,L1);
bool b2=rutil.IsPrimeIdeal(r,L2);
bool bsum=rutil.IsPrimeIdeal(r,sum);
bool bmul=rutil.IsPrimeIdeal(r,mul);
bool binter=rutil.IsPrimeIdeal(r,inter);
bool bb1=rutil.IsPrimaryIdeal(r,L1);
bool bb2=rutil.IsPrimaryIdeal(r,L2);
bool bbsum=rutil.IsPrimaryIdeal(r,sum);
bool bbmul=rutil.IsPrimaryIdeal(r,mul);
bool bbinter=rutil.IsPrimaryIdeal(r,inter);
Console.WriteLine("{0}{1},{2},{3},{4}",rutil.V2S(L1),rutil.IsIdealRetInfo(i1),rutil.IsNilpotentIdealRetInfo(n1),rutil.IsPrimeIdealRetInfo(b1),rutil.IsPrimaryIdealRetInfo(bb1));
Console.WriteLine("{0}{1},{2},{3},{4}",rutil.V2S(L2),rutil.IsIdealRetInfo(i2),rutil.IsNilpotentIdealRetInfo(n1),rutil.IsPrimeIdealRetInfo(b2),rutil.IsPrimaryIdealRetInfo(bb2));
Console.WriteLine("和:{0},{3},{6},{9}\n積:{1},{4},{7},{10}\n交:{2},{5},{8},{11}",
rutil.V2S(sum),rutil.V2S(mul),rutil.V2S(inter),
rutil.IsNilpotentIdealRetInfo(nsum),rutil.IsNilpotentIdealRetInfo(nmul),rutil.IsNilpotentIdealRetInfo(ninter),
rutil.IsPrimeIdealRetInfo(bsum),rutil.IsPrimeIdealRetInfo(bmul),rutil.IsPrimeIdealRetInfo(binter),
rutil.IsPrimaryIdealRetInfo(bbsum),rutil.IsPrimaryIdealRetInfo(bbmul),rutil.IsPrimaryIdealRetInfo(bbinter));
sum=rutil.SumIdeals(r,L1,L1);
mul=rutil.MultipleIdeals(r,L1,L1);
inter=rutil.IntersectIdeals(r,L1,L1);
nsum=rutil.IsNilpotentIdeal(r,sum);
nmul=rutil.IsNilpotentIdeal(r,mul);
ninter=rutil.IsNilpotentIdeal(r,inter);
bsum=rutil.IsPrimeIdeal(r,sum);
bmul=rutil.IsPrimeIdeal(r,mul);
binter=rutil.IsPrimeIdeal(r,inter);
bbsum=rutil.IsPrimaryIdeal(r,sum);
bbmul=rutil.IsPrimaryIdeal(r,mul);
bbinter=rutil.IsPrimaryIdeal(r,inter);
Console.WriteLine("和:{0},{3},{6},{9}\n積:{1},{4},{7},{10}\n交:{2},{5},{8},{11}",
rutil.V2S(sum),rutil.V2S(mul),rutil.V2S(inter),
rutil.IsNilpotentIdealRetInfo(nsum),rutil.IsNilpotentIdealRetInfo(nmul),rutil.IsNilpotentIdealRetInfo(ninter),
rutil.IsPrimeIdealRetInfo(bsum),rutil.IsPrimeIdealRetInfo(bmul),rutil.IsPrimeIdealRetInfo(binter),
rutil.IsPrimaryIdealRetInfo(bbsum),rutil.IsPrimaryIdealRetInfo(bbmul),rutil.IsPrimaryIdealRetInfo(bbinter));
sum=rutil.SumIdeals(r,L2,L2);
mul=rutil.MultipleIdeals(r,L2,L2);
inter=rutil.IntersectIdeals(r,L2,L2);
nsum=rutil.IsNilpotentIdeal(r,sum);
nmul=rutil.IsNilpotentIdeal(r,mul);
ninter=rutil.IsNilpotentIdeal(r,inter);
bsum=rutil.IsPrimeIdeal(r,sum);
bmul=rutil.IsPrimeIdeal(r,mul);
binter=rutil.IsPrimeIdeal(r,inter);
bbsum=rutil.IsPrimaryIdeal(r,sum);
bbmul=rutil.IsPrimaryIdeal(r,mul);
bbinter=rutil.IsPrimaryIdeal(r,inter);
Console.WriteLine("和:{0},{3},{6},{9}\n積:{1},{4},{7},{10}\n交:{2},{5},{8},{11}",
rutil.V2S(sum),rutil.V2S(mul),rutil.V2S(inter),
rutil.IsNilpotentIdealRetInfo(nsum),rutil.IsNilpotentIdealRetInfo(nmul),rutil.IsNilpotentIdealRetInfo(ninter),
rutil.IsPrimeIdealRetInfo(bsum),rutil.IsPrimeIdealRetInfo(bmul),rutil.IsPrimeIdealRetInfo(binter),
rutil.IsPrimaryIdealRetInfo(bbsum),rutil.IsPrimaryIdealRetInfo(bbmul),rutil.IsPrimaryIdealRetInfo(bbinter));
Console.WriteLine("");
}
static void Main(string[] args)
{
ZmodnZ r6_4=new ZmodnZ(1,6);
List<int> L1=new List<int>();
L1.Add(0);
L1.Add(3);
List<int> L2=new List<int>();
L2.Add(0);
L2.Add(2);
L2.Add(4);
test(r6_4,L1,L2);
ZmodnZ r12_5=new ZmodnZ(1,12);
L1.Clear();
L1.Add(0);
L1.Add(3);
L1.Add(6);
L1.Add(9);
L2.Clear();
L2.Add(0);
L2.Add(4);
L2.Add(8);
test(r12_5,L1,L2);
L2.Clear();
L2.Add(0);
L2.Add(2);
L2.Add(4);
L2.Add(6);
L2.Add(8);
L2.Add(10);
test(r12_5,L1,L2);
}
}
}