algebra 0.2.1

data/lib/algebra/numeric-supplement.rb

@@ -0,0 +1,123 @@
+# Numeric Supplements
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.01 (2001.04.10)
+
+class Numeric
+  def self.unity
+    1
+  end
+
+  def self.zero
+    0
+  end
+
+  def zero
+    self.class.zero
+  end
+
+  def unity
+    self.class.unity
+  end
+
+  def self.indeterminate(x)
+    eval(x)
+  end
+
+  def self.const(x)
+    x
+  end
+
+  def each; end
+
+  def pdivmod(other)
+    divmod(other)
+  end
+
+  def unity?
+    self == 1
+  end
+
+  def unit?
+    self == unity || self == -unity
+  end
+
+  def monomial?
+    true
+  end
+
+  def inverse
+    self == -1 ? -1 : 1
+  end
+
+  def self.field?
+    true
+  end
+
+  def self.euclidian?
+    true
+  end
+
+  def self.ufd?
+    true
+  end
+
+  def self.regulate(x)
+    #    if x.is_a? self
+    if x.is_a? Numeric
+      x # Numeric's can be operated each other.
+    end
+  end
+
+  def regulate(x)
+    self.class.regulate(x)
+  end
+  private :regulate
+end
+
+class Integer < Numeric
+  def self.ground
+    self
+  end
+
+  def self.field?
+    false
+  end
+
+  #  def self.field?; respond_to?(:from_prime_division); end #mathn loaded
+  def self.euclidian?
+    true
+  end
+
+  def devide?(other)
+    case other
+    when Integer
+      (other % self).zero?
+    else
+      # this case will occur when mathn is required
+      (other / self) * self == other
+      #      raise "devide?: unkown self.class(#{other})"
+    end
+  end
+end
+
+class Float < Numeric
+  def self.unity
+    1.0
+  end
+
+  def self.zero
+    0.0
+  end
+end
+
+class Complex < Numeric
+  def self.unity
+    new(1)
+  end
+
+  def self.zero
+    new(0)
+  end
+end

data/lib/algebra/permutation-group.rb

