# The Greek surrender of 2015: a big misunderstanding?

“Do you not know, my son, with how little wisdom the world is governed?”

– Axel Gustafsson Oxenstierna af Södermöre, 1648.

(Disclaimer: I’m neither an economist nor a political scientist. I suppose I share that with most people writing on this subject, and it doesn’t seem to bother anyone.)

Virtually everybody writing about the Eurogroup negotiations on a Greek bailout that occurred last weekend seems convinced that Wolfgang Schäuble, the German finance minister, is a monster of some sort. Even supporters of the Eurogroup position seem to think so. Part of this alleged monstrosity consists in a readiness to use power that vaguely corresponds to a certain well known clichè about Germans.

But what if he’s not a monster hell bent on ruining the Greeks to impose a rule of terror on the rest of Europe? Everybody thought Varoufakis & co had a plan, and many are still trying to cope with the realization that they probably didn’t (me included, btw) so maybe it’s time to revise the hypothesis that Mr. Schäuble aspires to be some kind of Vlad the Impaler.

If you substitute this assumption with one where Schäuble is a reasonably nice guy that wants the Eurozone as well as the EU to work, but is constrained by politics, you can construct a theory whereby the disastrous (to all sides) result of the negotiations between Greece and the Eurozone is due to a misunderstanding in the motivations of the different actors. Basically, the theory is based on the following hypotheses:

1. Nobody seriously believed that the leftist-Keynesian Tsipras-Varoufakis duo possibly wanted something else than a way for Greece to leave the euro without suffering too much wreckage in the process.
2. Nobody serioulsy believed that, on the contrary, the only real red line of the Greek side was that they wanted to keep the Euro, and were willing to pay any cost whatsoever to this end.
3. Due to some unfortunate properties of the subject matter (currencies) nobody considered it feasible that the other side would talk openly about their real motives, setting the stage for a massive communication failure.

In this alternative world Schäuble and the German negotiators are probably still wondering how it could be that a real, hard-core leftist Greek government would reject the chance for an assisted (!) Euro exit including debt restructuring and continued membership in the european union, and instead would sell off the country for a deal that is so hilariously bad that it literally benefits no side, simply because nobody expects it to work.

But was Greece offered the option of an assisted euro exit? I think so, but more to that in a minute.

It is widely accepted by now that the biggest problem of Greece is that it has a currency that it can’t devaluate. The best solution, given how the Eurozone is built, is for Greece to get a new currency it can devaluate at will, print at will, etc. Varoufakis writes that this isn’t feasible, but I always thought he meant that it would just be very difficult to pull off unilaterally for a small country that’s basically bankrupt.

On the other hand, there is also a general agreement about it being very toxic to even start talking about exiting the euro. Any official is supposed to be saying, over and over, that the euro is great and irreversible, whatever he/she thinks is true, because doing otherwise would trigger bank runs and other really bad things. A consequence is that a government that decides to leave the euro is indistinguishable from one that wants to keep it, if you go from what its officials are saying about this point. The same applies to statements about wanting to kick a country out of the euro. But when negotiators start second guessing the motives of each other because they cannot use plain language, they risk talking past each other for months and then getting a result nobody wanted.

Now, back to the assisted exit option. On the eve of the very, very last negotiation the following option (due to Schäuble, as rumor has it) appears at the end of a leaked draft agreement:

[In case no agreement could be reached, Greece should be offered swift negotiations on a time-out of the euro area, with possible debt restructuring].

Here is how you could translate it, assuming that Schäuble doesn’t actually want to throw Greece to the wolves.

• Greece should be offered swift negotiations = Greece will recieve help if it decides to leave the Euro
• time-out of the euro = Greece gets its own currency and stays in the EU (this is not a small matter!!) plus return option at a later date (ridiculous, but needed so everybody, but especially the Greek government, can keep face)
• possible debt restructuring = possible debt restructuring! In case no agreement could be reached = the above document is as good an excuse for leaving the euro as we can possibly concoct – and you are here because you need a good excuse back home, aren’t you?

So, under this theory, Tsipras and Tsakalotos were offered debt restructuring and a viable solution to many fundamental Greek problems, including a nice arsenal of strategies to make the implementation politically feasible. Schäuble couldn’t do it openly, so he did it more or less covertly. But Tsipras rejected this option, choosing instead additional pain for the already battered Greek people as well as handing the Eurozone the keys of the country (which it quite likely never wanted). Maybe because he didn’t understand what was happening, or maybe because he has other motives.

Varoufakis said about the proposal that this is the kind of proposal that is advanced when one does not want a deal. Cool, but then – why wouldn’t the Eurogroup want to have a deal? At the moment, the only explanation I’ve seen put forward is that they just wanted Greece to go up in flames.

