algebra 0.2.1

data/lib/algebra/finite-group.rb

@@ -0,0 +1,374 @@
+# Finite Group
+#
+#   by Shin-ichiro Hara
+#
+# Version 0.9 (2002.03.12)
+
+require 'algebra/finite-set'
+require 'algebra/prime-gen'
+
+module Algebra
+  module OperatorDomain
+    def right_act(other)
+      cast.product(other.cast) { |x, y| x * y }
+      #      product(other, self.class[unity]) {|x, y| x * y}
+    end
+
+    alias act right_act
+
+    def left_act(other)
+      other.right_act(self)
+    end
+
+    def right_quotient(other)
+      s = Set.phi
+      remain = cast.dup
+      until remain.empty?
+        x = remain.shift
+        t = Set[x].right_act(other)
+        s.push t
+        remain -= t
+      end
+      s
+    end
+
+    alias quotient right_quotient
+    alias right_coset right_quotient
+    alias coset right_quotient
+
+    def left_quotient(other)
+      s = Set.phi
+      remain = cast.dup
+      until remain.empty?
+        x = remain.shift
+        t = Set[x].left_act(other)
+        s.push t
+        remain -= t
+      end
+      s
+    end
+
+    alias left_coset left_quotient
+
+    def right_representatives(other)
+      s = Set.phi
+      remain = cast.dup
+      until remain.empty?
+        x = remain.shift
+        t = self.class[x].act(other)
+        s.push x
+        remain -= t
+      end
+      s
+    end
+
+    alias representatives right_representatives
+
+    def left_representatives(other)
+      s = Set.phi
+      remain = cast.dup
+      until remain.empty?
+        x = remain.shift
+        t = self.class[x].left_act(other)
+        s.push x
+        remain -= t
+      end
+      s
+    end
+
+    def right_orbit!(other)
+      news = Set.phi
+      loop do
+        each_product(other) do |x, y|
+          z = x * y
+          news.push z unless include?(z) || news.include?(z)
+        end
+        if news.empty?
+          break
+        else
+          concat news
+          news = Set.phi
+        end
+      end
+      self
+    end
+
+    alias orbit! right_orbit!
+
+    def left_orbit!(other)
+      other.right_orbit!(self)
+    end
+  end
+
+  class Set
+    include OperatorDomain
+    alias * act
+    alias / quotient
+    alias % representatives
+
+    def increasing_series(x = unit_group)
+      a = []
+      loop do
+        a.push x
+        if x >= (y = yield x)
+          break
+        end
+        x = y
+      end
+      a
+    end
+
+    def decreasing_series(x = self)
+      a = []
+      loop do
+        a.push x
+        if x <= (y = yield x)
+          break
+        end
+        x = y
+      end
+      a
+    end
+  end
+
+  class Group < Set
+    #    include OperatorDomain
+    attr_reader :unity
+
+    def quotient_group(u)
+      #      raise "devided by non normal sub group" unless normal?(u)
+      QuotientGroup.new(self, u)
+    end
+
+    def separate(&b)
+      self.class.new(unity, *find_all(&b))
+    end
+
+    def initialize(u, *a)
+      super(u, *a)
+      @unity = u
+    end
+
+    attr_reader :unity
+
+    def unit_group
+      self.class.new(@unity)
+    end
+
+    def semi_complete!
+      orbit!(self)
+    end
+
+    def semi_complete
+      dup.semi_complete!
+    end
+
+    def complete!
+      concat collect(&:inverse)
+      orbit!(self)
+    end
+
+    def complete
+      dup.complete!
+    end
+
+    def self.generate_strong(u, *ary_of_gens)
+      unless a = ary_of_gens.shift
+        return new(u)
+      end
+      a.first != u && (a = [u] + a)
+      while b = ary_of_gens.shift
+        b.first != u && (b = [u] + b)
+        c = []
+        a.each do |x|
+          b.each do |y|
+            c.push x * y
+          end
+        end
+        a = c
+      end
+      new(*a)
+    end
+
+    def closed?
+      each do |x|
+        return false unless include? x.inverse
+        each do |y|
+          return false unless include?(x * y)
+        end
+      end
+      true
+    end
+
+    def subgroups(&b)
+      e = unit_group
+      yield e if block_given?
+      subgrs = Set[e, self]
+      _subgroups(e, subgrs, &b)
+      yield self if block_given?
+      subgrs
+    end
+
+    def _subgroups(h, subgrs, &b)
+      loop do
+        new_elem = false
+        (cast - h).representatives(h).each do |a|
+          i = h.append(a).complete!
+          next if i.size == size
+          next if subgrs.include? i
+          new_elem = true
+          subgrs.push i
+          yield i if block_given?
+          if defined?(Primes) && Primes.include?(size / i.size)
+          else
+            _subgroups(i, subgrs, &b)
+          end
+        end
+        break unless new_elem
+      end
+    end
+    private :_subgroups
+
+    def centralizer(s) # C_{self}(s) not C_{s}(self) !!!!
+      separate { |x| s.all? { |y| x * y == y * x } }
+    end
+
+    def center # C_{self}(self)
+      centralizer(self)
+    end
+
+    def center?(x) # self == C_{self}(x)
+      all? { |y| x * y == y * x }
+    end
+
+    def normalizer(s)
+      separate { |x| s.right_act(Set[x]) == s.left_act(Set[x]) }
+    end
+
+    def normal?(s)
+      all? { |x| s.right_act(Set[x]) == s.left_act(Set[x]) }
+    end
+
+    def normal_subgroups
+      s = Set.phi
+      subgroups.each do |x|
+        if x.size == 1 ||
+           x.size == size ||
+           normal?(x)
+          yield x if block_given?
+          s.push x
+        end
+      end
+      s
+    end
+
+    def conjugacy_class(x)
+      (self % centralizer(Set[x])).map_s { |y| x.conjugate(y) }
+    end
+
+    def conjugacy_classes
+      s = Set.phi
+      t = cast
+      until t.empty?
+        x = conjugacy_class(t.pick)
+        yield x if block_given?
+        s.push x
+        t -= x
+      end
+      s
+    end
+
+    def simple?
+      subgroups.all? do |x|
+        x.size == 1 || x.size == size ||
+          !normal?(x)
+      end
+    end
+
+    def commutator(h = self)
+      gr = unit_group
+      each do |x|
+        h.each do |y|
+          gr.push x.inverse * y.inverse * x * y
+        end
+      end
+      self == h ? gr.semi_complete! : gr.complete!
+    end
+
+    def D(n = 1)
+      if n == 0
+        self
+      else
+        D(n - 1).commutator D(n - 1)
+      end
+    end
+
+    def commutator_series
+      decreasing_series(&:D)
+    end
+
+    def solvable?
+      commutator_series.last.size == 1
+    end
+
+    def K(n = 1)
+      if n == 0
+        self
+      else
+        commutator K(n - 1)
+      end
+    end
+
+    def descending_central_series
+      decreasing_series do |s|
+        commutator s
+      end
+    end
+
+    def Z(n = 1)
+      if n == 0
+        unit_group
+      else
+        separate do |x|
+          commutator(Set[x]) <= Z(n - 1)
+        end
+      end
+    end
+
+    def ascending_central_series
+      increasing_series(&:Z)
+    end
+
+    def nilpotent?
+      descending_central_series.last.size == 1
+      # ascending_central_series.last.size == size
+    end
+
+    def nilpotency_class
+      a = descending_central_series
+      a.size - 1 if a.last.size == 1
+    end
+
+    def to_a
+      [unity, *(super - [unity])]
+    end
+  end
+
+  # will be optimized
+  class QuotientGroup < Group
+    def initialize(univ, u)
+      @univ = univ
+      super(u, *univ.quotient(u))
+    end
+
+    def inverse
+      map_s(&:inverse)
+    end
+
+    alias inv inverse
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+
+end

