class Algebra::Group

Attributes

unity[R]

include OperatorDomain

Public Class Methods

generate_strong(u, *ary_of_gens) click to toggle source
# File lib/algebra/finite-group.rb, line 175
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
new(u, *a) click to toggle source
Calls superclass method Algebra::Set::new
# File lib/algebra/finite-group.rb, line 147
def initialize(u, *a)
  super(u, *a)
  @unity = u
end

Public Instance Methods

D(n = 1) click to toggle source
# File lib/algebra/finite-group.rb, line 298
def D(n = 1)
  if n == 0
    self
  else
    D(n - 1).commutator D(n - 1)
  end
end
K(n = 1) click to toggle source
# File lib/algebra/finite-group.rb, line 314
def K(n = 1)
  if n == 0
    self
  else
    commutator K(n - 1)
  end
end
Z(n = 1) click to toggle source
# File lib/algebra/finite-group.rb, line 328
def Z(n = 1)
  if n == 0
    unit_group
  else
    separate do |x|
      commutator(Set[x]) <= Z(n - 1)
    end
  end
end
ascending_central_series() click to toggle source
# File lib/algebra/finite-group.rb, line 338
def ascending_central_series
  increasing_series(&:Z)
end
center() click to toggle source
# File lib/algebra/finite-group.rb, line 236
def center # C_{self}(self)
  centralizer(self)
end
center?(x) click to toggle source
# File lib/algebra/finite-group.rb, line 240
def center?(x) # self == C_{self}(x)
  all? { |y| x * y == y * x }
end
centralizer(s) click to toggle source
# File lib/algebra/finite-group.rb, line 232
def centralizer(s) # C_{self}(s) not C_{s}(self) !!!!
  separate { |x| s.all? { |y| x * y == y * x } }
end
closed?() click to toggle source
# File lib/algebra/finite-group.rb, line 193
def closed?
  each do |x|
    return false unless include? x.inverse
    each do |y|
      return false unless include?(x * y)
    end
  end
  true
end
commutator(h = self) click to toggle source
# File lib/algebra/finite-group.rb, line 288
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
commutator_series() click to toggle source
# File lib/algebra/finite-group.rb, line 306
def commutator_series
  decreasing_series(&:D)
end
complete() click to toggle source
# File lib/algebra/finite-group.rb, line 171
def complete
  dup.complete!
end
complete!() click to toggle source
# File lib/algebra/finite-group.rb, line 166
def complete!
  concat collect(&:inverse)
  orbit!(self)
end
conjugacy_class(x) click to toggle source
# File lib/algebra/finite-group.rb, line 265
def conjugacy_class(x)
  (self % centralizer(Set[x])).map_s { |y| x.conjugate(y) }
end
conjugacy_classes() { |x| ... } click to toggle source
# File lib/algebra/finite-group.rb, line 269
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
descending_central_series() click to toggle source
# File lib/algebra/finite-group.rb, line 322
def descending_central_series
  decreasing_series do |s|
    commutator s
  end
end
nilpotency_class() click to toggle source
# File lib/algebra/finite-group.rb, line 347
def nilpotency_class
  a = descending_central_series
  a.size - 1 if a.last.size == 1
end
nilpotent?() click to toggle source
# File lib/algebra/finite-group.rb, line 342
def nilpotent?
  descending_central_series.last.size == 1
  # ascending_central_series.last.size == size
end
normal?(s) click to toggle source
# File lib/algebra/finite-group.rb, line 248
def normal?(s)
  all? { |x| s.right_act(Set[x]) == s.left_act(Set[x]) }
end
normal_subgroups() { |x| ... } click to toggle source
# File lib/algebra/finite-group.rb, line 252
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
normalizer(s) click to toggle source
# File lib/algebra/finite-group.rb, line 244
def normalizer(s)
  separate { |x| s.right_act(Set[x]) == s.left_act(Set[x]) }
end
quotient_group(u) click to toggle source
# File lib/algebra/finite-group.rb, line 138
def quotient_group(u)
  #      raise "devided by non normal sub group" unless normal?(u)
  QuotientGroup.new(self, u)
end
semi_complete() click to toggle source
# File lib/algebra/finite-group.rb, line 162
def semi_complete
  dup.semi_complete!
end
semi_complete!() click to toggle source
# File lib/algebra/finite-group.rb, line 158
def semi_complete!
  orbit!(self)
end
separate(&b) click to toggle source
# File lib/algebra/finite-group.rb, line 143
def separate(&b)
  self.class.new(unity, *find_all(&b))
end
simple?() click to toggle source
# File lib/algebra/finite-group.rb, line 281
def simple?
  subgroups.all? do |x|
    x.size == 1 || x.size == size ||
      !normal?(x)
  end
end
solvable?() click to toggle source
# File lib/algebra/finite-group.rb, line 310
def solvable?
  commutator_series.last.size == 1
end
subgroups() { |e| ... } click to toggle source
# File lib/algebra/finite-group.rb, line 203
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
to_a() click to toggle source
Calls superclass method Algebra::Set#to_a
# File lib/algebra/finite-group.rb, line 352
def to_a
  [unity, *(super - [unity])]
end
unit_group() click to toggle source
# File lib/algebra/finite-group.rb, line 154
def unit_group
  self.class.new(@unity)
end

Private Instance Methods

_subgroups(h, subgrs) { |i| ... } click to toggle source
# File lib/algebra/finite-group.rb, line 212
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