Benutzer:Dirk Huenniger/wurf

Die natürlichen Zahlen beginnen in diesem Dokument mit 1. Insbesondere ist 0 keine natürliche Zahl. Entsprechend beginnen alle Felder mit dem Index 1 als erstem Index, was einen Unterschied zu von der Programmiersprache C her gewohnten Notation darstellt.

Eine Würfelschlange ist eine Folge $\{a_{i},i\in \mathbb {N} \}$ für deren Glieder gilt $a_{i}\in \{1,2,3,4,5,6\}$

Wir definieren die Positionsfolge einer Würfelschlage durch ${\tilde {a}}_{0}=a_{0}$ und ${\tilde {a}}_{k}=a_{{\tilde {a}}_{k}-1}+{\tilde {a}}_{k}$

Für jede natürliche Zahl $n$ heißen zwei Würfelschlagen $\{a_{i}\}$ und $\{b_{i}\}$ äquivalent ab $n$, falls es Indizes $1\leq i\leq n$ und $1\leq j\leq n$ mit ${\tilde {a}}_{i}={\tilde {b}}_{j}$ gibt.

Sei $p(i)$ das $i$ in der Postionsfolge einer Würfelschlage enthalten ist. Ich denke man kann sehr leicht folgende 6 Zahlen berechnen $p(i),i\in {1,2,3,4,5,6}$. Ich vermute weiterhin das gilt

$p(k)={\frac {1}{6}}\sum _{i=k-6}^{k-1}p(i)$.

Ich habe diese 6 Zahlen in Haskell leicht berechnet und diese Rekursionsformel dort für zwei weitere Zahlen überprüft.

Die Anzahl möglicher Würfelschlangen der Länge n ist gegeben durch $6^{n}$.

Damit ist die Anzahl möglicher Würfelschlagen der Länge n, bei denen n in der jeweils zugehörigen Positionsfolge enthalten ist gegeben durch $k(n)=p(n)6^{n}$

Die Menge der Würfelschlangen der Länge n bei denen n in der jeweiligen Positionsfolge enthalten ist nennen wir $M_{n}$.

Wie viele Elemente hat $A_{n}(z)=\{x,x\in M_{n},x_{1}=z\}$. Mit der Schreibweise [T] für die Anzahl der Elemente von T gilt gerade.

$[A_{n}(z)]=k(n-z)\cdot 6^{z-1}$

Ins besondere sollte dann wohl gelten.

$\sum _{z=1}^{6}[A_{n}(z)]=k(n)$

Dies wurde experimentell verifiziert. Siehe unten.

Interessanterweise ist

$k(n)=7\cdot k(n-1),n>2$

Wir kennen $p(i)$. Wir wissen auch wie viele Würfelschlangen der Länge $n$ es gibt. Damit wissen wir auch wie viele Würfelschlangen der Länge $n$ es gibt deren letzter Index Teil der zugehörigen Positionsfolge ist. Wir nennen diese Anzahl $A(n)$.Diese Würfelschlagen können wir disjunkt aufteilen indem wir das jeweils erste Glied betrachten, es habe den Wert $k$. Wir wollen nun wissen wie viele Würfelschangen dieser Art es gibt die mit k beginnen, diese Zahl sei $B(k,n)$. Offenbar gilt $B(k,n)=A(n-k)$. Hat man nun eine Würfelschlange dieser Art die mit k beginnt und ersetzt k durch l so gibt es $D(k,l,n)=A(|l-k|)A(n-\mathrm {max} (l,k))$ solche Würfelschlangen wobei $A(0)=1$.

$E(n)$ ist die Anzahl der Würfelschlagen, deren Positionfolge den letzen Index enthält und die unter Austausch des ersten durch einen beliebigen anderen ebenfalls eine solche bilden.

Die Rekursionsformel wurde experimentell überprüft:

import Ratio


mega k= [0..k] 
--[1.0,2.7777777777777776e-2,4.1666666666666664e-2,6.095679012345679e-2,8.757716049382716e-2,0.12412122770919068,0.17407193072702332,0.0]

ddf::[Rational]
ddf=[1 % 6,7 % 36,49 % 216,343 % 1296,2401 % 7776,16807 % 46656]
ddfr=rec ddf


dkf::[Rational]
dkf=[1 % 36,1 % 24,79 % 1296,227 % 2592,5791 % 46656,16243 % 93312]

ful::[Double]
ful=[2.7777777777777776e-2,4.1666666666666664e-2,6.095679012345679e-2,8.757716049382716e-2,0.12412122770919068,0.17407193072702332]

alle n= 6^n
anz::Int-> Rational
anz n= if n<1 then 6 else((alle (n+1))* (ddfr !! (n-1)))
anz2::Int->Integer
anz2 n= numerator . anz $ n-1 
anz3 n= if n<1 then 1 else anz2 n