data/lib/algebra/finite-map.rb

@@ -0,0 +1,201 @@
+# Map of Finite Sets
+#
+#   by Shin-ichiro Hara
+#
+# Version 0.96 (2003.11.06)
+
+require 'algebra/finite-set'
+require 'algebra/powers'
+
+module Algebra
+  class Map < Set
+    include Powers
+
+    def self.[](a = {})
+      new.instance_eval do
+        @body = Hash[a]
+        self
+      end
+    end
+
+    def self.new_a(a)
+      self[Hash[*a]]
+    end
+
+    def initialize(h = {})
+      @body = h
+    end
+
+    def self.empty_set(t = nil)
+      m = new
+      m.target = t if t
+      m
+    end
+
+    class << self
+      alias phi empty_set
+      alias null empty_set
+    end
+
+    def self.singleton(x, y)
+      new(x => y)
+    end
+
+    def base_class
+      self.class.superclass
+    end
+
+    def each(&b)
+      @body.each(&b)
+    end
+
+    def empty_set(s = nil)
+      self.class.empty_set(s)
+    end
+
+    alias phi empty_set
+    alias null empty_set
+
+    def dup
+      m = self.class.new(@body.dup)
+      m.target = target if target
+      m
+    end
+
+    def call(x)
+      @body.fetch(x)
+    end
+
+    alias act call
+    alias [] call
+
+    def append!(x, y)
+      @body.store(x, y)
+      self
+    end
+
+    alias []= append!
+
+    def append(x, y)
+      dup.append!(x, y)
+    end
+
+    def hash
+      s = 0
+      @body.each_key do |k, v|
+        s ^= k.hash ^ ~v.hash
+      end
+      s
+    end
+
+    def member?(a)
+      return nil unless a.is_a? Array
+      @body[a.first] == a.last
+    end
+
+    alias has? member?
+
+    def domain
+      base_class.new(*@body.keys)
+    end
+
+    def image(set = nil)
+      if set
+        set.map_s { |k| call(k) }
+      else
+        base_class.new(*@body.values)
+      end
+    end
+
+    def map_s
+      s = base_class.phi
+      each do |x, y|
+        s.append!(yield(x, y))
+      end
+      s
+    end
+
+    def map_m
+      s = phi
+      each do |x, y|
+        s.append!(* yield(x, y))
+      end
+      s
+    end
+
+    def inverse
+      self.class.new(@body.invert)
+    end
+
+    def compose(other) # LEFT ACTION!!!
+      m = other.map_m { |x, y| [x, call(y)] }
+      m.target = target
+      m
+    end
+
+    alias * compose
+
+    #  module Map_common
+
+    attr_accessor :target
+    alias source domain
+    alias codomain target
+    alias codomain= target=
+
+    def identity?
+      all? { |x, y| x == y }
+    end
+
+    def surjective?
+      raise 'target is not defined.' unless @target
+      image.size == target.size
+    end
+
+    def injective?
+      image.size == source.size
+    end
+
+    def bijective?
+      surjective? && injective?
+    end
+
+    def inv_image(s)
+      source.separate { |x| s.member? act(x) }
+    end
+
+    def inv_coset
+      s = phi
+      if target
+        target.each do |y|
+          s.append!(y, base_class.phi)
+        end
+      end
+      each do |x, y|
+        if s.include? y
+          s.call(y) << x
+        else
+          s.append!(y, base_class.singleton(x))
+        end
+      end
+      s
+    end
+
+    def inspect
+      @body.inspect
+    end
+
+    def to_s
+      @body.inspect
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'algebra/permutation-group'
+
+  a = Algebra::Set[0, 1, 2]
+  b = Algebra::Set[0, 1, 2]
+  (a**b).each do |x|
+    p x
+  end
+end