algebra 0.2.1

data/sample/sample-geometry02.rb

@@ -0,0 +1,29 @@
+require 'algebra'
+R = MPolynomial(Rational)
+x,y,a1,a2,b1,b2,c1,c2 = R.vars('xya1a2b1b2c1c2')
+
+V = Vector(R, 2)
+X, A, B, C = V[x,y], V[a1,a2], V[b1,b2], V[c1,c2]
+
+def line(p1, p2, p3)
+  SquareMatrix.det([[1, *p1], [1, *p2], [1, *p3]])
+end
+
+def vline(p1, p2, p3)
+  (p1-p2).norm2 - (p1-p3).norm2
+end
+
+l1 = vline(X, A, B)
+l2 = vline(X, B, C)
+l3 = vline(X, C, A)
+
+s = line(A, B, C)
+
+g = Groebner.basis [l1, l2, l3, s-1] #s-1 means non degeneracy
+
+g.each do |f|
+  p f
+end
+#x - 1/2a1a2b1 + 1/2a1a2c1 + 1/2a1b1c2 - 1/2a1c1c2 - 1/2a1 - 1/2a2^2b2 + 1/2a2^2c2 + 1/2a2b1^2 - 1/2a2b1c1 + 1/2a2b2^2 - 1/2a2c2^2 - 1/2b1^2c2 + 1/2b1c1c2 - 1/2b2^2c2 + 1/2b2c2^2 - 1/2c1
+#y + 1/2a1^2b1 - 1/2a1^2c1 - 1/2a1b1^2 + 1/2a1c1^2 + 1/2a2^2b1 - 1/2a2^2c1 - 1/2a2b1b2 - 1/2a2b1c2 + 1/2a2b2c1 + 1/2a2c1c2 + 1/2b1^2c1 + 1/2b1b2c2 - 1/2b1c1^2 -1/2b2c1c2 - 1/2b2 - 1/2c2
+#a1b2 - a1c2 - a2b1 + a2c1 + b1c2 - b2c1 - 1

data/sample/sample-geometry03.rb

@@ -0,0 +1,40 @@
+#incenter
+puts "too heavy ... skip (#{$0})"
+exit
+require 'algebra'
+
+R = MPolynomial(Rational)
+x,y,a1,a2,b1,b2,c1,c2 = R.vars('xya1a2b1b2c1c2')
+Q = LocalizedRing(R)
+x0,y0,a10,a20,b10,b20,c10,c20 = R.vars.map{|v| Q[v]}
+V = Vector(R, 2)
+W = Vector(Q, 2)
+X, A, B, C = V[x,y], V[a1,a2], V[b1,b2], V[c1,c2]
+
+def bisector(p1, p2, p3)
+  p1,p2,p3 = [p1,p2,p3].map{|v| v.convert_to(W)}
+  k1 = (p1.inner_product(p2))**2/p2.norm2
+  k2 = (p1.inner_product(p3))**2/p3.norm2
+  (k1-k2).numerator
+end
+
+def line(p1, p2, p3)
+  SquareMatrix.det([[1, *p1], [1, *p2], [1, *p3]])
+end
+
+l1 = bisector(X-A, B-A, C-A)
+p l1
+l2 = bisector(X-B, C-B, A-B)
+p l2
+l3 = bisector(X-C, A-C, B-C)
+p l3
+
+s = line(A, B, C)
+
+g = Groebner.basis [l1, l2, l3, s-1] #s-1 means non degeneracy
+
+g.each do |f|
+  p f
+end
+
+#p g.size > 1

data/sample/sample-geometry04.rb

