journal link (Physical Review D)

In a sentence: **Really light QCD axions don’t have to be fine-tuned; you can avoid overclosure naturally if inflation is long enough and slow enough.**

This went up on arXiv in May and was published in PRD last week. In the meantime, I’ve given talks on it at two conferences: the Patras Axion-WIMP at DESY in Hamburg*, and IDM (Identification of Dark Matter) at my alma mater, Brown University.

Talk slides (IDM edition): PDF, PPT

The PPT version has a cute animation, which I left out of the PDF because my laptop can’t display PDF animations anyway.

If you’re curious about my work but aren’t a specialist in axion dark matter, let me know and maybe I’ll write a post explaining all of this with less jargon

**If you’re ever in Hamburg, check out the gardens (Planten un Blomen) and the model train museum (Miniatur Wunderland). And DESY, of course.*

All of the posts prior to this one are random odds and ends from high school and college. Going forward, I’ll probably be using this for updates on my research and such. Maybe some fun side projects, too.

]]>What is the area of the grey region?

]]>**EDIT:** Curly and square brackets are unnecessary and confusing. Future versions of Bracket will be nice and round:

(XY) –> (()XY)

{XY} –> (XY)

[X] –> (X)

This leads to a single elegant function (), which can take 0-3 arguments:

() is the lambda *metaprocedure*

(X) is an identifier

(XY) is the procedure X applied to argument Y

(MXY) is the *metaprocedure *M applied to arguments X and Y

This simplifies the language, and should therefore make code much more readable. It also helps me achieve my goal of creating the purest form of LISP: one in which there are no data types and no keywords — only parentheses. (Everything (must (be parentheses))).

**ENDEDIT**.

Here’s the syntax for Bracket:

(XY): the lambda expression λX.Y, where X is an identifier and Y is an expression.

[X]: an identifier (variable) unique to X (that is, [], [[]], [potato] are all unique identifiers.)

{XY}: the expression X applied to Y. Equivalently, {} is just used for grouping, but all lambda expressions must be explicitly grouped with anything they are applied to.

For example, ([][]) is the identity function, [x] is an identifier, and {([][])[x]} = [x].

A program is just an expression that evaluates to a list* of numbers**, which can be translated into a string of characters with

{{P([]([[]]{{C{{[]I}O}}[[]]}))}N}

(the Bracket syntax for Pλx.λy.C(xIO)yN)

Where:

P is the program

C is a function that prepends an ASCII character to a string

I is a function that increments an ASCII character once

O is the ASCII null character 0x00 or \0

N is the empty string “”

*lists are represented in Church encoding, “Higher-order function” style.

**numbers are Church numerals (see the same article)

Now that that’s out of the way, here’s a “Hello World” program: (actually prints “HW” for the sake of brevity)

{{([]([[]]([[[]]]([[[[]]]]{{[[[]]][]}{[[]]{[[[]]][[[[]]]]}}}))))([]([[]]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[][[]]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}))}{{([]([[]]([[[]]]([[[[]]]]{{[[[]]][]}{[[]]{[[[]]][[[[]]]]}}}))))([]([[]]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[]{[][[]]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}))}([[[]]]([[[[]]]][[[[]]]]))}}

And here it is in the new, 300% rounder version of Bracket:

(((()(())(()((()))(()(((())))(()((((()))))(((((())))(()))(((()))((((())))((((())))))))))))(()(())(()((()))((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(((()(())(()((()))(()(((())))(()((((()))))(((((())))(()))(((()))((((())))((((())))))))))))(()(())(()((()))((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((())((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(()(((())))(()((((()))))((((()))))))))

]]>Let’s say you have a large collection of points in a plane, and you need to find the closest point to point **P**. The obvious (and inefficient) way is to calculate the distance to every point, which requires N square roots and takes far too long to be useful in some cases (such as an early draft of Voronoid that didn’t work out because of this inefficiency). Here’s a better way I came up with:

- For every point
**Q**, calculate |x_{Q}-x_{P}| and |y_{Q}-y_{P}|. Find the sum and maximum of these values and store them. - Find the two points with the smallest sum and the smallest maximum.
- If the same point has the smallest value for both, you win! That’s the closest point to
**P**. Otherwise… - Go through the points again, using the stored values this time. For every point that has a
*smaller sum than that of the point with the smallest maximum***and**a*smaller maximum than that of the point with the smallest sum*, calculate the standard Euclidean distance from**P**: sqrt((x_{Q}-x_{P})^{2}+(y_{Q}-y_{P})^{2}). The closest point to**P**within this (likely very small) set of points is also the closest point overall.

I’m sure there are absurdly efficient algorithms for doing this better, but this one is very easy to implement (assuming it works, which I’ve sort of heuristically proven). In fact, I might go back and try my early version of Voronoid with this algorithm and see how it runs.

]]>I just tossed this together this morning. Next up: pretty colors!

(Note: Internet Explorer 8 or below can’t do canvases.)

]]>You have not discovered a potion for remembering, but for reminding; you provide your students with the appearance of wisdom, not with its reality. Your invention will enable them to hear many things without being properly taught, and they will imagine that they have come to know much while for the most part they will know nothing. And they will be difficult to get along with, since they will merely appear to be wise instead of really being so.

It could easily be about Wikipedia, Google, or the Internet in general.

Actually, it’s about a much older technology: writing. Specifically, it’s (Plato’s account of) Socrates’ (account of Thamus’) commentary on writing from *Phaedrus*. Full text here, via an interesting NY Times article on an AI Jeopardist.

What do you think? Was writing worth it? How about the Internet?

(Postscript: relevant comic from Chuck & Beans)

]]>[Note: So far, Voronoid supports Chrome and Firefox, on any operating system. It may work in Opera, but probably won’t in IE or Safari.]

]]>One solution (and probably the easiest good one) is to use SSL encryption. That sounds complicated, but it’s usually as easy as entering “`https://`

” instead of “`http://`

” before the URL. I say “usually,” because not all websites support SSL (it’s much more complicated from their end!).

Of course, it’s a pain in the neck to type that in all the time, so here’s a quick solution for Chrome or Firefox. In either browser, it forces “`s gmail.com`

” to redirect to “`https://gmail.com/`

“, for example.

**Chrome:**

Wrench menu –> Options –> Basics tab –> Default Search section –> Manage –> Add…

Then add the following “search engine” keyword:

Name: SSL

Keyword: s

URL: https://%s

**Firefox:**

Bookmarks –> Organize Bookmarks –> Unsorted Bookmarks (in the sidebar)

Then Organize –> New Bookmark…

Then add:

Name: SSL

Location: https://%s

Keyword: s

**Caveat:**

This will force the first page you visit to use SSL, but the website may drop the security for future pages. For example, “s gmail.com” will stay encrypted, because Google is smart, but “s facebook.com” will go back to plain old HTTP after you log in, because Facebook…. isn’t that smart.

Plugins like HTTPS Everywhere (Firefox only, because of technical limitations in other browsers) will automate the process and keep your connection secure all the time.

]]>Who’s there?

**Man.
**

man who