musik

ある方の質問をきっかけに、量子力学について考えてみました。末尾に参考書籍を記しています。

１）そもそも「力学」とはなにか。
力学とは、文字通り力の学問ですが、力を受けた物体がどのような振る舞いをするかを『記述する』学問です。

この場合の『物体』は、例えば、太陽／地球／月／彗星といった天体であったり、電子／陽子／中性子といった素粒子であったり、回転する「こま」であったりします。もちろん、『物体』は、自動車のボディーや東京スカイツリー、本四連絡橋でも構わないのですが、こうした実用的な力学は自動車工学や建築学で扱うことや、物理屋さんの好むような理論化が十分でない等の理由で、通常、「物理」という学問分野の対象にはなっておらず、物理屋さんがいう「力学」の範疇には入れないことが多いです。（抽象的な方が格好良い、という伝統的物理観によるものといってもよいでしょう）。

力学の計算の成果として、ハレー彗星の回帰年数や、電子の振る舞いを「予測」することができ、それにより我々が住んでいる宇宙の有様の理解が進むことが、力学の目的であるといえます。この「予測」は、「数式表現」されていることが強く求められています。

また、そもそもの物理学の成り立ちから、「真理は単純な数式で表されるはずであり、それは美しい形式を持つに違いない」という暗黙の信条があり、「なんとなくこんな感じ」とか「この時はこうなる」風の場当たり的な知識は物理学と見なされません。
（私見では、化学／地学／生物学／工学に対し、物理学が優位性を持っていると感じるのは、こうしたストイックな態度によるものと思います。一方、物理学における全ての数式はあくまでも「実験的事実」から導かれるものであって、理論は実験的事実に基づいて構成されるものに過ぎません。しかしながら、世の中では、「それが理論だから正しい」式の間違った言い方がされてしまうことがあります。「多くの実験事実に基づいて理論化されたものであり、さらに、その理論が真理としてあるべき美しさを持っていると感じられることから、正しいだろう」というのが、正しい態度ではあります）。

量子力学は、「量子」と呼ばざるを得ない「へんなもの」の力学であるといえます。

２）「量子」とはなにか。
光がそうであるように、粒子でも波動でもある存在を、粒子的な観点から「量子」と呼びます。また、この世界においては不確定性が本質であり、粒子の振る舞いを完全に予測することはできず、ある一定の幅の間でしか粒子を捉えることができません。

普通に考えると、ある存在が、同時に（あるいは、見方によって）粒子でも波動でもあり得る、というのは解釈に苦しみますが、どうして、ある存在が粒子でも波動でもあり得るのか、という問いに対しては、「多くの実験事実がそうであるから、そう解釈するしかない」と回答をせざるを得ません。

どうやら、宇宙は人間が理解するために存在しているのではなさそうですし、そもそも、人間が物事を理解するというのはどういうことか、という疑問がふつふつと湧いて参りますが、物理学科的には、「数式表現ができ、それによって予測できれば、解釈はさておいて、理解したってことで良いよね。」というココロであります。もちろん、物理学者も人間ですので、粒子でも波動でもあることや不確定性についてはなかなか納得し難く、気持ち悪いと思っていると思います。

３）「量子力学」とは何か。
繰り返しになりますが、量子力学は、「量子」と呼ばざるを得ない「へんなもの」の力学であり、「量子の振る舞いについて、波動／粒子の両側面や不確定性を踏まえつつ、実験的事実を数式表現し、予測する学問」であるといえます。

物理学科的に「量子力学」を理解するためには、いわゆる古典力学以上の数式（特に面倒な解析力学等）を理解する必要があり、学生の多くが初歩の段階で脱落します。（申すまでもなく私もその一人。個人的な関係は全くありませんが、「シュレジンガー音頭」の方のお気持ちはよくわかります）。