@@ -0,0 +1,28 @@
+require 'algebra'
+
+R = MPolynomial(Rational)
+x,y,a1,a2,b1,b2,c1,c2 = R.vars('xya1a2b1b2c1c2')
+V = Vector(R, 2)
+X, A, B, C = V[x,y], V[a1,a2], V[b1,b2], V[c1,c2]
+
+def perpendicular(p0, p1, p2, p3)
+  (p0-p1).inner_product(p2-p3)
+end
+
+def line(p1, p2, p3)
+  SquareMatrix.det([[1, *p1], [1, *p2], [1, *p3]])
+end
+
+l1 = perpendicular(X, A, B, C)
+l2 = perpendicular(X, B, C, A)
+l3 = perpendicular(X, C, A, B)
+
+s = line(A, B, C)
+g = Groebner.basis [l1, l2, l3, s-1] #s-1 means non degeneracy
+
+g.each do |f|
+  p f
+end
+#x + a1a2b1 - a1a2c1 - a1b1c2 + a1c1c2 + a2^2b2 - a2^2c2 - a2b1^2 + a2b1c1 - a2b2^2 + a2c2^2 + b1^2c2 - b1c1c2 - b1 + b2^2c2 - b2c2^2
+#y - a1^2b1 + a1^2c1 + a1b1^2 - a1c1^2 - a2^2b1 + a2^2c1 + a2b1b2 + a2b1c2 - a2b2c1 - a2c1c2 - a2 - b1^2c1 - b1b2c2 + b1c1^2 + b2c1c2
+#a1b2 - a1c2 - a2b1 + a2c1 + b1c2 - b2c1 - 1

data/sample/sample-geometry07.rb

@@ -0,0 +1,58 @@
+require "algebra"
+R = MPolynomial(Rational)
+m, b, a = R.vars("mba")
+K = LocalizedRing(R)
+a0, b0, m0 = K[a], K[b], K[m]
+
+M = SquareMatrix(K, 3)
+l0, l1, l2 = M[[0, 1, 0], [1, 1, -1], [1, 0, 0]]
+m4 = M[[a0, 1, -a0], [1, b0, -b0], [m0, -1, 0]]
+m40 = m4.dup; m40.set_row(0, l0)
+m41 = m4.dup; m41.set_row(1, l1)
+m42 = m4.dup; m42.set_row(2, l2)
+
+def mdet(m, i)
+  i = i % 3
+  m.minor(i, 2).determinant * (-1) ** i
+end
+
+def tris(m, i)
+  pts = [0, 1, 2] - [i]
+  (m.determinant)**2 / mdet(m, pts[0]) / mdet(m, pts[1])
+end
+
+u0 = (tris(m4, 0) - tris(m40, 0)).numerator
+u1 = (tris(m4, 1) - tris(m41, 1)).numerator
+u2 = (tris(m4, 2) - tris(m42, 2)).numerator
+
+puts [u0.to_s, u1.to_s, u2.to_s]
+puts
+
+[u0, u1, u2].each do |um|
+  p um.factorize
+end
+puts
+
+x = u0 / a / (m*b+1)
+y = u1 / (m+a) / (b-1)
+z = u2 / (-b*a+1)
+
+p x
+p y
+p z
+puts
+
+gb = Groebner.basis([x, y, z])
+p gb
+# puts gb
+puts
+
+gb.each do |v|
+  p v.factorize
+end
+#(-1)(-mb + m + ba^3 + ba^2 - ba - a^2)
+#(-1)(-ma + m + ba^2 - a^2)
+#(-1)(b + a - 1)(-ba + 1)(a)
+#(-1)(-ba + 1)(a)(a^2 + a - 1)
+
+# => a = -1/2 + \sqrt{5}/2

data/sample/sample-groebner01.rb

@@ -0,0 +1,8 @@
+require "algebra"
+P = MPolynomial(Rational, "xyz")
+x, y, z = P.vars("xyz")
+f1 = x**2 + y**2 + z**2 -1
+f2 = x**2 + z**2 - y
+f3 = x - z
+p Groebner.basis([f1, f2, f3])
+#=> [x - z, y - 2z^2, z^4 + 1/2z^2 - 1/4]

data/sample/sample-groebner02.rb

@@ -0,0 +1,13 @@
+require "algebra"
+
+P = MPolynomial(Rational)
+x, y, z = P.vars "xyz"
+f1 = x**2 + y**2 + z**2 -1
+f2 = x**2 + z**2 - y
+f3 = x - z
+
+coeff, basis = Groebner.basis_coeff([f1, f2, f3])
+basis.each_with_index do |b, i|
+  p [coeff[i].inner_product([f1, f2, f3]), b]
+  p coeff[i].inner_product([f1, f2, f3]) == b #=> true
+end

data/sample/sample-groebner03.rb

