Binary Operators in somerby.net/mack/logic

Binary Operators in somerby.net/mack/logic now have different precedences.  See here.

Alternative Hexadecimal Digits

I've been collaborating with Valdis Vītoliņš on hexadecimal digits.  The result is a new set of digits:

They follow a design where the horizontal strokes represent 1, 2 and 4 in the binary composition of the number which each digit is supposed to represent.  The rules for constructing the digits are:

• 0 is represented by a digit that looks like an 'o' or a '6'.
• 8 is represented by a digit that looks like a miniscule rho or a 'P'.
• Numbers 1-7 and 9-15 are represented by digits whose shape follows this plan:

We considered several possible sets of digits before settling on this one.  We choose this new set of digits because 

1. We find it is the easiest to encode and decode.
2. We find that pairs of these digits can be combined into readable ligatures.

Valdis has created fonts for the digits and ligatures, which I have incorporated into a branch of the Hex Editor plugin for Notepad++ .  It has all the features of the mainline Hex Editor plugin, but also offers the option of viewing hexadecimal data with the new characters in place of the traditional 0-9A-F.  If you'd like to use it, then download this zip file and run the setup executable contained therein:

• HexEditor.zip 

The fonts look like this:

Hexadecimal Digits AND Ligatures!

A few years ago, I posted a set of hexadecimal digits that I invented that could serve as an alternative to the customary 0-9 and A-F.  My idea was to make a set of digits that could be represented in the standard numeric LCD display where the digit somehow represented a binary version of the number it represents. See here.  Now someone has done one better.  In the blog post "We think about yotabytes, but can't handle just one byte", Valdis Vītoliņš describes a hexadecimal of his own invention based on the same idea which adds one innovation; he combines pairs of digits into ligatures, thereby creating a system of 256 symbols that can represent numbers 0 though 255.  That's one symbol for each possible byte value, and the numeric value for each symbol can be read out of its shape with a simple algorithm.  If you're a programmer <ahem>, software engineer, like me, who looks at hex dumps often, this is an intriguing idea.  I might actually try use this.

Counterexample Feature Completed for somerby.net/logic

The "Counterexample" button now works for modal statements as well as non-modal statements in somerby.net/mack/logic.

Addtions to somerby.net/mack/logic

I added operators for strict implication and definite description to somerby.net/mack/logic.  I also added the beginnings of a feature that finds counterexamples for statements that are not necessarily true.  It only works for non-modal statements, but I think I can expand it to work for modal statements as well.

Free Variables Are Back (partially)

I've added some support for free variables back into somerby.net/mack/logic.  They are now treated as constants denoting actual objects.  At the moment, they are not allowed in statements which contain modal operators, since I have not yet found a satisfactory way to deal with constants in modal statements.  Or at least a way that I'm willing to commit to.  I'm working on it.  I've been reading Possible Worlds, "Actualism" and "SQML" and other such things for instruction and insight.  I knew that there was more than one system of modal logic, but this reading has made me appreciate the need for me to define exactly what system of modal logic somerby.net/mack/logic implements.  So I'm working on that, too.

No More Free Variables (for now)

Formerly, somerby.net/mack/logic would accept statements with free variables.  It would bind them all with existential quantifiers.  That seemed to work; it yielded the results I expected for all of the statements I had tried - up until a few days ago, when I found it to fail for some statements.  One such statement is "a=b".  I would expect this to be a contingent statement; true or false depending on whether or not a and b denoted the same object, but the application decided it to be necessarily true.  It's not hard to see why if we expand the statement, as the application does, to be "3b,3a,a=b". There is always an a and a b which are identical in any nonempty universe; they are identical when they are the same object.

So, for now, the application rejects statements that contain free variables.  I'm working on finding a way to decide them correctly.  As soon as I've found one (and I've assured myself that it really is correct), I'll incorporate it into the application and allow free variables once again.