量子力学を理解したい、という問いに対して、私が答えるとするならば、大学の物理学科に入り、古典力学、解析力学、量子力学を学び、また、いくつかの有名な歴史的な実験を追体験し、量子力学を創って来た人々の随想を読みつつ思索に耽り、十数年を過ごしてみると、幾ばくかの理解が得られるかも知れないが、自分もまた、量子力学を理解したとは言えないのであるから、人様に教えられることはない、ということでしょうか。

４）書籍について
と言う事では、折角のご質問に答えたことになるまいでしょうから、いくつか書名を挙げておきます。
いずれもきちんとしたもので、定評がありますが、合う／合わないは極端に分かれますので、実際手に取って御判断下さい。

●物理学科での教科書
「量子力学 I (物理学大系―基礎物理篇) 」　朝永 振一郎　みすず書房
（物理学科の量子力学入門。既存の知識の再利用ではなく、新たな知識の獲得という視点を知る事なく、
　後輩に譲り渡したのが残念です。）

「量子力学入門」 (物理テキストシリーズ 6) 阿部 龍蔵 岩波書店
（私のころの初学者用教科書です。）

「量子力学 I 原子と量子」 (物理入門コース 5) 中嶋 貞雄　 岩波書店
（これも同様のレベル。このシリーズにはお世話になりました。）

「量子力学―ランダウ=リフシッツ物理学小教程」ランダウ・リフシッツ
（超デキる学生向け。こういう世界を覗き見るのも一興かと。ちくま文庫になっています。
　物理系の卒業生同士で「ランダウ読んだ？」はある種のご挨拶です。）

ファインマン物理学
（凡人学生向け。数式だけ飛ばして読んでも良いかも知れません。私はファインマンの量子力学は未読ですが、
　これで読書会をやってみたい気はします。）

●物理学科副読本系
「鏡の中の物理学」朝永 振一郎
（本書中の「光子の裁判」は絶対読むべきです。湯川秀樹の「旅人」もよかろうと思います。）

トムキンスの冒険　ガモフ
（伝説の名著。これはお勧めしても間違いでないと思っています。）

量子力学の冒険　トランスナショナルカレッジオブレックス
（有名な本ですが、私はこれの前著「フーリエの冒険」しか読んでいません。合う人には合うと思います。）

「32ページの量子力学入門」シンキロウ 暗黒通信団
（暗黒通信団は、円周率表のような変な本があるので注目しています。未読ながら気になる／安価ということで、
　挙げておきます。「“距離”のノート」も気になります）。

映画「imitation game」を見たので、enigmaを作ってみた。

もともと、チューリングやenigmaに興味があったので、それなりに映画を楽しめたが、予備知識のない場合はどうなのだろう。短い時間に様々な要素を説明せねばならず、暗号の中身については大いに端折っていたのは仕方がないことではあるが、私ごとき者には多少残念。 チューリング級の天才であれば、「天気予報のような定型文を解読のターゲットに使えば良い」ということはさっさと思いついてしまいそうな気がする。もちろん実話通りではないのは当然としても、ちょっと紋切りかと。 カンバーバッチは品格ある変人を演じさせれば天下一品。非常にらしかったと思う。（私はチューリングの人格について知るところはほとんどない）。

さて、例によってインチキプログラムである。それらしくコード化され、デコードもされるが、正しいかどうかはまったくわからないてふもの。オブジェクトを作ってみてなかなか楽しかった。再代入を使わずにこれを書けるとは思えない。という感想を抱いた。

#!/usr/bin/ruby

class Roter
  def initialize ( str )
    @pattern_a = str
    @pattern_b = "abcdefghijklmnopqrstuvwxyz"

    p ""
    p "initialize ==="
    p @pattern_a
    p @pattern_b
  end

  def rotate ( )
    str = @pattern_a
    @pattern_a = str[1,str.length-1] + str[0,1]

    p ""
    p "rotate ==="
    p @pattern_a
    p @pattern_b
  end

  def shift ( org_str, direction )

    if direction==1 then
        new_str = org_str.tr( @pattern_a, @pattern_b )
    elsif direction==-1 then
        new_str = org_str.tr( @pattern_b, @pattern_a )
    end

    p "shift === "
    print "#{@pattern_a} => #{@pattern_b}\n"
    print "shift:#{org_str} => #{new_str}\n"
    return new_str
  end

