My partner and I talk a lot about how our son is learning. We think he does a great job with some things and just an ok job at others. We’ve been with him in stressful situations and we’ve all made it through (even the car!). But as we reflect on what we would have done in those situations we start to realize just how much better we are as drivers than he is, or that he will be even after another few months of intensive training. We’ve had (cough cough) 30 years of practice, and now we’d say we’re pretty good at it.
What I’m depressed about is the realization that years of experience (or 10,000 hours, if you prefer) can’t be taught. I’m pretty sure that my son will become a great driver, but I don’t think there’s anything I could do to help that along very fast. I’m depressed because my profession is teaching physics, and all I ever get is four years with a student. For most of my students all I ever get is one semester. Trying to teach “physics maturity” (to borrow and slightly change a phrase from my mathematics buddies) in a semester is really hard. Maybe impossible. If I knew my students were going to go off and continue to think about physics and practice physics and model things like crazy throughout their life, I suppose I could take solace that they’d eventually become the experts I want them to be. But the students that do that are in a minority so small that it’s probably not worth it to count them.
I’m realizing that all I can do is set the table for them. I can try to make a course experience that gives them some tools and gives them glimpses of others. Just as I can’t make my son a great driver in just a few months, I can’t make an expert in physics in one course.
So I’m depressed, but super excited to be heading off to the AAPT conference today so I can get the usual pick-me-up that I get from all my friends there. Who knows, maybe when I get back I’ll have a post with a title like “Teaching physics is the greatest thing you can do” or something like that.
Your thoughts? Here are some starters for you:
That sounds cool and all, but the details are proving to be tough. I’d like to brag a little about what we’ve been up to in this post (mostly so there’s a good record of it somewhere), but if you’re wondering about the title of this post, just go here where there’s a little explanation for what we need for you. Read on for more details.
This is actually the easy part. If you know the shape of the drum head you’re interested in (and can describe it mathematically — see below for that hassle) you just need a single command in Mathematica:
{frequencies, functions}=NDEigensystem[{-Laplacian[f[x, y], {x,y}], DirichletCondition[f[x,y], True]}, {f}, {x,y} \Element region, {10}]
where “region” is your mathematical description of the shape of the drum head. This command uses a Finite Element approach and returns the 10 lowest eigen frequencies. Note that you have to take the square root of the frequencies you get from this command to get the audio frequencies.
Here’s a sample of listening to various frequencies on a slowly changing shape:
Simple shapes are easy: a circle? Disk[], a rectangle? ImplicitRegion[-1<=x<=1 && -2<=y<=2, {x,y}]. But what about crazy shapes? And what about shapes that Mathematica can programmatically shift around while it hunts for cool shapes that produce cool spectra?
What we’ve decided to do is to use control points around the edge that Mathematica can make slight adjustments to. When it does, it redraws a smooth, closed curve that includes all the points and it then uses a cool command that turns that border into a region:
region = BoundaryMeshRegion[controlpoints, Line[{1,2,3,4,6,1}]]
The problem is that you have to make sure that the control points are in the right order around the border (say, clockwise, for example). Luckily it turns out that the traveling salesperson problem comes to the rescue here. If you want to find the shortest path visiting all the points in a plane (and returning to the first one), that path will not cross itself and hence will be a proper region border. So:
fst = FindShortestTour[points];
comes to the rescue. So Mathematica does this:
Ok, so let’s say you have six control points. Each one is an x and y value so you have a 12-dimensional optimization problem. What could we use? We’ve decided to use Mathematica’s implementation of an evolutionary algorithm (or genetic algorithm). Really it’s the same thing I was using when trying to see if Mathematica could learn to race around corners. Evolutionary approaches work well where there’s a humongous parameter space and you don’t really know any other way to explore it other than brute force.
The big problem (yes, I’m getting to the title of this post, hold your horses) is that a set of frequencies from a drum head (the result of step 4 above) needs to be converted to a single number that can be used to rank various drum heads in the evolutionary algorithm.
Ok, so we realized that we needed to be able to look at a spectrum from a drum head and rate it on the scale of “is it melodic?” We thought of some interesting approaches. Mostly they centered around measuring how close the frequency spectrum is to an evenly spaced one (which is what a stringed instrument gives you). We ran into lots of potential problems, though, not least was that orchestra chimes have a “missing fundamental” and still sound good.
We also realized that maybe we could handle mostly evenly spaced frequencies if we could determine where to thump the drum head to kill the offending non-evenly-spaced ones.
Ok, so now we had to go back to Mathematica to determine where on a particular drum head you could thump it to control the relative amplitudes of the various frequencies (think about how a stringed instrument sounds very different depending on where you hit it.
Here’s an example of how the frequencies from the shape of Minnesota change their relative amplitudes if you thump in the center of every county in Minnesota (note that the find shortest tour command was used to do that):
Luckily the NDEigensystem gives us the resonant shapes for every resonant frequency so finding the relative amplitude for a given thump location (and shape) really just amounts to doing this integral:
where is just the ith resonant shape and thump(x,y) is the function that describes the thump shape (and location).
It’s taken us a while to find a good way to do this integral fast, but we’re getting there (right now we’re at one second per frequency per shape).
So now we can look for a good candidate of frequencies and then hope there’s a thump location that’ll shut off the bad ones (fingers crossed!).
So then we hit on the way we could pull all of this together (we hope). We’ve decided to let the crowd (you!) help us rate a collection of frequencies and relative amplitudes on a scale of 0 – 5 where 0 is like white noise and 5 is a pure tone. We figured that since we’re making drums for people we ought to let people determine the single number that our evolutionary algorithm needs.
One of the researchers in the math department this summer is working on an artificial neural network to recognize handwriting and my students realized that approach could work here. All we need is to train the network on what are good, bad, and medium sounding collections of frequencies and relative amplitudes.
Luckily Mathematica has recently built in some really powerful functions that implement the major algorithms in neural network theory. The one we’re planning on using is “Predict” which just needs a whole bunch of these:
{{216, 456, 786, 890, 1012}, {0.5, 0.3, 0.6, 0.7, 1}}->2
where the first list of numbers is the random frequencies and the second is the relative amplitudes. It then trains on whatever you give it and then it can be used on future untrained ones.
So, we need your help! Please go to our new site and score a few random sounds on our 5 point scale (decimals are welcome). It just takes 1 second per sound and we’d love to just get a ton to train the neural network. Then our workflow will look like this:
We started developing the training set using Mathematica to generate sounds. This is pretty easy (just use the Play command) but it was tedius and we weren’t generating enough. This notion of crowdsourcing came from my wonderful students so I decided to give it a try over this holiday weekend.
I knew making a database-driven website wouldn’t be a problem (I rail against Blackboard so much because I finally just wrote my own LMS). But I didn’t know how to generate the sounds. So, I decided to dig into the HTML5 audio standards. It turns out that just a few lines of javascript code will generate a sound with a controllable frequency and amplitude:
oscillator$key = context.createOscillator(); gainNode$key = context.createGain(); oscillator$key.frequency.value = $value; currentTime = context.currentTime; oscillator$key.connect(gainNode$key); // Connect sound source 2 to gain node 2 gainNode$key.connect(context.destination); // Connect gain node 2 to output gainNode$key.gain.value = $amps[$key]; oscillator$key.start(currentTime); oscillator$key.stop(currentTime + 1);
where $key is set up as the loop variable (goes from 1 to 5). Feel free to take a look at the html source of our page to see how it all goes together.
So thanks for any help you can give. We really hope we get enough data so that the training is robust.
Thoughts? Here are some starters for you:
I’ve used a Lagrangian approach a ton in my work with students and my posts here. It’s a great way to model the dynamics of a system because you just have to parametrize the kinetic and potential energy of the system and you’re off. No vectors, no free body diagrams, just fun
Here’s the idea in a nutshell:
Hold a ball in your hand. In 2 seconds it needs to be back in your hand. What should you do with the ball during those two seconds to minimize the time integral of the kinetic energy minus the potential energy during the journey?
It’s a fun exercise to do with students. You’re asking them to minimize this integral over two seconds:
When I do this their first guess is to leave the ball in your hand. They like to define the gravitational potential energy there to be zero, and then know the kinetic energy is zero if it doesn’t move so they’ve found an easy way to get a total of zero for the integral. So I challenge them to find a path who’s answer would be negative! It’s a pretty fun exercise, especially if you actually calculate the integrals for their crazy ideas.
The point is that the winner is to throw the ball up so that it’s trajectory, responding simply to gravity, takes 2 seconds (ie throw it up 1.225 meters). The kinetic energy is positive during the whole journey (except for an instant at the top, of course) but the potential energy is positive during the whole journey too.
Calculus of variations teaches us that if you want to minimize an integral like this:
(where is shorthand for the x-velocity) you really just need to integrate this differential equation over the same time integral:
What’s cool is that if the function is KE-PE the equation above becomes Newton’s second law! That’s why this works. You use scalar energy expressions and you get the force equation for every component of motion! Now there are some other cool things like not needing to worry about constraint forces but I won’t worry about that in this post.
Ok, so what happens when you consider relativistic speeds (ie close to the speed of light)? Well, the first thing I did (which, spoiler, didn’t work) was to wrack my brain for an expression for the kinetic energy and plug away. When teaching relativity you get to a point when you’re making the argument with your students that KE isn’t just anymore but is really where gamma is given by:
If you take the limit of that expression for small v’s you get the usual expected result, and that’s certainly what we do right away with our students to make them feel better.
Ok, so I plugged it in and got a relativistic version of Newton’s 2nd law:
Note how the second term on the left side looks a little like “ma” while the right hand side is just the force from a conservative potential energy (U). The extra term on the left hand side is the weird stuff.
Without really thinking about whether that was the right equation, I modeled a constant force system and got this for the velocity
(I set the speed of light to 1). You can see that the speed is forced to obey the cosmic speed limit.
But here’s the problem. The equation above is wrong. That is not the correct relativistic Newton’s 2nd law equation.
So what happened? I plugged in the correct relativistic kinetic energy and the Lagrangian trick (minimizing KE-PE) gave a trajectory that doesn’t match what actually happens! So something’s wrong. Here’s a few possibilities (one is right, see if you can guess before reading the next paragraph):
It turns out it’s the last one. It took me a while of digging around, but this wikipedia article set me straight. The gist of what’s talked about there is this:
Yeah, weird, I know. It’s like “hey, I know what the answer in the back of the book is so I’m going to futz with my early equations until they give me the right answer. So what is the right functional to use? This:
Yep, it’s negative. Yep, it’s not an expression you’ve ever seen before if you’ve studied special relativity. But, guess what, it works! When you plug it in and do the calculus of variations trick you get the right dynamics. Surprise, surprise, given that it was built to do just that.
Here’s the same graph as above but not comparing that prediction with the right dynamics (in red):
It also asymptotes to the cosmic speed limit, just at a different rate.
That’s the question I was really wondering about. Luckily google came to the rescue with this great wikibook article that it found for me. It points out that the kinetic energy portion of the functional you use to make the relativistic dynamics work is really just proportional to the invariant space-time interval:
This is an expression for the “distance” between two distinct events in space-time that is the same for all inertial observers. It’s really cool given all the weird time dilation and length contraction that can go on in the various inertial frames.
So basically the trajectories that actual things follow is designed to make the space-time “jumps” add up to the smallest number. That’s super cool
Your thoughts? Here are a few starters for you:
]]>
A quick refresher:
Midterm grades weren’t great. The most common grade was an F. I feel like crap about that. I just wanted to write about what’s been going on to help me reflect.
First the good news: I like the structure. The three problems every day help me really flesh out what I think is important and provide focus for what we do in class. I like a lot of the book problems but it’s fun to make up my own at times to (I really did use the one about 3D movie glasses that I talked about in the other post). Students come to the oral exams with their portfolios and some have some really great work done on them.
So why so many F’s? Those of you who’ve dabbled with standards-based grading know where they come from: “I can always reassess later.” While I thought knowing that a quiz was upcoming would motivate the students to take an honest stab at the problems between each class, quite often it seems that few have spent much time on them before the quiz. They know they can bomb the quiz and still reassess later. It makes for some pretty depressing quiz scores. Combine that with little pressure to reassess early and you get a bunch of F’s for midterm.
The first set of oral exams (each student does three in a week) was very depressing as well. The most common grade was a zero, which they got if they didn’t have anything in their portfolio for the random problem selected. I made it clear they’d get an immediate zero but that we’d spend the time making sure they knew how to get started on the problem.
I just finished the second week of oral exams (separated from the first by four weeks) and saw many less zeros. I would ask what the chances of a zero were and very few said “zero chance, I’ve got something for every one.” With one student I joked that he was treating the oral exams like a casino. One student only had one he hadn’t done. That’s the number that came up😦
I talked with many of the students who got F’s and asked if they had a plan. Most had a lot of confidence that they’d pass the course but they realized they needed to start turning in reassessments much more often. While that’s great news, I also hope they start looking at the problems earlier so that the quizzes can be good enough scores to keep them from having to reassess every standard. I asked a lot of them if they were mad at me because of the F’s and no one admitted to that. Most said it was an honest assessment of their turned in work while from several I got the sense that they felt it was a far cry from their internal understanding of the material.
I know from my colleagues’ experience that most of these students will work hard if you give them a hard deadline. My only deadline is the two-week rule that says you have to get in at least a piece of crap for every standard within two weeks of it being activated (talked about in class) or else it’s a zero forever. Most standards have a quiz associated that takes care of that, but the randomness means there’s the occasional standard that doesn’t get quizzed. That’s still a pretty weak deadline compared to my colleagues’ teaching approaches. My dreamer response is that this is a lesson they should learn, but I don’t feel I’m being very successful attaining that goal.
Labs is another place where I’ve realized I have to provide a different style of support. Most labs involve up to an hour of planning, roughly an hour of data collection, and an hour devoted to analysis. What happens in practice often is an hour of planning, an hour of data collection, and everyone leaves. They know that they’ll have 2 weeks to get something in so why would they have to work on the analysis then? I think a few of the students have come to realize that I can be very useful to them during the analysis stage, but if they don’t stick around they’ll have to track me down later. One big mistake I made was to trust them to do the heavy lifting involved in getting up the Mathematica syntax learning curve to do the types of analysis I want (Montecarlo-based error propagation, curve fitting that’s responsive to variable error bars and that produces error estimates on all the fit parameters). Last week when I turned in the midterm grades I sat down and made much better support documents in Mathematica that will help them focus on the physics that needs to be studied in the lab. That’s already paid off quite nicely for a couple of students.
Well, that’s where I sit. I’m a little nervous that I’ve lost the students, though I was heartened by some good conversations with each of them this week. I think the final grades will be much better than the midterms but I’m nervous that their memory of the class will be dominated by the last few weeks of the semester when a bunch of them will be making screencasts 24 hours a day. We’ll see.
Your thoughts? Here are some starters for you:
First a quick story about go-karts. I was “racing” in one (against my friends) and I was trying to follow the wide/narrow/wide path through all the corners. But I was losing! I finally realized that the wheels had terrific grip and that I could floor the pedal and hug all the curves and never spin out. My friends knew this and by the time I figured it out it was too late.
So what’s the physics involved here? The key is to figure out why wheels start to slip in the sideways direction. They have a particular amount of grip and that force provides the instantaneous centripetal acceleration for the wheel. If you know what the grip force is, along with the instantaneous radius of curvature, you can find the fastest possible speed at that section of the road:
or
So, if you know the path of the road, you should be able to figure out the maximum possible speed at every location. So how do you do that? Well, first let’s make sure we understand how we’re mathematically describing the path.
What I decided to do was just pick some random points in the plane. Then I interpolate a path that smoothly connects them all. Here’s the Mathematica syntax that does that:
pts = RandomReal[{-1, 1}, {5}]; intx = Interpolation[pts[[All, 1]], Method -> "Spline"]; inty = Interpolation[pts[[All, 2]], Method -> "Spline"];
So now we have two functions, intx and inty, that characterize what the path does. You can plot the path now using:
ParametricPlot[{intx[i], inty[i]}, {i, 1, 5}]
which give this:
I knew there was likely some cool differential geometry formula for finding the curvature at any point and I found it at this wikipedia page:
which I can calculate now that I have the interpolation functions from above. Cool, so now I can find the radius of curvature at every point:
So now I can use the equation above for the velocity at every point and figure out a trajectory, and more importantly, a time to traverse the path, which I’d love to minimize eventually.
To be clear, I pick an arbitrary grip force and then calculate the radius of curvature and hence the max speed everywhere and I figure out how long it would take to make the journey. I realized that I’d risk the occasional infinite speed for straight portions of the track so I decided to build in a cap on the speed, that I arbitrarily picked.
So how do I figure out the time once I know the speeds. Pretty easily, actually, as for every segment of the path the small time is determined by the distance, divided by the speed:
where again i is the parametrization that I used (it just basically counts the original random points) and the speed (v(i)) is calculated as above.
Ok, cool, so if you give me a path, I’ll tell you the fastest you could traverse it. But that doesn’t yet let me figure out better paths around corners. To do that I need to generate some other paths to test to see if they’re faster. Remember they might not be as tight of turns (and so likely faster at the curves) but they’re then going to be likely longer. The hope is that we can find an optimum.
How do I generate other test paths? Well, for each of the original random points, I perturb the path in a direction perpendicular to the original path (which I’ll start calling the middle of the road). If there’s 5 points, then at each the path will move a little left or right of the center, and I’ll use the spline interpolation again to get a smooth path that connects all those perturbations.
So now it’s a 5 dimensional optimization problem. In other words, what is the best combination of those 5 perturbations that yields a path that allows the car to make the whole journey faster. Luckily Mathematica‘s NMinimize function is totally built for a task like this. Here’s what it found:
Note how in the last curve the red point has to significantly slow down, allowing the green point to win. Cool, huh?
Here’s another example that I didn’t have the patience to let NMinimize run (I let it run for 30 minutes before I gave up). It took so long because I used 10 original points, and so it was a 10 dimensional optimization problem. Luckily, just by running some random perturbations I found a significantly better path. Note how it accepts a really tight turn towards the end but it still ends up winning:
As a last note, I should mentions that making the animations took me a while to figure out. I knew the speed at every point (note, not the velocity!) but I needed to know the position (in 2D) at every point in time. I finally figured out how to do that (obviously). Here’s the command:
NDSolve[{D[intx[i[t]], t]^2 + D[inty[i[t]], t]^2 == bestvnew[i[t]]^2,
i[0] == num}, {i}, {t, 0, tmax}]
where tmax was how long the path takes. Basically I’m solving for how fast I should go from point 1 to the last point (i as a function of time). Then I can just plot the dots at the right location at {intx[i[t]], inty[i[t]]}. That worked like a charm.
Alrighty, that’s been my fun for the last few days. Thoughts? Here are some starters for you:
Here’s her tweet
When I saw it I started to wonder if angular momentum was enough to explain it. So I set about trying to model it. Here’s my first try:
It does a pretty good job showing how the fast rotation of the red ball produces enough tension in the line to slow and then later raise the green ball. Here’s a plot of the tension in the line as a function of time:
So how did I model it? I decided to use a Lagrange multiplier approach where the length of the rope needs to be held constant. Here’s a screenshot of the code:
You define the constraint, the kinetic and potential energies, and then just do a lagrangian differential equation for x and y of both particles:
(note that in the screen shot above there’s actually some air resistance added as an extra term on the left hand side of the “el” command).
Very cool. But what about the notion that the rope wraps around the bar, effectively shortening the string? I thought about it for a while and realized I could approach the problem a little differently if I used radial coordinates. First here’s a code example of a particle tied to a string whose other side is tied to the post:
I’ve changed the constraint so that some of the rope is wrapped around the bar according to the angle of the particle. Here’s what that yields:
Ok, so then I wanted to feature wrapping in the code with both masses. Here’s that code:
And here’s the result, purposely starting the more massive object a little off from vertical:Fun times! Your thoughts? Here are some starters for you:
The main idea is to have daily quizzes that are problems randomly selected from the previous day’s work. It reduces the amount of homework I have to grade, and tackles the cheating problem since it’s now a no-notes quiz. I liked it a lot in my fall class and I definitely want to keep those strengths. My suggestion was six problems per day that would act as the only contexts for any future assessments (quizzes, screencasts, oral exams, and office visits). One commenter noted that might be too much to ask the students to absorb from Tuesday to Thursday. Also, I wasn’t too happy about the double quiz I suggested on Tuesdays (one for the previous Thursday material and one to act as a re-assessment of week-old information). So, here’s my new thinking:
Things I like about this:
Things I’m not sure about:
So that’s where I’m at (for today Your thoughts? Here’s some starters for you:
Here’s what I was thinking
In addition I’m thinking that the assigned problems could be the context for both oral exams and office visits. In other words, it’s the only problems they’ll work on. Note, of course, that on all quizzes and exams the problems will be “turned inside out” so that they really represent a type of problem, instead of a specific problem.
Ok, first I realize that I have to be super careful selecting the six problems each day. There really can’t be any fillers in there or super hard ones with fancy tricks that’ll only work in weird situations. I’m up for that challenge.
Here’s one question I have: In the past class I assigned all new problems for the review day so they really had 6 problems for every standard (4 on the day we “covered” the material and 2 for the review homework). Should I assign 6 every night for this Tuesday-Thursday class? Or should I go with 4 since it doesn’t seem too hard to tackle them from Tuesday to Thursday (admittedly Thursday to Tuesday is easier)?
Second question: If a problem is randomly selected, can it be selected again? If so, maybe I should never provide solution sets. I guess I’m leaning toward that already so that they’ll know to just really have a good handle on all the problems (since they could show up anywhere: quiz, oral exam, office visit, etc).
I guess I’m right now circling around 6 problems per class and repeats are fine with no solution sets. What are the downsides I’m not seeing?
Some starter comments for you:
Cool, huh? My students found this last year when we were studying rigid body rotation. One of the things we did a lot was try to spin a tennis racquet about an axis in the plane of the head and perpendicular to the handle without it rotating about the handle. It turns out it’s pretty hard and the reason is the same as the explanation for the video above.
My friend Will posted that vid recently again and I sent him the an animation I made showing a similar result.
He asked for a blog post, so here you go. To make it a fun challenge, I wanted to see if I could do it “off the top of my head,” in other words I wanted to see if I could put together the calculation without checking my notes from last spring when I was teaching this stuff (and hence it was all at my fingertips).
I knew I couldn’t do all the inertia tensor stuff off the top of my head, so I thought I’d see if I could do it with a small number of masses so that the inertia tensor benefit wasn’t huge.
First, I laid out a few point masses to model the handle in the video. I put one at the screw, two at the handle ends, and one at the crossing point. I knew I needed to calculate the location of those points for any arbitrary Euler rotation, so I had to think about Euler rotations first. Basically these are the rotations you can do to an object to put it in any orientation (without changing the center of mass which I put at the origin). It reminded me of the discussions my students and I had about how to do that (before we’d read about Euler rotations) and I decided that sounded easiest:
What that does is the usual theta and phi orientation for a direction from the origin and an additional phi rotation of the body around that direction. It’s not how Euler rotations are sometimes presented:
It just turns out that’s harder to do numerically since you have to find the new and really new axes. In Mathematica you can do my recipe by:
RotationMatrix[, {0,0,1}].RotationMatrix[, {0,1,0}].RotationMatrix[, {0,0,1}].(points you care about)
The period is how Mathematica does matrix multiplication (including dot products).
Ok, so now I need to find the locations of my 4 points and then take time derivatives recognizing that my time-dependent variables are theta, phi, and psi. The time derivatives produce the velocities that I can use to calculate the kinetic energy as a function of the variables and their time derivatives. Then I’m in business because I can just do the euler-lagrange approach at that point. Here’s a screenshot of the code:
The locs are the locations of the dots as described before with the handle screw part being 1 unit long and the handle width being that crazy square root of 3/2 + 0.01 which will make sense below. The m function is the rotation matrix described above. The newlocs function determines where all the points are at some arbitrary theta, phi, and psi and the ke is the kinetic energy (note the D used for derivative). The el function is the Euler-Lagrange operator and the sol command puts it all together, including some initial conditions set to rotate the handle as similar to the video as I could do (note that if you don’t set the psi variable to a little off zero you don’t see the instability). Here’s the result:
And here’s an animation looking at the path the screw takes (it’s animated just so the camera can sweep around)
I remembered from the intertia tensor analysis that the stable axes of rotation (among the 3 eigenaxes) are the ones with the highest and lowest eigenvalues. So I calculated those and found that when the length is sqrt(3/2) there is not one in the middle. Here’s a comparison with the length both 0.1 above and below that magic length:
Cool, huh? I hope Will’s happy.
Some starter comments for you:
I decided to code up the game in Mathematica (this is the century of the decade of the year of the week of the hour of code after all). The low hanging fruit was to match an all-28 board against a board with random numbers on it without any repeats. It’s low-hanging because not having repeats means I don’t have to teach Mathematica how to make a choice when a repeated number is rolled (see below for my try at that). To simulate a roll I just produce 4 random integers between 1 and 6, add them, and double them. Here’s a plot of the probability of each roll:
To check if a bingo (four in a row) happens, I just check the board after each roll for any possible bingos.
Instead of playing matches, I just calculated how many rolls it would take to get a bingo for each type of board. Here’s a histogram of 1000 runs for each type (each bin is the count of the runs that took that many rolls to get a bingo for both types of boards).
I was a little surprised by this result. The random boards beat the all 28s board by a fair margin (on average). Did it surprise you?
So then I started wondering about better boards. I realized that if I wanted to do boards with some repeats on them, I’d have to teach Mathematica an effective strategy for making decisions. For example, say you rolled a 22 and you had 3 22s on your board. How do you decide where to put your bingo marker?
[pause while the reader considers]
What I decided to go with was to go for the spots that help out as many potential bingos as possible. That means corners and the inner square are worth more than non-corner edges. What I mean is that a corner spot could be a part of 3 potential bingos (left-right, down-up, and diagonal). The same is true for the inner square. But the non-corner edge spots only have left-right and up-down. So, if given a choice, it’ll go with one of the better ones. If all choices are in the same sort of spot (either all good or all slightly-less-good) then just do it randomly. However, if any of the choices gives you a bingo, I go with that one.
First I tried boards with randomly selected possibilities on each space. This allowed for repeats, since each space re-ran the random selection. Then I made boards where the randomness just mentioned was weighted by the probability expectation seen above. Here’s a comparison of all 4 types of boards:
It’s really interesting to see that the all 28s board is the worst, on average, even though we expected it to be better based on our (very limited) experience. It’s also interesting to see that the average number of rolls for a bingo is half as much for the weighted random (with repeats) board.
So what’s the best board? I don’t know, but what I did was generate 100 weighted-random boards and play 100 games with each. I then looked for the one with the lowest average. Here’s the winning board:
26 40 24 22
18 36 34 18
38 30 36 26
32 20 26 34
And here’s a histogram of running that board 1000 times:
Note that once it got a bingo in four consecutive rolls! Also note that the board doesn’t have any 28s in it!
Ok, that’s my fun for the week/day/hour of code. I hope you enjoyed it. Thoughts? Here are some starters for you: