The building block of stochastic calculus is Brownian motion, or Weiner process. We take a stochastic process starting at zero that is then defined by independent, Gaussian increments:

or in shorthand, $dB_t \sim N(0, \delta t)$, where $d B_t$ is the increment and $\delta t$ is the time interval. We care about $\delta t \rightarrow 0$. We note that the differences $dB_t$ are all independent if they don’t overlap.

Quadratic Variation

Given a function $f$ we define the quadratic variation to be $(d f\; d f) = \lim_{\left|\Pi\right| \to 0} \sum_{j = 0}^{n - 1}(f(t_{j + 1}) - f(t_j))^2,$ where $\Pi$ is the sum of the square distance between the intervals on the time grid $t_j$.

If a function is differentiable, the mean value theorem implies that these differences go to zero as the intervals $[t_j, t_{j + 1}]$ go to zero. This is however not the case for Brownian motion. Indeed, Brownian motion is continuous but not differentiable (we will not prove this here).

Lemma (Quadratic Variation of Brownian Motion). $d B_t \; dB_t = dt$.

Proof. Omitted.

Covariance

We will now pause to consider the covariance of Brownian motion. We can compute (using our definition above)

A Stochastic Differential Equation

We want to write down a stochastic differential equation which will define the increments of a stochastic process $S_t$. We will do this in the form of a drift-diffusion model

where $\mu$ and $\sigma$ are arbitrary (non-stochastic) functions defining the drift and volatility.

The Black-Scholes equation is

We wil find this yields asset prices $S_t$ that are log-normally distributed.

Ito’s Lemma

We want to ‘taylor expand’ a stochastic process by using a stochastic differential equation. Suppose we have an SDE of the form above,

We want to ignore ‘small’ terms. Normally we would ignore anything smaller than $O(dt)$ and $O(S_t)$, but quadratic variation implies the $d W_t^2$ term will be order $O(d_t)$ and can’t be ignored. So doing this gives us Ito’s Lemma:

For the drift-diffusion model above we have

Pricing a Call Option

Now we can put together all of the building blocks above to come up with the price of a call option. We have

We want to compute the price of the call option with a strike $K$, that is, one whose terminal value is

We can model this as a stochastic process $c(S_t, t)$ which has the above boundary condition and evolves according to the Black-Scholes equation above.

We want to write down a SDE for $c$. Applying Ito’s Lemma gives us

Note that this implies that if we hold the portfolio $\Pi(S_t, t) = c(S_t, t) - \frac{\partial c}{\partial S_t} S_t$, the portfolios is left with no exposure to the ‘randomness’ (Brownian motion) term, and so our portfolio is riskless\footnote{This, you may have guessed, is a delta hedged portfolio.}.

This portfolio evolves according to (after expanding)

Now we already know we have a risk free portfolio, and so it must evolve according to the risk free rate $r$ by

These models must give us the same result ultimately, and equating them gives

This is a PDE describing the price of a call option.

[If the formatting of this post looks odd in your feed reader, visit the original article]

In 1946, Paul Erdős proved a lovely result¹ about such functions, which we are going to prove!

Theorem. If $f: \mathbb{N} \rightarrow \mathbb{R}$ is increasing and totally multiplicative, then $f(n) = n^{\alpha}$, for some $\alpha \in \mathbb{R}$.

Proof. Suppose that $f(2) = 2^{\alpha}$, and take $n > 2$ such that $f(n) = n^{\beta}$. Then for any $\ell \in \mathbb{N}$, we can write

for $a = \lfloor \log_2(n) \ell \rfloor$. Since $f$ is increasing, evaluating the function at each of the above must still satisfy the inequality

This implies the inequality

But this has to hold for all $\ell \in \mathbb{N}$, and thus we must have $\beta = \alpha$, and we’re done.

[If the formatting of this post looks odd in your feed reader, visit the original article]

Problem. Show that

$$ \sum_{r=0}^{n}(-1)^{r}\binom{n}{r}^2 = \begin{cases} 0 &\mbox{if $n$ is odd}, \\ (-1)^{n/2} \binom{n}{n/2} &\mbox{if $n$ is even}. \end{cases} $$

The normal solution involves looking at the coefficient of $x^n$ in the equation

but it is possible to solve the problem without resorting to the binomial theorem.