Maybe, and then they really are all monsters, not just Mr. Schäuble. And pretty stupid, too. I don’t think this is very likely, but maybe I’m naive.

### Slidy+Mathjax presentation example

A few weeks ago, I blogged about using slidy and mathjax for writing presentations. I’ve put together a zip file with an example that allows you to try out this combination (the download link is at the end of this post), and perhaps even get you started at writing the presentation for that conference a few weeks down the road. Here are the instructons for it:

1. Download and unpack the basic starter kit somewhere. The kit is just a two slide presentation framework with a title page and one page with interesting formulas. It includes some basic css to make the presentation look nice, and a logo I invented in five minutes.
2. Download the MathJax zip archive, and unpack it into the directory where the slides are. Then rename the directory it made for itself to MathJax. It is important that the MathJax folder is in the same folder as the presentation slides, because otherwise some security features of firefox won’t allow mathjax to use the highest quality mathematics rendering. The issue is described here in more detail.
3. Unpack the Slidy2 zip archive, also into the same folder as the starter kit.
4. Open the slides with a current firefox or chromium browser. It should work. Hit F11 to get to full screen mode (and hit it again to return to normal mode).

That’s it.

## Tips and tricks

• You may want to usese firebug to debug the slides and do live repositioning/restyling of elements. This makes designing slides much faster.
• You can embed videos into the presentations using html5 tags.
• It is probably a good idea to obtain a decent html editor. I use emacs with nXhtml. It seems also bluefish is a good bet. I didn’t find any of the wysiwyg editors out there particularly useful.
• If you use emacs, you can use cdlatex mode to edit latex formulas in html documents.
• There is a lot of information on html and css in the mozilla developer network.

## Disclaimer, etc.

There are no warranties of any kind associated with the starter kit.

The contents of the zip file are under the MIT license.

### Finally an alternative to LaTeX for writing mathematical presentations

For some time now I have been looking for an alternative to LaTeX for presenting mathematics. With MathJax, a Javascript package for displaying mathematics on the web, LaTeX lost its monopoly on typesetting equations. And the combination of MathJax with slidy, a framework for authoring presentations in html, finally provides a real alternative to LaTeX.

Until now, I, like most mathematicians, used LaTeX beamer for writing presentations on my research. I had been somewhat unhappy with that solution for some time, for a variety of reasons. One of them is that it is hard to embed anything into a LaTeX presentation. In theory, images are easy to embed, but there is quite a bit of quirkiness associated to that. Movies are a different matter, and it is a familiar sight that speakers interrupt the flow of their slides to launch another application for playing a video. Something fancy like an interactive graph? I have never seen anyone do it in LaTeX. In fact, the only interactive features I ever see are page-up and page-down.

Another problem is that LaTeX doesn’t really work well for the task of making presentation designs, and as a result most designs look clumsy. If you compare the designs that are available for blogs and web pages with the designs in the beamer theme matrix (in particular the yellow one) you will see what I mean. The acceptance of those themes is limited, and I estimate that 30% of all beamer presentations use the default theme, which incidentally is the least decorated. Adding a truetype font, like those you can find here is possible, but difficult and error prone. Granted, maybe it actually is easy, but I haven’t succeeded.

In a quest for alternatives I stumbled upon slidy, and my first impression was that it is much more convenient for creating slides, and that it is easier to get good looking results. Since slidy presentations are web pages, theming is much better supported than with LaTeX. Inserting images and arranging them as desired is very easy, and I look forward to embedding a video using a plugin that works reliably. Typesetting mathematics, the most important reason for using LaTeX, is handled fantastically well by MathJax. MathJax is fully compatible with latex, which means that I can continue to use the very same notation for equations and formulas that I use everywhere else. And the rendering quality of MathJax is completely on par with that of LaTeX.

The main drawbacks are that the presentations do not look exactly the same everywhere, and that it is not as easy to print them to produce handouts. I very rarely see handouts, and I have never produced them myself from slides. Whether it is a problem that the look of presentations is slightly different from device to device is something that I intend to find out. My first impression, though, is that the differences are small enough not to matter. If you use percentages for image sizes then the worst that can happen is that you need to scroll a slide down, or change the font size, which amounts to pressing the ‘-‘ key. Thus, at the moment these drawbacks seem to me like a very small price to pay for something that in other respects definitively looks like a better alternative. I will continue to use latex to write articles, but I am glad that I finally will be able to move away from it for presentations.

### ASDF system definition files for Fortran 77 codes