@@ -0,0 +1,257 @@
+# Permutation Group
+#
+#   by Shin-ichiro Hara
+#
+# Version 0.90 (2002.03.12)
+
+require 'algebra/powers'
+require 'algebra/combinatorial'
+require 'algebra/finite-group'
+
+module Algebra
+  class PermutationGroup < Group
+    def self.unit_group(d)
+      self[unity(d)]
+    end
+
+    def self.unity(n)
+      Permutation.unity(n)
+    end
+
+    def self.perm(a)
+      Permutation.new(a)
+    end
+
+    def self.symmetric(n)
+      s = new(unity(n))
+      Combinatorial.perm(n) do |x|
+        s << perm(x) # unity is not duplicated naturally
+      end
+      s
+    end
+
+    def self.alternate(n)
+      symmetric(n).separate { |x| x.sign > 0 } # slow two times
+    end
+
+    def initialize(u, *a)
+      @degree = u.degree
+      super(u, *a)
+    end
+
+    attr_reader :degree
+  end
+
+  class Permutation
+    include Enumerable
+    include Powers
+
+    def self.[](*a)
+      new(a)
+    end
+
+    def self.unity(d)
+      new((0...d).to_a)
+    end
+
+    def initialize(x)
+      @perm = x
+    end
+
+    attr_accessor :perm
+
+    def unity
+      self.class.unity(@perm.size)
+    end
+
+    def degree
+      @perm.size
+    end
+
+    alias size degree
+
+    def each(&b)
+      @perm.each(&b)
+    end
+
+    def eql?(other)
+      @perm.eql?(other.perm)
+    end
+
+    alias == eql?
+
+    def hash
+      @perm.hash
+    end
+
+    def inspect
+      @perm.inspect
+    end
+
+    def to_s
+      @perm.inspect
+    end
+
+    def [](i)
+      @perm[i] || i
+    end
+
+    alias call []
+
+    #  def []=(i, x); @perm[i] = x;  end
+
+    def index(i)
+      @perm.index(i)
+    end
+
+    def right_act(other) # permutation's traditional product (g*h)[x] == h[g[x]]
+      self.class.new(collect { |i| other[i] })
+    end
+
+    alias * right_act
+
+    def left_act(other)
+      self.class.new(other.collect { |i| self[i] })
+    end
+
+    #    alias * left_act
+
+    def inverse
+      self.class.new((0...degree).collect { |i| index(i) })
+    end
+
+    alias inv inverse
+
+    def sign
+      a = perm.dup
+      b = inverse.perm
+      s = 1
+      (0...(degree - 1)).each do |i|
+        next unless (j = a[i]) != i
+        a[b[i]] = j
+        b[j] = b[i]
+        s = -s
+      end
+      s
+    end
+
+    def conjugate(g)
+      g * self * g.inverse
+    end
+
+    def decompose_cyclic
+      s = []
+      remain = (0...size).to_a
+      while f = remain.shift
+        a = [f]
+        i = f
+        loop do
+          j = self[i]
+          if j == f
+            s.push a if a.size > 1
+            break
+          else
+            remain.delete j
+            a.push j
+            i = j
+          end
+        end
+      end
+      s
+    end
+
+    #---------------------------- beta
+
+    #    def self.load(file)
+    #      s = Group[]
+    #      File.foreach(file) do |line|
+    #	g = eval(line).self
+    #	s.set_unity g unless s.unity
+    #	s.push g
+    #      end
+    #      s
+    #    end
+
+    #    def self.subgr_load(file)
+    #      s = Set[]
+    #      File.foreach(file) do |line|
+    #	s.push eval(line).collect{|perm| perm.self}.Group
+    #      end
+    #      s
+    #    end
+
+    #    def conjugate0(g)
+    #      to_Mapa.collect{|pr| [g[pr.first], g[pr.last]]}.Mapa.to_ParmGr
+    #    end
+
+    #    require "algebra/finite-map"
+
+    def to_map
+      m = Map.phi
+      @perm.each_with_index do |x, i|
+        m.append!(i, x)
+      end
+      m
+    end
+
+    def decompose_transposition
+      a = []
+      (0...degree).each do |i|
+        a << [i, self[i]]
+      end
+      r = []
+      loop do
+        a.delete_if { |i, x| i == x }
+        break if a.empty?
+        i, x = a.shift
+        x, j = alpha = a.assoc(x)
+        a.delete(alpha)
+        unless j == i
+          a.rassoc(i)[1] = j
+          r.unshift [i, j]
+        end
+        r.unshift [i, x]
+      end
+      r
+    end
+
+    def self.cyclic2perm(c, n = nil)
+      n = c.flatten.max + 1 unless n
+      a = (0...n).collect do |i|
+        c.each do |b|
+          if j = b.index(i)
+            i = b[(j + 1) % b.size]
+          end
+        end
+        i
+      end
+      new(a)
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  include Algebra
+  a = [
+    [Permutation[1, 0, 2], Permutation[2, 0, 1]],
+    [Permutation[0, 2, 1]]
+  ]
+  PermutationGroup.generate_strong(Permutation.unity(3), *a).each do |x|
+    p x
+  end
+  puts
+
+  S3 = PermutationGroup.symmetric(3)
+  S3.each do |x|
+    p x
+  end
+  puts
+
+  G = PermutationGroup.generate_strong(Permutation.unity(3),
+                                       [Permutation[1, 2, 0]],
+                                       [Permutation[2, 0, 1]])
+  G.each do |x|
+    p x
+  end
+  puts
+end

data/lib/algebra/polynomial-converter.rb