@@ -0,0 +1,14 @@
+require "algebra"
+F5 = ResidueClassRing(Integer, 2)
+F = AlgebraicExtensionField(F5, "a") {|a| a**3 + a + 1}
+a = F.var
+P = MPolynomial(F)
+
+x, y, z = P.vars("xyz")
+f1 = x + y**2 + z**2 - 1
+f2 = x**2 + z**2 - y * a
+f3 = x - z - a
+
+f = x**3 + y**3 + z**3
+q, r = f.divmod_s(f1, f2, f3)
+p f == q.inner_product([f1, f2, f3]) + r #=> true

data/sample/sample-group01.rb

@@ -0,0 +1,16 @@
+require "algebra"
+e = Permutation[0, 1, 2, 3, 4]
+a = Permutation[1, 0, 3, 4, 2]
+b = Permutation[0, 2, 1, 3, 4]
+p a * b #=> [2, 0, 3, 4, 1]
+
+g = Group.new(e, a, b)
+g.complete!
+p g == PermutationGroup.symmetric(5) #=> true
+
+
+
+
+
+
+

data/sample/sample-jordan-form01.rb

@@ -0,0 +1,51 @@
+require "algebra"
+
+M4 = SquareMatrix(Rational, 4)
+m = M4[
+    [-1, 1, 2, -1],
+    [-5, 3, 4, -2],
+    [3, -1, 0, 1],
+    [5, -2, -2, 3]
+]
+m.jordan_form.display; #=>
+#  2,   0,   0,   0
+#  0,   1,   1,   0
+#  0,   0,   1,   1
+#  0,   0,   0,   1
+puts
+
+#-----------------------------------
+m = M4[
+  [3, 1, -1, 1],
+  [-3, -1, 3, -1],
+  [-2, -2, 0, 0],
+  [0, 0, -4, 2]
+]
+jf, pt, qt, field, modulus  = m.jordan_form_info
+p modulus #=> [a^2 + 4]
+jf.display; puts #=>
+#  2,   1,   0,   0
+#  0,   2,   0,   0
+#  0,   0,   a,   0
+#  0,   0,   0,  -a
+
+m = m.convert_to(jf.class)
+p jf == pt * m * qt #=> true
+
+#-----------------------------------
+m = M4[
+    [-1, 1, 2, -1],
+    [-5, 3, 4, -2],
+    [3, -1, 0, 1],
+    [5, -2, -2, 0]
+]
+jf, pt, qt, field, modulus  = m.jordan_form_info
+p modulus #=> [a^3 + 3a - 1, b^2 + ab + a^2 + 3]
+jf.display; puts #=>
+#  2,   0,   0,   0
+#  0,   a,   0,   0
+#  0,   0,   b,   0
+#  0,   0,   0, -b - a
+
+m = m.convert_to(jf.class)
+p jf == pt * m * qt #=> true

data/sample/sample-lagrange-multiplier01.rb

@@ -0,0 +1,30 @@
+require 'algebra'
+P = MPolynomial(Rational)
+t, x, y, z = P.vars('txyz')
+f = x**3+2*x*y*z - z**2
+g = x**2 + y**2 + z**2 - 1
+
+fx = f.derivate(x)
+fy = f.derivate(y)
+fz = f.derivate(z)
+
+gx = g.derivate(x)
+gy = g.derivate(y)
+gz = g.derivate(z)
+
+F = [fx - t * gx, fy - t * gy, fz - t * gz, g]
+
+Groebner.basis(F).each do |h|
+  p h.factorize
+end
+
+#(1/7670)(7670t - 11505x - 11505yz - 335232z^6 + 477321z^4 - 134419z^2)
+#x^2 + y^2 + z^2 - 1
+#(1/3835)(3835xy - 19584z^5 + 25987z^3 - 6403z)
+#(1/3835)(3835x + 3835yz - 1152z^4 - 1404z^2 + 2556)(z)
+#(1/3835)(3835y^3 + 3835yz^2 - 3835y - 9216z^5 + 11778z^3 - 2562z)
+#(1/3835)(3835y^2 - 6912z^4 + 10751z^2 - 3839)(z)
+#(1/118)(118y - 1152z^3 + 453z)(z)(z - 1)(z + 1)
+#(1/1152)(z)(z - 1)(3z - 2)(3z + 2)(z + 1)(128z^2 - 11)
+
+

data/sample/sample-m-factorize01.rb