A Combinatorial Solution

Solution. We begin by noting that

is the number of ways of choosing $r$ elements from $\{1, \dots, n\}$ followed by $n - r$ elements from $\{n + 1, \dots, 2n\}$. Then as we sum over $r$, the sum (ignoring the minus sign) counts the total number of $n$ element subsets from $\{1, \dots, 2n\}$.

Now to each $n$-element subset of $\{1, \dots, 2n\}$, we assign ‘1’ if the subset contains an even number of elements in $\{1, \dots, n\}$, and a ‘-1’ if it contains an odd number. Summing over all of these assigned numbers then is equivalent to our original sum.

Consider the following mapping. Given a subset of size $n$, let $1 \leq x \leq n$ be the smallest integer for which exactly one of $x, n + x$ is in the set. We then toggle $x$ and $n + x$ in the subset, giving us another subset of $\{1, \dots, 2n\}$ of size $n$, but maps between elements of different sign. It’s also clearly an involution (applying it twice gives you back the original subset).

If $n$ is odd, then this mapping is well defined, since if there was no such element $x$, then $x$ and $n + x$ would always be in the subset, and there would have to then be an even number of elements in the subset (which isn’t the case). If $n$ is even, then this mapping is only not well defined when we always have both $x$ and $n + x$ in the subset. Thus the mapping is not defined on $\binom{n}{n/2}$ subsets, since we can fully specify each of these by choosing the $n/2$ elements of $\{1, \dots, n\}$ to include. Also all such subsets were given the sign $(-1)^{n/2}$.

Thus if $n$ is odd, we can use this mapping to pair each element with a positive sign to an element with a negative sign, and the total sum is zero. If $n$ is even, then we can do this for all but $\binom{n}{n/2}$ elements, all of which have sign $(-1)^{n/2}$, and thus summing up we get the desired answer,

[If the formatting of this post looks odd in your feed reader, visit the original article]

[If the formatting of this post looks odd in your feed reader, visit the original article]

This post draws on this talk by Luciano Mammino, and this repo by Ronen Amiel.

What is a Module Bundler?

A module bundler is a tool that takes pieces of JavaScript and their dependencies and bundles them into a single file, usually for use in the browser. You may have used tools such as Browserify, Webpack, Rollup or one of many others.

It usually starts with an entry file, and from there it bundles up all of the code needed for that entry file to be able to run.

Module bundlers have two main stages:

1. Dependency resolution
2. Packing

Starting from an entry point (such as app.js above), the goal of dependency resolution is to look for all of the dependencies of your code (other pieces of code that it needs to function) and construct a graph (called a dependency graph). Once this is done, you can then pack or convert your dependency graph into a single file that the application can use.

Let’s start out our code with some imports (I’ll elaborate on the reason later).

const detective = require('detective')
const resolve = require('resolve').sync
const fs = require('fs')
const path = require('path')

Dependency Resolution

We first need to decide how we want to represent a module during the dependency resolution stage.

Module Representation

For each module we need:

• The name and an identifier of the file
• Where the file came from (in the file system)
• The code in the file
• What dependencies that file needs

A graph structure then would gets built up by recursively checking for dependencies within each file. In JavaScript, the easiest way to represent such a set of data would be an object.

let ID = 0
function createModuleObject(filepath) {
  const source = fs.readFileSync(filepath, 'utf-8')
  const requires = detective(source)
  const id = ID++

  return { id, filepath, source, requires }
}

In the piece of code above, we call a function detective to the dependencies that the given file needs. Detective is a library that can “find all calls to require() no matter how deeply nested”, and using it means we can avoid both parsing the code and looking for requires in the resulting AST (Abstract Syntax Tree).

One thing to note is that if you try to do something weird like:

const libName = 'lodash'
const lib = require(libName)

the module bundler will not be able to find it (because that would mean executing the code). This behavior is the same in almost all module bundlers.

So what does running this function from the path of a module give?

We can see that this is exactly what we wanted to get. The next stage in the process is dependency resolution, but first I want to talk about the module map.

Module Map

When importing modules in Node, you can perform relative imports, like require('./utils'). To allow this behavior, the bundler would need to know what the right ./utils is once everything is packaged. The way this is implemented is with the module map.

