Pyramide de chiffres

sage: P = Pyramide(4)
sage: P.remplisage()
 Remplissage de la matrice : chiant
 tapper 222222222222222221 pour ne pas remplacer
 Bien sur vous pouvez enter un variable a = 222222222222222221 et tapper a
 Remplacer x11 par : a
[x11   0   0   0]
[x12 x22   0   0]
[x13 x23 x33   0]
[x14 x24 x34 x44]
 ---------------------------------------

 Remplacer x12 par : 1
[x11   0   0   0]
[  1 x22   0   0]
[x13 x23 x33   0]
[x14 x24 x34 x44]
---------------------------------------

 Remplacer x13 par : 2
[x11   0   0   0]
[  1 x22   0   0]
[  2 x23 x33   0]
[x14 x24 x34 x44]
---------------------------------------

 Remplacer x14 par : a
[x11   0   0   0]
[  1 x22   0   0]
[  2 x23 x33   0]
[x14 x24 x34 x44]
 ---------------------------------------

 Remplacer x22 par : 1
[x11   0   0   0]
[  1   1   0   0]
[  2 x23 x33   0]
[x14 x24 x34 x44]
---------------------------------------

 Remplacer x23 par : 9
[x11   0   0   0]
[  1   1   0   0]
[  2   9 x33   0]
[x14 x24 x34 x44]
---------------------------------------

 Remplacer x24 par : a
[x11   0   0   0]
[  1   1   0   0]
[  2   9 x33   0]
[x14 x24 x34 x44]
 ---------------------------------------

 Remplacer x33 par : a
[x11   0   0   0]
[  1   1   0   0]
[  2   9 x33   0]
[x14 x24 x34 x44]
 ---------------------------------------

 Remplacer x34 par : a
[x11   0   0   0]
[  1   1   0   0]
[  2   9 x33   0]
[x14 x24 x34 x44]
 ---------------------------------------

 Remplacer x44 par : a
[x11   0   0   0]
[  1   1   0   0]
[  2   9 x33   0]
[x14 x24 x34 x44]
 ---------------------------------------

[x11   0   0   0]
[  1   1   0   0]
[  2   9 x33   0]
[x14 x24 x34 x44]
sage: P.A_solution()
[2 0 0 0]
[1 1 0 0]
[2 9 2 0]
[5 7 2 0]
[x11   0   0   0]
[  1   1   0   0]
[  2   9 x33   0]
[x14 x24 x34 x44]

class Pyramide:
	def __init__(self,n):
		self.n			= n 
		self.star()
	def star(self):
		mlist=[];
		varlist =[]
		root = "x"
		n = self.n
		for i in range(n):
				for j in range(n):
					if(i <= j):
						mlist.append(root+str(i+1)+str(j+1));
						varlist.append(root+str(i+1)+str(j+1));
					if (i > j):
						mlist.append(0)
		self.Poly_ring 		 = PolynomialRing(ZZ,varlist)
		self.matrix_space 	 = MatrixSpace(self.Poly_ring,n,n)
		self.matrix 		 = self.matrix_space(mlist).transpose()
		self.x  			 = [self.Poly_ring(a) for a in varlist]
		self.x_temp          = [self.Poly_ring(a) for a in varlist]
		R = []
		A = self.matrix
		for i in range(self.n-1):
			for j in range(i+1):
				R.append(A[i,j]-A[i+1,j]-A[i+1,j+1])
		self.equation = vector(R)
		self.X  = lambda ij : self.Poly_ring(x[self.x.index(self.Poly_ring("x"+str(ij[0])+str(ij[1])))])
	def remplisage(self):
		print " Remplissage de la matrice : chiant \n tapper 222222222222222221 pour ne pas remplacer \n Bien sur vous pouvez enter un variable a = 222222222222222221 et tapper a"
		X = self.x_temp
		for xij in X:
				a_ij = int(input(" Remplacer "+str(xij)+" par : "))
				if (a_ij != 222222222222222221):
					self.Substitute(xij,a_ij)
					print self.matrix
					print "--------------------------------------- \n"
				else: 
					print self.matrix
					print " --------------------------------------- \n"
		print self.matrix
	def Substitute(self,xij,a_ij):
		self.matrix 		= self.matrix.substitute({xij :a_ij})
		self.equation       = self.equation.substitute({xij : a_ij})
		self.x.remove(xij)
	def Subs(self,i,j,a_ij):
		self.matrix 		= self.matrix.substitute({self.X([i,j]) :a_ij})
		self.equation       = self.equation.substitute({self.X([i,j]) : a_ij})
		self.x.remove(self.X([i,j]))
	def Solver(self):
		X = self.x
		second_membre = -self.equation.substitute({xij : 0 for xij in X})
		homogene  	  = self.equation+second_membre
		pre_matrix = [[eq_k.coefficient(xij) for xij in X] for eq_k in homogene]
		def My_ker(pre_mat,k):
			return matrix(k,pre_matrix)
		M5 = My_ker(pre_matrix,GF(5))
		KER_M5 = M5.right_kernel()
		Part_solution_5 = M5.solve_right(second_membre)
		M2 = My_ker(pre_matrix,GF(2))
		KER_M2 = M2.right_kernel()
		Part_solution_2 = M2.solve_right(second_membre)
		return [KER_M5,Part_solution_5,KER_M2,Part_solution_2]
	def A_solution(self):
		a,b,c,d = self.Solver()
		f = lambda u,v : 5*u -4*v
		sol_part = f(d.lift(),b.lift())%10 
		A = self.matrix
		x = self.x
		print A.substitute({x[k] : sol_part[k] for k in range(len(x))})
		print A