@@ -0,0 +1,10 @@
+require "algebra"
+P = MPolynomial(Integer)
+x, y, z = P.vars("xyz")
+f = x**3 + y**3 + z**3 - 3*x*y*z
+p f.factorize #=> (x + y + z)(x^2 - xy - xz + y^2 - yz + z^2)
+
+PQ = MPolynomial(Rational)
+x, y, z = PQ.vars("xyz")
+f = x**3 + y**3/8 + z**3 - 3*x*y*z/2
+p f.factorize #=> (1/8)(2x + y + 2z)(4x^2 - 2xy - 4xz + y^2 - 2yz + 4z^2)

data/sample/sample-m-factorize02.rb

@@ -0,0 +1,7 @@
+require "algebra"
+
+Z7 = ResidueClassRing(Integer, 7)
+P = MPolynomial(Z7)
+x, y, z = P.vars("xyz")
+f = x**3 + y**3 + z**3 - 3*x*y*z
+p f.factorize #=> (x + 4y + 2z)(x + 2y + 4z)(x + y + z)

data/sample/sample-m-polynomial01.rb

@@ -0,0 +1,5 @@
+require "algebra"
+P = MPolynomial(Integer)
+x, y, z, w = P.vars("xyz")
+p((-x + y + z)*(x + y - z)*(x - y + z))
+#=> -x^3 + x^2y + x^2z + xy^2 - 2xyz + xz^2 - y^3 + y^2z + yz^2 - z^3

data/sample/sample-map01.rb

@@ -0,0 +1,4 @@
+require "algebra"
+a = Map[0=>2, 1=>2, 2=>0]
+b = Map[0=>1, 1=>1, 2=>1]
+p a * b #=> {0=>2, 1=>2, 2=>2}

data/sample/sample-polynomial01.rb

@@ -0,0 +1,4 @@
+require "algebra"
+P = Polynomial.create(Integer, "x")
+x = P.var
+p((x + 1)**100) #=> x^100 + 100x^99 + ... + 100x + 1

data/sample/sample-polynomial02.rb

@@ -0,0 +1,6 @@
+require "algebra"
+P = Polynomial(Integer, "x", "y", "z")
+x, y, z = P.vars
+p((-x + y + z)*(x + y - z)*(x - y + z))
+#=> -z^3 + (y + x)z^2 + (y^2 - 2xy + x^2)z - y^3 + xy^2 + x^2y - x^3
+

data/sample/sample-primefield01.rb

@@ -0,0 +1,8 @@
+require "algebra"
+Z13 = ResidueClassRing(Integer, 13)
+
+a, b, c, d, e, f, g = Z13
+p [e + c, e - c, e * c, e * 2001, 3 + c, 1/c, 1/c * c, d / d, b * 1 / b]
+  #=> [6, 2, 8, 9, 5, 7, 1, 1, 1]
+p( (1...13).collect{|i|  Z13[i]**12} )
+  #=> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

data/sample/sample-quotientfield01.rb

@@ -0,0 +1,6 @@
+require "algebra"
+Q = LocalizedRing(Integer)
+a = Q.new(3, 5)
+b = Q.new(5, 3)
+p [a + b, a - b, a * b, a / b, a + 3, 1 + a]
+  #=> [34/15, -16/15, 15/15, 9/25, 18/5, 8/5]

data/sample/sample-quotientfield02.rb

@@ -0,0 +1,13 @@
+require "algebra"
+
+F13 = ResidueClassRing(Integer, 13)
+
+P = Polynomial(F13, "x")
+Q = LocalizedRing(P)
+x = Q[P.var]
+p ( 1 / (x**2 - 1) - 1 / (x**3 - 1) )
+
+#This is equivalent to the following
+F = RationalFunctionField(F13, "x")
+x = F.var
+p ( 1 / (x**2 - 1) - 1 / (x**3 - 1) )

data/sample/sample-quotientfield03.rb

@@ -0,0 +1,11 @@
+require "algebra"
+
+F13 = ResidueClassRing(Integer, 13)
+F = AlgebraicExtensionField(F13, "a") {|a| a**2 - 2}
+a = F.var
+RF = RationalFunctionField(F, "x")
+x = RF.var
+
+p( (a/4*x + RF.unity/2)/(x**2 + a*x + 1) +
+  (-a/4*x + RF.unity/2)/(x**2 - a*x + 1) )
+#=> 1/(x**4 + 1)