cc x y n= (anz (abs(x-y)))*anz (n-(max x y)) +6*(sum (rl x y n))

rl::Int->Int->Int->[Rational]
rl x y n= concat  (map (\z->bb z (n-(max x y))) [(max x y) .. ((min x y)+6)])

bb::Int->Int->[Rational]
bb x n=   (map (\y-> cc x y n ) (take (min 6 (n-1)) [1,2,3,4,5,6]))

bbb n =   (map (\x->bb x n) (take (min 6 (n-1)) [1,2,3,4,5,6]))

--fx::Int->Rational
--fx n=(bbb n)/ (alle n)

diff (x:y:xs)=(y-x):(diff (y:xs))
diff xs= []

--main= print ( sum (map sum (bbb 4)),sum (map sum (ttt 4)) )
--main= print ( ttt 4, bbb 4)
---sum (map sum (ttt 4))
main = print [((rui x y)-(toInteger(howmany2 x y)))|x<-tail (mega 6),y<-[1..6]]

rui x y=if (x/=1) && (y>x-1) then 0 else(anz3 (x-y)*(6^(max 0 (min (y-1) (x-2)))))

--main= print [(x,uuu x,anz2 x)|x<-[1..6]]
uuu l = sum (map (howmany2 l) [1..6])


mynums k=[numerator (x*6^y)|(x,y)<-zip (dd2 k) (tail (mega k))]


mynumsfast=[6,6,42,294,2058,14406,100842,425958]

oou=[2.7777777777777776e-2,4.1666666666666664e-2,6.095679012345679e-2,8.757716049382716e-2,0.12412122770919068]

--mm=tail (map (\x->1-x*x) dd2)

p x = 1-(product x)

--pp=map (\x-> p (take x mm)) mega
--sp=map (\x-> sum (take x (tail dk2))) mega

dd::Int->[Int]
dd k=map howmany (mega k)


--dk=map hkmany mega
tri (a:b:c:d:e:f:xs)=(1.0/6.0)*(a+b+c+d+e+f): (tri (b:c:d:e:f:xs))
tri rest = []


rec (a:b:c:d:e:f:xs)=(a:b:c:d:e:f:(1.0/6.0)*(a+b+c+d+e+f):[])++
  (rec (b:c:d:e:f:(1%6)*(a+b+c+d+e+f):[]))


dd2::Int->[Rational]
dd2 k= map (/(lmain k)) (dd3 k)
dd3::Int->[Rational]
dd3 k= map fromIntegral (dd k)

--dk2= map (/lkain) dk3
--dk3::[Rational]
--dk3= map fromIntegral dk


lmain::Int->Rational
lmain k= fromIntegral  . length$ (hh k)
lkain::Rational
lkain= fromIntegral  . length$ wk

howmany::Int->Int
howmany x = foldl (+) 0 (map ((\y-> if y then 1 else 0).(elem x)) (hh x))
howmany2::Int->Int->Int
howmany2 x z= foldl (+) 0 (map ((\y-> if y then 1 else 0).(\(k,g)->(elem x k)&& ((g !! 0)==z))) (zip (hh x) (ws x)))

hh k= map ghops (ws k)

hkmany z=foldl (+) 0 (map (\x-> if x then 1 else 0)  (hk z)) 

hhh=filter (\x-> x/=([],[])) (hk2 3)

predd a b (x,y)= if ((head x)== a && (head y)==b) then 1 else 0

tt ::Int->Int->[Rational]
tt x n=    (map (\y-> ((sum (map (predd x y) lik))) ) (take (min 6 (n-1)) [1,2,3,4,5,6]))
ttt::Int->[[Rational]]
ttt n =    (map (\x->tt x n) (take (min 6 (n-1)) [1,2,3,4,5,6]))

lik =hhh
hk2 z= map (\(x,y)-> if (hopeq z (ghops x) (ghops y)) 
  then (x,y) else ([],[])) wk

hk z= map (\(x,y)-> (hopeq z (ghops x) (ghops y)) ) wk
hopeq z x y= (elem z x) && (elem z y) 
ghops l= hops 0 l
hops a l= if a < length l then (a+1):(hops (a+x) l) else []
  where
    x=(l!! a)

ws k= iterate (>>= fun) (fun []) !! (k-1)
fun as = [ a:as | a <- [1..6] ]

--ws= ([[1],[2],[3],[4],[5],[6]] 
--     >>= fun >>= fun >>= fun>>= fun>>= fun )
--fun= \x->[1:x,2:x,3:x,4:x,5:x,6:x]

wk=  ws 6>>=fun2
fun2 t= [(1:x,t),(2:x,t),(3:x,t),(4:x,t),(5:x,t),(6:x,t)]
  where
    x=tail t