Our module object has a unique id key, which will be our ‘source of truth’. When we are performing our dependency resolution, for each module, we will keep a list of the names of what is being required along with their id. This way, we can get the correct module at run-time.

This also means that we can store all of the modules in a non-nested object, using the id as a key.

Dependency Resolution

The main purpose of this dependency resolution is to start at the root/entry module, and to look for and resolve dependencies recursively.

To make clear what is meant by ‘resolve dependencies’, in Node there is a function require.resolve, and that is used to figure out where the file your module is requireing is. The need for this to be an explicit process is because we can import both relatively or from a node_modules folder. Luckily there’s an npm module named resolve which implements this algorithm for us. We just have to pass in the dependency and base URL arguments, and it will do all the hard work for us.

We need to carry out this resolution for each dependency of each module in the project. We also need to create the module map that was mentioned earlier. This process is implemented as follows.

function getModules(entry) {
  const rootModule = createModuleObject(entry)
  const modules = [rootModule]

  // Iterate over the modules, even when new 
  // ones are being added
  for (const module of modules) {
    module.map = {} // Where we will keep the module maps

    module.requires.forEach(dependency => {
      const basedir = path.dirname(module.filepath)
      const dependencyPath = resolve(dependency, { basedir })

      const dependencyObject = createModuleObject(dependencyPath)

      module.map[dependency] = dependencyObject.id
      modules.push(dependencyObject)
    })
  }

  return modules
}

At the end of this function, we are left with an array named modules which will contain module objects for every module/dependency in our project. With that in place, we can move on to the final step: packing.

Packing

In the browser, there’s not really such thing as modules, and there’s also no require or module.exports. So even though we have all of our dependencies, we currently have no way to use them as modules.

Module Factory Function

Enter the factory function. A factory function is a function (that’s not a constructor) which returns an object. It is a pattern from object oriented programming, and one of its uses is to do encapsulation and dependency injection, which is exactly what we want to do. Using a factory function, we can both inject our own require function and module.exports object that can be used in our bundled code and give the module its own scope.

// A factory function - we can replace require and module with
// our own dependency injection
(require, module) => {
  /* Module Source */
}

For each module object obtained in the previous stage, we are going to going to transform it so that a factory function can be used.

Packing

We are now ready to perform the packing stage. The main process performed here is putting each module into a module factor function, and then doing dependency injection using the module map.

function pack(modules) {
  const modulesSource = modules.map(module => 
    `${module.id}: {
      factory: (module, require) => {
        ${module.source}
      },
      map: ${JSON.stringify(module.map)}
    }`
  ).join()

  return `(modules => {
    const require = id => {
      const { factory, map } = modules[id]
      const localRequire = name => require(map[name])
      const module = { exports: {} }
      factory(module, localRequire)
      return module.exports
    }
    require(0)
  })({ ${modulesSource} })`
}

The final output is an IIFE, which means that if you run that code in the browser (or anywhere else), the function will be run immediately. The IFFE is also a good way to encapsulate scope, so that we don’t pollute everything with all of our modules.

We also inject two kinds of require functions, require and localRequire. The first accepts the id of a module object, but of course the source code isn’t written using ids. Instead, we are using the other function localRequire to take any arguments to require by the modules and convert them to the correct id. This is using those module maps discussed earlier.

Lastly, we call require(0) to require the module with an id of 0, which is our entry file. And that’s it! Our module bundler is 100% complete!

module.exports = entry => pack(getModules(entry)) 

Congratulations! 🎉

So we now have a working module bundler.

This probably shouldn’t be used in production, because it’s missing loads of features (like managing circular dependencies, making sure each file gets only parsed once, es-modules, and so on) but this has hopefully given you a good idea of how module bundlers actually work.

In fact, this one works in about 60 lines if you remove all of the comments. Thanks for reading, and I hope you have enjoyed a look into the workings of our simple module bundler.

Check out the finished source code at https://github.com/adamisntdead/wbpck-bundler.

[If the formatting of this post looks odd in your feed reader, visit the original article]

Problem. Find an upper bound on the maximum probability that two randomly chosen elements of a finite non-abelian group commute, and show that it is attained.

Discussion

Suppose that we have a group $G$, and a random element $g \in G$. We have then got two cases.