data/sample/sample-quotientfield04.rb

@@ -0,0 +1,11 @@
+require "algebra"
+
+F13 = ResidueClassRing(Integer, 13)
+F = RationalFunctionField(F13, "x")
+x = F.var
+AF = AlgebraicExtensionField(F, "a") {|a| a**2 - 2*x}
+a = AF.var
+
+p( (a/4*x + AF.unity/2)/(x**2 + a*x + 1) +
+  (-a/4*x + AF.unity/2)/(x**2 - a*x + 1) )
+#=> (-x^3 + x^2 + 1)/(x^4 + 11x^3 + 2x^2 + 1)

data/sample/sample-set01.rb

@@ -0,0 +1,13 @@
+require "algebra"
+#intersection
+p Set[0, 1, 2, 4] & Set[1, 3, 5] == Set[1]
+p Set[0, 1, 2, 4] & Set[7, 3, 5] == Set.phi
+
+#union
+p Set[0, 1, 2, 4] | Set[1, 3, 5] == Set[0, 1, 2, 3, 4, 5]
+
+#membership
+p Set[1, 3, 2].has?(1)
+
+#inclusion
+p Set[3, 2, 1, 3] < Set[3, 1, 4, 2, 0]

data/sample/sample-splitting-field01.rb

@@ -0,0 +1,14 @@
+require "algebra"
+
+PQ = Polynomial(Rational, "x")
+x = PQ.var
+f = x**4 + 2
+p f #=> x^4 + 2
+field, modulus, facts = f.decompose
+p modulus #=> [a^4 + 2, b^2 + a^2]
+p facts #=> (x - a)(x + a)(x - b)(x + b)
+
+fp = Polynomial(field, "x")
+x = fp.var
+facts = Factors.new(facts.collect{|g, n| [g.evaluate(x), n]})
+p facts.pi == f.convert_to(fp) #=> true

data/sample/test-00-cayley-hamilton.rb

@@ -0,0 +1,76 @@
+# Test of Cayley-Hamilton's Theory
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.0 (2001.04.08)
+
+require "algebra/matrix-algebra"
+require "algebra/m-polynomial"
+require "algebra/polynomial"
+require "algebra/polynomial-converter"
+include Algebra
+
+n = Integer(ARGV.shift || 2)
+$mul = ARGV.shift
+case n
+when 2
+  unless $mul
+    R = MPolynomial(Integer)
+    a, b, c, d = R.vars("abcd")
+  else
+    R = Polynomial.over(Integer, *"abcd".scan(/./))
+    a, b, c, d = R.vars
+  end
+  Rx = Polynomial(R, "x")
+  x = Rx.var
+
+  M2 = SquareMatrix(Rx, 2)
+  m = M2[
+    [a, b],
+    [c, d]
+  ]
+when 3
+  unless $mul
+    R = MPolynomial(Integer)
+    a, b, c, d, e, f, g, h, i, j = R.vars("abcdefghij")
+  else
+    R = Polynomial.over(Integer, *"abcdefghi".scan(/./))
+    a, b, c, d, e, f, g, h, i = R.vars
+  end
+  Rx = Polynomial(R, "x")
+  x = Rx.var
+
+  M3 = SquareMatrix(Rx, 3)
+  m = M3[
+    [a, b, c],
+    [d, e, f],
+    [g, h, i]
+  ]
+else
+  unless $mul
+    if true
+      R = MPolynomial(Integer)
+      MR = SquareMatrix(R, n)
+      m = MR.matrix{|i, j| R.var("x#{i}#{j}") }
+      Rx = Polynomial(R, "x")
+      ch = m.char_polynomial(Rx)
+      p ch.evaluate(m)
+      exit
+    else
+      R = MPolynomial(Integer)
+      Rx = Polynomial(R, "x")
+      M = SquareMatrix(Rx, n)
+      m = M.matrix{|i, j| R.var("x#{i}#{j}") }
+      x = Rx.var
+    end
+  else
+    puts "not implemented."
+    exit
+  end
+end
+
+p m
+p (x - m)
+det = (x - m).determinant
+p det
+p det.evaluate(m)