end

# system initialize

roter = []
roter0 = "abcdefghijklmnopqrstuvwxyz"
roter1 = "abcdefghijklmnopqrstuvwxyz"
roter2 = "abcdefghijklmnopqrstuvwxyz"

roter[0] = Roter::new( roter0 )
roter[1] = Roter::new( roter1 )
roter[2] = Roter::new( roter2 )

org_str = ARGV[0]
new_str = ""
c = 0
n = 0

org_str.split(//).each{ | c |
    (0..2).each{ |i|
        c = roter[i].shift( c,  1 )
    }

    c = c.tr( roter2, roter2.reverse )
    [2,1,0].each{ |i|
        c = roter[i].shift( c, -1 )
    }

    new_str = new_str + c
    n = n + 1

    roter[0].rotate(  )

    if n % roter0.length == 0 then
        roter[1].rotate(  )
    end

    if n % (roter0.length * roter1.length ) == 0 then
        roter[2].rotate(  )
    end

}

p org_str
p new_str

大変有害なものを晒している気もするが、お許しあれ。

●Problem 5
foldl lcm 1 [1..10]
2520

foldl lcm 1 [1..20]
232792560

●Problem 6
(x + y)^2 = x^2 + 2xy + y^2

(x + y)^2 - x^2 - y^2 = 2xy

(x + y + z)^2 - x^2 - y^2 - z^2 = 2xy + 2xz + 2yz

import Data.List
Prelude Data.List> sort [x*y | x<-[1..10], y<-[1..10], x /= y ]
[2,2,3,3,4,4,5,5,6,6,6,6,7,7,8,8,8,8,9,9,10,10,10,10,12,12,12,12,14,14,15,15,16,16,18,18,18,18,20,20,20,20,21,21,24,24,24,24,27,27,28,28,30,30,30,30,32,32,35,35,36,36,40,40,40,40,42,42,45,45,48,48,50,50,54,54,56,56,60,60,63,63,70,70,72,72,80,80,90,90]

sum [ x*y | x<-[1..10], y<-[1..10], x /= y ]
2640

sum [ x*y | x<-[1..100], y<-[1..100], x /= y ]
25164150

別解
(sum [1..10] )^2 - sum [ x^2 | x<-[1..10] ]
2640
(sum [1..100] )^2 - sum [ x^2 | x<-[1..100] ]
25164150

計算速度が問題になるほどのものではなかった。
別解であっても十分速い。