1. If $g$ commutes with everything, then the probability that $g$ commutes with another element is obviously 1.
2. If $g$ does not commute with everything, we need to find the probability that it commutes with a random other element.

This gives us two things to compute (or more correctly, to bound): the probability that a random element commutes with everything, and the probability that if it does not commute with everything, then it commutes with a random element. The natural approach is then clearly thinking about centers and centralisers.

Solution

Let $G$ be a finite group. If it is non-abelian, then its center $Z(G)$ is not the entire group, that is, $G$ has some element $g \not \in Z(G)$. Then $C_G(g)$, centraliser of $g$, also cannot be the entire group, as that would contradict $z \not \in Z(G)$.

Noting that $C_G(g) \leq G$, and $Z(G) \leq C_G(g)$, we can then apply Lagrange’s theorem twice to get

Now let $x$, $y$ be a random elements of $G$. We can bound the probability that they commute with

This bound is achieved by the Quaternion group $Q_8$.

[If the formatting of this post looks odd in your feed reader, visit the original article]

• A group isomorphic to every non-trivial subgroup. $\mathbb{Z}$.
• A group of order $n$ which has no subgroup of $k$, where $k \mid n$. $A_5$, since it is simple and thus has no subgroup of index 2. Another example is $A_4$ (which is the smallest such group), but it’s a little harder to show that it works.
• Two non-isomorphic groups with the same order type. $C_4 \times C_4$ and $C_2 \times Q_8$. Both have 1 element of order 1, 3 elements of order 2, and 12 elements of order 4. If this property holds for two abelian groups, then they are isomorphic.
• A non-abelian group with all non-identity elements of order $p$. The group of upper triangular $3 \times 3$ matrices over $\mathbb{Z}/p\mathbb{Z}$ with 1s on the diagonal.
• A non-abelian group of order $p^3$. Same as above.
• An infinite group whose proper subgroups are all finite. The group $\left\{k/2^{n} : k, n \in \mathbb{N}, k<2^{n}\right\}$ with addition modulo 1. This is the Prüfer $2$-group.
• A group $G$ with $N \trianglelefteq G$ and $H \trianglelefteq N$ such that $H \not \trianglelefteq G$. In $D_8$, we have $\langle s \rangle \trianglelefteq \langle r^2, s \rangle \trianglelefteq \langle r, s \rangle = D_4$, but $\langle s \rangle \not \trianglelefteq D_4$.
• A group in which every group generated by $n$ elements has a surjective homomorphism to it. The free group with a basis of $n$ elements.
• An infinite group with every non-identity element of order 2. $C_2 \times C_2 \times C_2 \times \cdots$.
• An infinite non-abelian group with every element of finite order. $S_3 \times C_2 \times C_2 \times \cdots$.
• A group $G$ with $G \cong G \times G$. $G = C_2 \times C_2 \times C_2 \times \cdots$. We can also get $G \cong G \times G \times G \times \cdots$ in the natural way.
• Two non-zero elements of $\mathbb{R}$ that generate a subgroup not isomorphic to $\mathbb{Z}$. $1$ and $\sqrt{2}$.
• A group with two subgroups whose product is not a subgroup. Consider $D_3$, with the distinct reflections $s, s’ \in D_3$. Then ${e, s} \times {e, s’} \not \leq D_3$.
• A quotient group of a finite group that is not isomorphic to a subgroup. $Q_8 / {-1, 1}$.
• A group isomorphic to its automorphism group. $S_3 \cong \operatorname{Aut}(S_3)$.
• A non-abelian infinite group where the set of elements of finite order is a subgroup. $\operatorname{GL}_2(\mathbb{Q})$. We note that this also holds for all abelian groups, and indeed any group where the elements of finite order commute with each other.
• A group that is not a semi-direct product. $Q_8$.
• A group $G$ with two isomorphic subgroups $H, K$ where $G/H$ and $G/K$ are not isomorphic. Take $G = C_4 \times C_2$, with $H = \langle (2, 0) \rangle$ and $K = \langle (0, 1)\rangle$. Then $G/H \cong C_2 \times C_2$, and $G/K \cong C_4$.

[If the formatting of this post looks odd in your feed reader, visit the original article]

[If the formatting of this post looks odd in your feed reader, visit the original article]