Looks like you can eliminate a lot of ∂s...
But look: ∂/∂x (6x) = 1/x (6x) = 6. Could there be anything wrong with this reasoning?
Millenium Prize Question
The winking smilie is an integral part of the argument.
BTW, the equations are the Navier-Stokes equation in spherical coordinates. @Danoff might have chosen this form because it has a lot more symbols for the buck than the vector calculus version:
And a million dollars (and infinite math kudos) await those who can solve this question:
If you get stuck solving the Navier Stokes question, here is another easier but trickier question (seems it's hard to find one which is not solved somewere in the interwebs, so if you want to give it a go, don't google):
You have joined the Obsessive Coin Flipping Cult of GTPlanet, and -- naturally -- the amount of your annual dues will be determined by chance. First you must select a head-tail sequence of length five. A coin is then flipped (by a certified OCFCG official) until that sequence is achieved with five consecutive flips. Your dues is the total number of flips, in GTP dollars. For example, if you choose HHHHH as your sequence, and it happens to take 36 flips before you get a run of five heads, your annual OCFCG dues will be 36 GTP dollars. What sequence should you pick? HHHHH? HTHTH? HHHTT? Does it even matter?
import random
coin=['H','T']
seq='HHHHH' # change this for other sequences
trials = 1000
avg = 0
for t in range(trials):
trial='' # start a new trial
while 1:
trial += random.choice(coin) # add a coin flip to the trial
if trial[-len(seq):] == seq: # check end of trial sequence for our sequence
avg += len(trial)
break
avg /= trials
print ('average #flips', avg)
What's happening here? Is my computer broken? 
Wow, you're right. Something odd is going on, here.Yes, all sequences are equally likely as outcome when tossing a coin 5 times. But consider this python script:
Running this on my computer gives an average of about 60-62 flips until getting HHHHH, but only 37-39 flips until getting HHTHH.Code:import random coin=['H','T'] seq='HHHHH' # change this for other sequences trials = 1000 avg = 0 for t in range(trials): trial='' # start a new trial while 1: trial += random.choice(coin) # add a coin flip to the trial if trial[-len(seq):] == seq: # check end of trial sequence for our sequence avg += len(trial) break avg /= trials print ('average #flips', avg)
TTTTT: average flips: 61
TTTTH: average flips: 31
TTTHT: average flips: 33
TTTHH: average flips: 32
TTHTT: average flips: 38
TTHTH: average flips: 32
TTHHT: average flips: 33
TTHHH: average flips: 32
THTTT: average flips: 34
THTTH: average flips: 36
THTHT: average flips: 41
THTHH: average flips: 31
THHTT: average flips: 34
THHTH: average flips: 36
THHHT: average flips: 33
THHHH: average flips: 32
HTTTT: average flips: 31
HTTTH: average flips: 34
HTTHT: average flips: 35
HTTHH: average flips: 34
HTHTT: average flips: 32
HTHTH: average flips: 42
HTHHT: average flips: 36
HTHHH: average flips: 33
HHTTT: average flips: 32
HHTTH: average flips: 33
HHTHT: average flips: 32
HHTHH: average flips: 38
HHHTT: average flips: 32
HHHTH: average flips: 33
HHHHT: average flips: 31
HHHHH: average flips: 62/********************************************************************/
/* */
/* pflipper */
/* */
/* "Python coin flipper" */
/* */
/********************************************************************/
/*
This program is a translation to C of the Python program by tarnheld.
The inspiration is this post, also by tarnheld:
You have joined the Obsessive Coin Flipping Cult of GTPlanet, and --
naturally -- the amount of your annual dues will be determined by chance.
First you must select a head-tail sequence of length five.
A coin is then flipped (by a certified OCFCG official) until that sequence
is achieved with five consecutive flips. Your dues is the total number of
flips,
in GTP dollars. For example, if you choose HHHHH as your sequence,
and it happens to take 36 flips before you get a run of five heads,
your annual OCFCG dues will be 36 GTP dollars.
What sequence should you pick? HHHHH? HTHTH? HHHTT? Does it even matter?
*/
/*
// tarnheld's Python script:
import random
coin=['H','T']
seq='HHHHH' # change this for other sequences
trials = 1000
avg = 0
for t in range(trials):
trial='' # start a new trial
while 1:
trial += random.choice(coin) # add a coin flip to the trial
if trial[-len(seq):] == seq: # check end of trial sequence for our
sequence
avg += len(trial)
break
avg /= trials
print ('average #flips', avg)
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#define NUM_COINS 5
char pattern[NUM_COINS + 1];
/* Number of trials */
#define TRIALS 100000
/*
The maximum number of flips per trial. If the number of flips
exceeds this value, bad things will happen. This situation
should be checked for, but in the interest of speed it is not.
*/
#define MAX_FLIPS 10000000
char sequence[MAX_FLIPS];
int main( void )
{
int i;
int j;
int k;
char * p; /* pointer to end of sequence */
int total;
char * where;
srand( time( NULL ) + getpid( ) );
for ( i = 0; i < 32; i++ )
{
total = 0;
/* Brute force generation of pattern because I'm feeling lazy. */
/* Besides, it's probably a microsecond or two faster. */
pattern[0] = i & 0x10 ? 'H' : 'T';
pattern[1] = i & 0x08 ? 'H' : 'T';
pattern[2] = i & 0x04 ? 'H' : 'T';
pattern[3] = i & 0x02 ? 'H' : 'T';
pattern[4] = i & 0x01 ? 'H' : 'T';
for ( j = 0; j < TRIALS; j++ )
{
p = sequence;
for ( k = 0; k < 4; k++ )
*(p++) = ( ( rand( ) & 1 ) ? 'H' : 'T' );
*p = 0;
for ( ; ; )
{
*(p++) = ( rand( ) & 1 ) ? 'H' : 'T';
*p = '\0';
if ( ( where = strstr( sequence, pattern ) ) != NULL )
break;
}
total += p - sequence;
}
printf( "%s: average flips: %d\n", pattern, total / TRIALS );
}
exit( EXIT_SUCCESS );
}
BTW, the equations are the Navier-Stokes equation in spherical coordinates. @Danoff might have chosen this form because it has a lot more symbols for the buck than the vector calculus version:
Quite right. I can't count.
And, I've finally figured it out.
import random as rnd
coin=['H','T']
S='HHTHH'
trials = 10000
avg = 0
for t in range(trials):
X=''
while 1:
X += rnd.choice(coin) # add a flip
if X[-len(S):] == S: # check end of X for S
avg += len(X)
break
avg /= trials
print ('average # trials',avg)
P = [0,0,0,0,0,1]
p = [0,0,0,0,0,0]
EV = 0
for k in range(trials):
if (k > 6 and k*P[0] < 0.0001):
print('after ',k,' flips:')
break
EV += k*P[0] # update expected value
p[0]=P[1]
p[1]= P[2]
p[2]= P[3]
p[3]= P[3]+P[4]
p[4]= P[5]
p[5]=P[1]+P[2]+ P[4]+P[5]
P[0] = 0.5*p[0]
P[1] = 0.5*p[1]
P[2] = 0.5*p[2]
P[3] = 0.5*p[3]
P[4] = 0.5*p[4]
P[5] = 0.5*p[5]
print('expected value for ',S,' is ~',EV)
You came across that searching for PRPL, didn't you?
Word problems are to math as practicing scales is to making music or soccer practice drills to the playing soccer -- boring chores. It's sad that most people seem to think that's all about math, but try to see the beauty in a proof without words of this sum formula:
Right you are. Specifically in a seven-flip sequence, there are four cases where the sequence begins with HHTHH and my routine is counting all four of them; similarly there are four sequences where HHTHH starts with the second flip, and of course four sequences where it ends with HHTHH (or, equivalently, the third flip begins an HHTHH sequence). You are correct that in terms of the original problem, once we find the HHTHH sequence we should stop flipping.
Wow, that Lockhart's Lament is an excellent article!Word problems are to math as practicing scales is to making music or soccer practice drills to the playing soccer -- boring chores. It's sad that most people seem to think that's all about math, but try to see the beauty in a proof without words of this sum formula:
1+2+3+4+...+n = (n*n)/2 + n/2:
That's a nice trick
Love the analogies to music or painting.
It's amazing that simple coin flipping can lead to such surprising results, but it get's even better (or worse
): Imagine you play a game of coins with a friend: you pick a sequence of 5 heads/tails openly, then after that your friend can choose another sequence of the same length. Then you flip coins until either one of the sequences show up, making the one who chose this sequence the winner. Is this game worth trying in your position? 
)
