From: "boris_stitnicky (Boris Stitnicky)" <boris@...>
Date: 2013-04-07T18:25:13+09:00
Subject: [ruby-core:54079] [ruby-trunk - Feature #8232][Open] Rudiments of abstract algebra in Ruby


Issue #8232 has been reported by boris_stitnicky (Boris Stitnicky).

----------------------------------------
Feature #8232: Rudiments of abstract algebra in Ruby
https://bugs.ruby-lang.org/issues/8232

Author: boris_stitnicky (Boris Stitnicky)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 


I have recently been struggling with Matrix class to make it accept physical magnitudes for matrix multiplication, and at that opportunity (http://bugs.ruby-lang.org/issues/8223), I noticed that rings and fields in Ruby do not know their additive identity. Eg. there is no method Float#zero or Rational#zero... I therefore propose that:

1. every ring has #additive_identity, alias #zero method defined.
2. every ring has other methods defined, as required for rings in abstract algebra. An example (perhaps a stupid example) might be:

class << Integer
  def additive_identity; 0 end
  alias zero additive_identity
  def add( other ); self + other end
  def additive_inverse; -self end
  def multiply( other ); self * other end
  def multiplicative_identity; 1 end
end

3. That every field in Ruby has, in addition to the above methods, a method #multiplicative_inverse defined, as in:

class << Float
  def additive_identity; 0.0 end
  alias zero additive_identity
  def add( other ); self + other end
  def additive_inverse; -self end
  def multiply( other ); self * other end
  def multiplicative_identity; 1.0 end
  alias one multiplicative_identity
  def multiplicative_inverse; 1.0 / self end
end

I am no pro mathematician, and abstract algebra first sounded to me like a kind of thing that should be treated in some specialized libraries for math nerds, but looking how Twitter pays people to write abstract algebra in Scala

https://github.com/scalaz/scalaz/blob/master/core/src/main/scala/scalaz/Monoid.scala

and reading posts like this one about it:

http://stackoverflow.com/questions/14790588/what-is-twitters-interest-in-abstract-algebra

, where especially noteworthy comment is that by Randall Schulz of box.com, fourth from the top.

If we actually require Ruby rings and fields to have the basic properties of rings and fields (just like Enumerable classes are required to have #each method), it would be possible to implement structured objects such as Matrices over them, and instead of intuitively using numeric literals such as 0 and 1, the matrix or another structured object would ask rings / fields, which their elements come from, what their #additive_identity (#zero), #multiplicative_identity (#one) is. And at the same time, I would like to express my wish that Matrix be made a standard part of Ruby, that does not need to be loaded by require.




-- 
http://bugs.ruby-lang.org/