●Problem 16
#!/usr/bin/ruby
(1..1000).each{ |n|
p = 2 ** n
sum = 0
p.to_s.split(//).each{|i| sum= sum + i.to_i }
print "2^#{n} = #{p} -> #{sum}\n"
}
__END__

2^1 = 2 -> 2
2^2 = 4 -> 4
2^3 = 8 -> 8
2^4 = 16 -> 7
2^5 = 32 -> 5
2^6 = 64 -> 10
2^7 = 128 -> 11
2^8 = 256 -> 13
2^9 = 512 -> 8
2^10 = 1024 -> 7
...
2^1000 =
10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376
-> 1366

これほどの長整数がきちんと計算されているかは不明だが、
途中経過を見て、いちおう「らしい」事は確認した。
（これをもって正しいというには相当の勇気が必要）。

2^1000=1.0715E+301 なのはエクセルでも確認できた。
VBAで計算させようとしたが、持っている数値は頭の
15桁だけであり、計算できなかった（トホホ）。

1071508607186270000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

■ruby版
#!/usr/bin/ruby

zz = z = []
a = 2..100
b = 2..100

p a
p b

a.each{ | x |
b.each{ | y |
z << x ** y
}
}

zz = z.sort.uniq

p zz.length # 回答
p zz # 確認

__END__

2..100
2..100
9183
[4, 8, 9, 16, 25, 27, 32, 36, 49, 64, 81, 100, 121, 125, 128, 144, 169,
196, 216, 225, 243, 256, 289
...
,100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]

■haskell版
思考過程（試行過程）を記載しています。

x^yを導出し、結果をソートする。
sort [x^y | x <-[2..5], y<-[2..5]]
[4,8,9,16,16,25,27,32,64,81,125,243,256,625,1024,3125]

x^yを導出し、結果の重複を取り除く。
nub [x^y | x <-[2..5], y<-[2..5]]
[4,8,16,32,9,27,81,243,64,256,1024,25,125,625,3125]

x^yの結果から重複を取り除き、その数を算出する。
length $ nub [x^y | x <-[2..5], y<-[2..5]]
15

xとyを問題で与えられた上限に変更。
length $ nub [x^y | x <-[2..100], y<-[2..100]]
9183

xとyを問題で与えられた上限に変更した場合の数列を見たいので、出力。重複を取り除きソート。途中省略
sort $ nub [x^y | x <-[2..100], y<-[2..100]]
[4,8,9,16,25,27,32,36,49,64,81,100,121,125,128,144,169,196,216,225,243,256,289,324,343,361,400,441,484,512,529,576,625,676,729,784,841,900,961,1000,1024,
...
,100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]

素人考えで作ったものを公開の場所に置く是非には迷うが、とりあえず自分の記録として残しておく。

haskellでプログラムを書いて完全数を求める。

まず、任意の数に対する素因数分解の方法を考える。
let n = 28
[x | x<-[1..(n `div` 2)], n `mod` x == 0]

素因数分解の結果を合計する。
let n = 28
sum [x | x<-[1..(n `div` 2)], n `mod` x == 0]
28

素因数分解の結果の合計と元の数を比較し、完全数であるかを判定する。
let n = 28
( sum [x | x<-[1..(n `div` 2)], n `mod` x == 0] ) == n
True

1から任意の数（28）までの整数から完全数を抜き出す。
[n | n<-[1..28],( sum [x | x<-[1..(n `div` 2)], n `mod` x == 0] ) == n ]

自然数から完全数を抜き出す。
[n | n<-[1..],( sum [x | x<-[1..(n `div` 2)], n `mod` x == 0] ) == n ]
[6,28,496,8128

ということで、haskellを素直に書けば素直に答えが得られるとも言うことができるが、1日計算したところで、8128以降の答えが得られていない。haskellとてもなんらかの形で計算効率を考慮しなければならないということである。考えてみれば当然であるのだが。

プロジェクト・オイラー、問題20。一応それらしきプログラムを作り、正しいような気がしていたが、環境によって答えが異なる。なんとまあ、全くもう。

ruby1.8.7が怪しいように思ったが、i686-linux版では正しいと思われる結果が出ている。さて、どうやって修正できるのやら。どうやって検証するのやら。長整数がきちんと扱える環境を使わねば。

ともあれ、cygwin上のrubyがlinux版の100倍遅いとは。。。。

（楽しい）。

#!/usr/bin/ruby
N = 100

def factorial( n )

	if n <= 1 then

		1

	else

		n * factorial( n- 1 )

	end

end

f = factorial( N )

print "factorial( ", N, " ) = ", f, "\n"

sum = 0

f.to_s.split(//).each{ | s |

	sum = sum + s.to_i

}

print "sum = ", sum, "\n"

●ruby 1.9.3p385 (2013-02-06 revision 39114) [i386-cygwin]
real 0m1.249s
user 0m0.031s
sys 0m0.467s

factorial( 100 ) =
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
sum = 648

●ruby 1.8.7 (2011-06-30 patchlevel 352) [i686-linux]
real 0m0.012s
user 0m0.004s
sys 0m0.004s

factorial( 100 ) = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
sum = 648

●ruby 1.8.7 (2012-02-08 patchlevel 358) [universal-darwin12.0]
real 0m0.032s
user 0m0.006s
sys 0m0.010s

factorial( 100 ) = -103842843508756158358798687947847805639487006820789523464184759489820034626638828969890744868143583395759498188780474387766308770729164800000000000000000000
sum = 720

プロジェクト・オイラーの問題10をやってみた。

ruby で書いて、MacOSXのターミナルで動かしたが、遅くてなかなか返ってこない。プログラムが動いていても、ユーザーが触らなければスリープに入ってしまうようだ（私がそう設定しているようだ）。

このようなプロジェクトに興味がある人が身近にいるらしいということで、「環境を問わず、どこでも動かせるプログラム環境」について、少し考えてみた。

で、誰しも思いつくのが、ブラウザ付属のJavaScript。やってみました。

開くの注意。計算を終えてページが表示されるまで1時間程度かかります。Chromeだと、結果が出るまで、ロード中のぐるぐる回転は示されますが、途中出力はまったく表示されません。また、このページ以外のタブでは閲覧が可能です。一方、FireFoxだと、途中の素数出力等はでますが、「結果が返ってこないけど、止める？」と聞いてきます。また、全タブがロックします。・・・ということで、済みませんがご注意を。

Ubuntu (32bit)上のFireFoxで約30分、Chromeで約2時間。Windows7(32bit)上のChromeで約70分。IE10で26分。ハードウェア性能は後者の方が良いので、ブラウザによって、JavaScriptの計算能力には大きな差があると言えましょう。

計算結果はページ最下部に出力されます。ページ最上部に計算開始時刻を、最下部に終了時刻を出力しますが、多少本当かいな。また、途中の素数も出力しますので、開始・終了は、本当の意味での計算時間を示すものではありません。

JavaScriptが動けば動くはずなので、スマートホンでも原理的には計算可能ですが、単なるバッテリー消費プログラムでしょう。このプログラムは、ローカルマシンで動作するので、ネットワークやサーバーには負荷がかかりません。心置きなく計算を楽しんで下さい。

以下は、緩慢なるrubyプログラム。腕が悪いということです。少しは工夫しているつもりですが、自己流の限界でしょうか。

#!/usr/bin/ruby

primes = Array::new

primes = [2]

n = 1

sum = 0

while n<2000000

	n = n + 2

	mod = 0

	primes.each{ | p |

		if (n % p)==0 then

			mod = 1

		end

	}

	if mod == 0 then

		p n

		primes << n

		sum = sum + n

	end

end

# p "primes = ",  primes, "\n"

print "sum = ",  sum, "\n"

Haskellがあまりにも遅いので、Cで書くとどうなるか試した。

なんとシステムタイムは0.000sだ。10年振りのCだが、中身はrubyと変わらないので、一応書くことができた。でも、gccから喰らうエラー一点は見逃している（だって、動くんだもん）。

普段、コンパイルを必要とする言語で処理を書くことはないが、偶には、Cも書かねば・・・と思った瞬間である。

c=2, r=2, sum=0 c=5, r=8, sum=2 c=8, r=34, sum=10 c=11, r=144, sum=44 c=14, r=610, sum=188 c=17, r=2584, sum=798 c=20, r=10946, sum=3382 c=23, r=46368, sum=14328 c=26, r=196418, sum=60696 c=29, r=832040, sum=257114 c=32, r=3524578, sum=1089154 r=5702887 sum=4613732

real 0m0.145s user 0m0.140s sys 0m0.000s

#include    <stdio.h> 
main(){
    int c,r;
    int sum = 0;

    for( c=1; c < 400; c++ ){
        r = fiv( c );

        if( 4000000 < r ){
            printf("r=%d sum=%d\n",r,sum );
            exit( 0 );
        }else if( (r % 2) == 0 ){
            printf( "c=%d, r=%d, sum=%d\n",c,r,sum );
            sum = sum + r;
        }
    }
}

int fiv( int n ){
    int r;

    if( n <= 0 ){
        r = 0;
    }else if( n == 1 ){
        r = 1;
    }else if( n == 2 ){
        r = 2;
    }else{
        r = fiv( n-1 ) + fiv( n-2 );
    }
    return( r );
}

preタグの中身は改行だらけになるが、対処法がわからないので、これにて失礼。
（2024/7/29 にMarkdownに修正。Mardownをデフォルトにしたいのだが。。。#include <stdio.h>が消えるのが悲しい。が、なんとか出せた。）

久しぶりにプロジェクトオイラー。問題2。１年ほどかかって、1桁ができていない。こういう人間もいる、ということで。

ここにあるソースを学校で使う人がいるとは思いませんが、万一使うと、大量に怒られるような内容に（意図はしていませんが）、なっていると思います。お気をつけ下さい。

Haskell版。無限リストを使っても良さそうに思ったが、それでは動かなかった（結果がいつまでも返ってこない）。そのため、マジックナンバーで上限を抑えるの挙に出た。回答が返ってきて、かつ、意味のある回答になるよう調整する。ああ、悲しい。

Ruby版とHaskell版で回答が同じになったので、よしとしているが、本当にあっているのかな？
計算時間はHaskell版の方が長い。これも異なように思われる。

まずはHaskell版。リスト内包表記を使うともう戻れない。が、複雑化した場合に対処しきれる気はしない。

fiv 1 = 1

fiv 2 = 2

fiv n = fiv (n-1) + fiv (n-2) 


main = do print $ sum [x | x<-map fiv [1..40], x<4000000, even x] 

ここで利用しているフィボナッチ関数で得た４００万以下の数列は以下のごとし。
[1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578]

偶数だけ抽出すると以下のごとし。
[2,8,34,144,610,2584,10946,46368,196418,832040,3524578]

合計すると以下のとおり。
4613732

計算時間は以下の如し。
real 1m19.321s
user 1m18.793s
sys 0m0.264s

こちらはruby版。デバッグ出力が普通にできるのが嬉しい。

#!/usr/bin/ruby


def fiv(n)

	if n <= 0 then

		r = 0

	elsif n == 1 then

		r = 1

	elsif n == 2 then

		r = 2

	else

		r = fiv(n-1) + fiv(n-2)

	end

#	print "n=",n,",fiv=",r,"\n"

	r

end

c = 1

sum = 0

while c <400

	

	r = fiv(c)

	if 4000000 < r then

		print "r=",r,"\n"

		print "sum=",sum,"\n"

		exit

	elsif r % 2 == 0 then

		print "c=",c,",r=",r,",sum=",sum,"\n"

		sum = sum + r

	end

	c = c + 1

end

デバッグ出力の経過は以下の如し。
c=2,r=2,sum=0
c=5,r=8,sum=2
c=8,r=34,sum=10
c=11,r=144,sum=44
c=14,r=610,sum=188
c=17,r=2584,sum=798
c=20,r=10946,sum=3382
c=23,r=46368,sum=14328
c=26,r=196418,sum=60696
c=29,r=832040,sum=257114
c=32,r=3524578,sum=1089154
r=5702887
sum=4613732

ruby版の実行時間はこんなもの（たかが4799.41bogomipsの古いマシンなので）。
real 0m17.065s
user 0m16.949s
sys 0m0.012s

都内某所でチビタマムシの標本を実体顕微鏡で見せてもらった。

美しい。銀河系のごとく、古美術品のごとく美しい。

類する写真はなかなか見当たらないが、これが最も似ている。

http://ta440ro.blog.shinobi.jp/虫の類/?pageNo=7