@@ -0,0 +1,193 @@
+# String <=> Polynomial <=> MPolynomial translator
+#
+#   by Shin-ichiro Hara
+#
+# Version 2.0 (2001.04.08)
+
+require 'algebra/m-polynomial'
+require 'algebra/polynomial'
+require 'algebra/residue-class-ring'
+
+module Algebra
+  module PolynomialConvertTo
+    def convert_to(other)
+      if other <= MPolynomial
+        g = self
+        vs = []
+        while g <= Polynomial
+          vs.push g.variable
+          #	vs.push g.var
+          g = g.ground
+        end
+        MPolynomial.create(g, *vs)
+      else
+        raise "unkown self.class (#{other})"
+      end
+    end
+  end
+
+  module PolynomialConverter
+    def value_on(ring)
+      e = ring.zero
+      #    x = ring.var(var)
+      x = ring.var(variable)
+      reverse_each do |c|
+        e = e * x + (ground <= Polynomial ? c.value_on(ring) : c)
+      end
+      e
+    end
+
+    def var_swap
+      k = Algebra.Polynomial(ground.ground, self.class.variable)
+      ring = Algebra.Polynomial(k, ground.variable)
+      e = ring.zero
+      x = ring.var
+      y = ring.ground.var
+      reverse_each do |c|
+        e = e * y + c.evaluate(x)
+      end
+      e
+    end
+  end
+
+  module MPolynomialConvertTo
+    def convert_to(other)
+      if other <= Polynomial
+        #	Polynomial.create(ground, *(variables))
+        Polynomial.create(ground, *variables.reverse)
+      else
+        raise "unkown self.class (#{other})"
+      end
+    end
+  end
+
+  module MPolynomialConverter
+    def value_on(ring)
+      e = ring.zero
+      each do |idx, c|
+        e += value_on_idx(idx, ring, c)
+      end
+      e
+    end
+
+    def value_on_idx(idx, ring, c)
+      vars = ring.vars.reverse
+      #      vars = ring.vars
+      e = ring.unity
+      idx.each_with_index do |n, i|
+        e *= vars[i]**n
+      end
+      e * c
+    end
+  end
+
+  #  class ResidueClassRing
+  #    def abs_lift(depth, mring = nil)
+  #      unless mring
+  #	r = self.class
+  #	depth.times do
+  #	  r = r.ground.ground
+  #	end
+  #	mring = Algebra.MPolynomial(r)
+  #	depth.times do |n|
+  #	  mring.var("x#{n}")
+  #	end
+  #      end
+  #
+  #      s = mring.zero
+  #      if depth > 1
+  #	lift.each_with_index do |c, n|
+  #	  s += c.abs_lift(depth-1, mring) * mring.vars[depth-1]**n
+  #	end
+  #      else
+  #	lift.each_with_index do |c, n|
+  #	  s += c * mring.vars[depth-1]**n
+  #	end
+  #      end
+  #      s
+  #    end
+  #  end
+
+  #  class Polynomial
+  #    def abs_lift(depth)
+  #      r = ground
+  #      (depth-1).times do
+  #	r = r.ground.ground
+  #      end
+  #      mring = Algebra.MPolynomial(r)
+  #      depth.times do |n|
+  #	mring.var("x#{n}")
+  #      end
+  #
+  #      s = mring.zero
+  #      if depth > 1
+  #	each_with_index do |c, n|
+  #	  s += c.abs_lift(depth-1, mring) * mring.vars[depth-1]**n
+  #	end
+  #      else
+  #	each_with_index do |c, n|
+  #	  s += c * mring.vars[depth-1]**n
+  #	end
+  #      end
+  #      s
+  #    end
+  #  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  #  MPolynomial.extend Polynomial2Polynomial
+  #  Polynomial.extend Polynomial2Polynomial
+
+  #  require "algebra/auto-require"
+  require 'algebra/rational'
+  require 'algebra/algebraic-extension-field'
+  A = Algebra.AlgebraicExtensionField(Rational, 'a') do |a|
+    a**3 - 2
+  end
+  a = A.var
+  B = Algebra.AlgebraicExtensionField(A, 'b') do |b|
+    a**2 + a * b + b**2
+  end
+  b = B.var
+  f = (a - b + 1)**2
+  p f
+  p f.abs_lift # (2)
+
+  P = Algebra::Polynomial.create(Integer, 'x', 'y', 'z')
+  x, y, z = P.vars
+  f = x**2 + y**2 + z**2 - x * y - y * z - z * x
+  #  Algebra::MPolynomial.instance_eval do
+  #    p AUTO_LOAD
+  #  end
+  #  P.instance_eval do
+  #    p ['try convert_to', self, AUTO_LOAD]
+  #  end
+  MP = P.convert_to(Algebra::MPolynomial)
+  x, y, z = MP.vars
+  g = x**2 + y**2 + z**2 - x * y - y * z - z * x
+  p f = f.value_on(MP) #=> z^2 - zy - zx + y^2 - yx + x^2
+  p f == g             #=> true
+
+  P0 = MP.convert_to(Algebra::Polynomial)
+  x, y, z = P0.vars
+  g = x**2 + y**2 + z**2 - x * y - y * z - z * x
+  p f = f.value_on(P0)
+  p f == g
+
+  Px = Algebra.Polynomial(Integer, 'x')
+  x = Px.var
+  Pxy = Algebra.Polynomial(Px, 'y')
+  y0 = Pxy.var
+
+  Py = Algebra.Polynomial(Integer, 'y')
+  y = Py.var
+  Pyx = Algebra.Polynomial(Py, 'x')
+  x0 = Pyx.var
+
+  f = y0**2 * x - y0**3 * x**2
+  g = y**2 * x0 - y**3 * x0**2
+  p f
+  p g
+  p f.var_swap
+  puts 'END.'
+end