One of the Common Lisp packages that I find very useful is f2cl, originally written by Kevin A. Broughan and Diane M. K. Willcock [1], with recent contributions by Richard J. Fateman and Raymond Toy [2]. It can convert a lot of the Fortran 77 codes out there fairly reliably into quite fast Common Lisp code. The lack of a fancy home page or even a separate project (it is currently part of CLOCC) makes it somewhat hard to find, but should not be taken as a sign of abandon. A more prominent project that uses f2cl is the open source CAS system Maxima.

The advantages of using f2cl over a foreign function interface are, among other things, that the generated Common Lisp code has far better error handling, and is much more convenient to use (for a Common Lisp programmer, at least).

I think it would be nice to have ASDF system definitions for the Fortran 77 packages bundled with f2cl. This would complement the mk:defsystem definitions already available. A small difficulty is that the f2cl compiler has a lot of options, and it is desirable to want to set them globally, eventually overriding them on a file by file basis. At least, this is what is done in some of the .system files. I managed to convince ASDF to do this, but I am not sure if the way i did it is the best solution. From the point of view of OOP this can be (and will be) improved, of course. I’m referring more to the need of things like accessing ASDF symbols that are not exported. In any case, having global options that can be overriden on a component basis looks like a feature one would like to have every now and then.

A typical f2cl .system file looks like this (for example):

(mk:define-language :f2cl
:compiler #'f2cl:f2cl-compile
:source-extension "f")

(mk:defsystem minpack
:source-pathname "clocc:src;f2cl;packages;minpack"
:components
((:file "minpack"
:language :lisp)
(:module "minpack"
:source-pathname ""
:source-extension "f"
:package :minpack
:language :f2cl
:keep-lisp-file t
:relaxed-array-decls nil
:array-type :array
:array-slicing t
:package :minpack)
;; etc

Note that :file components can also have a :compiler-options, although I don’t know how the overriding behavior really is.

To convince ASDF to behave in a similar way, I subclassed the asdf:module class, adding an f2cl-options slot.

(defclass f2cl-module (module)
((f2cl-options :initform nil
:initarg :f2cl-options
:accessor f2cl-options)))

To have an f2cl source file type with corresponding compilation, one does

(defclass f77-source-file (cl-source-file)
((f2cl-options :initform nil
:initarg :f2cl-options)))

(defmethod source-file-type ((c f77-source-file) (s module)) "f")

(defmethod perform ((o compile-op) (f f77-source-file))
(apply #'f2cl:f2cl-compile
(cons (make-pathname :name (component-name f)
:type "f"
:defaults (component-pathname f))
(compiler-options f))))

But here is the catch. Compiler options have to be computed from the module *and* the file. I did it like this

(defmethod f2cl-options ((c f77-source-file))
(let* ((c-c-o (slot-value c 'f2cl-options))
(p-c-o (when (typep (parent c) 'f2cl-module)
(f2cl-options (parent c)))))

;; override global options.
(append c-c-o p-c-o)))

where

(defmethod parent ((c f77-source-file))
(slot-value c 'asdf::parent)) ;; Oops

Anyway, it works. Now I am wondering if I overlooked the apropriate feature in ASDF, or another way of doing this. Accessing ‘asdf::parent is good enough for me, but before attempting to contribute .asd files to f2cl, I would prefer to have a more solid solution.

The Nelder-Mead algorithm is a rather popular algorithm for (low dimensional) nonlinear programming. The original version (from 1965, see [1]) has known and varied failure modes, but never really had to fear for its popularity. It doesn’t need derivatives, which can be quite convenient, and has a reputation to work well even with noisy and rough functions.

Recently, a few provably convergent variants have been devised (see [2], [3], and [4]). The one by A. Bürmen et al [4], the “Grid Restrained Nelder-Mead Algorithm” (GRNMA) is notable because it does not impose a “sufficient descent” condition at each iteration, which makes it closer to the original algorithm.

A reliable, simple-to-use derivative free minimization routine is a handy little tool to have around. It turns out that implementing the GRNMA is also a pleasant programming project.

### More on the alias method

It turns out that, as pointed out by Jens Axel Søgaard, the method I wrote about a few days ago is the alias method by Walker, as found in D. Knuth’s TAOCP, but with a modification by R. A. Kronmal and A. V. Peterson. Their contribution, it seems, was the algorithm to rearrange the intervals in O(N) operations.

In any case, there is a very good and complete textbook, nowadays available freely on the net, where all these things are explained, disected, and thoroughly overengineered in every good sense of the word. The book is “Non-Uniform Random Variate Generation”, by Luc Devroye (thanks to Brad Lucier for mailing me this great link).

Below you’ll find some additional notes about the method, prompted by reading part of the book, and a link to an updated version of the CL code. (For simplicity, I will write as if in the context of my first post).

### Slime 2.0

A new version of slime has been released. See here, or download it directly as a gzipped tar archive or as a zip file.