# What is the maximum DTM with K+J vs K?

What is the maximum DTM in the endgame king + janus vs king on a 10x8-board ?

The janus can move like a bishop or like a knight. Since both sides have two additional pieces, the board has 10 columns and (like the chess board), 8 rows.

• Is there a name for this variant? Apr 12, 2015 at 21:36
• The name should simply be "janus-chess" Apr 12, 2015 at 22:44
• The usual name for the B+N piece is princess.
– bof
Apr 14, 2015 at 4:39
• What's a DTM??? Apr 27, 2015 at 11:20
• @Tony Ennis: DTM = depth to mate (that is, number of moves to mate, perfect play being assumed). Apr 27, 2015 at 11:31

I don't know the exact answer for the 10x8 board (used e.g. in Capablanca Chess, where your Janus is called the Archbishop), but I have something that could get you well along toward an exact answer, though with some effort on your part (see further below). On the 8x8 board the max DTM is 17 moves (as you may already know). My conjecture is that the 10x8 answer won't be far off from that, and I'd bet a small sum that it's no more than 19 moves. (After all, if the defending king starts in the center of the 10x8 board and you start corralling it, you're almost immediately into a situation in which, as you start pushing to an edge/corner, the rest of the mating sequence will be indistinguishable from how it would play out on the 8x8 board, as the rest of the board's real estate becomes simply irrelevant.) But as for getting an exact 10x8 answer ...

A few years ago, I was toying around with generating tablebases for Seirawan Chess, which is played on the standard 8x8 board, but features the same extra pieces as Capablanca Chess. In the Seirawan variant, the Janus/Archbishop piece goes by the name Hawk. I just now placed into a github repository my old C++ source code for generating a complete KHK (or, KJK in your terminology) tablebase on the 8x8 board, along with the output files, where e.g. `KHK.0` is the set of all mate positions, and `KHK.34` is the set of all positions where it is 34 ply until black is mated. It hasn't undergone tons of testing, but this and similar ones for e.g. KEK (king-and-elephant/chancellor vs. king) appeared to function correctly and agree with known results. For instance, the max DTM of 17 moves on the 8x8 board indicated by my KHK stuff is the same value given at the wikipedia page for the Princess piece (yet another name for this particular fairy chess piece).

My code would need to changed a bit in order to adapt to your 10x8 board question. In particular, my code makes full use of the symmetries of the 8x8 board in order to reduce the number of positions needing to be examined, and of course the 10x8 board is less symmetric; so that would need an alteration. Additionally, my somewhat crude representation/storage of positions in this simple program would need to be changed and accounted for (in terms of some hard-coded arithmetic that's performed, for instance) in order to adapt to the 10x8 board. You can see the sort of thing I mean in the following snippets:

``````// Constants to name the symmetries of the board.
const int sym_id = 1;
const int sym_x = 2; // reflect across x axis
const int sym_y = 3;
const int sym_d1 = 4; // reflect across a1-h8 diagonal
const int sym_d2 = 5;
const int sym_r90 = 6; // rotate 90 degrees clockwise
const int sym_r180 = 7;
const int sym_r270 = 8;

int Apply_Symmetry (int sym, int square)
{
// Applies the specified symmetry of the board to the specified square
//     (in 0x88 terms).

if (sym == sym_d1) {
return (square / 16) + ((square % 16) * 16);
}

else if (sym == sym_y) {
return ((square / 16) * 16) + (7 - (square % 16));
}

else if (sym == sym_d2) {
return (7 - (square / 16)) + ((7 - (square % 16)) * 16);
}

else if (sym == sym_x) {
return (square % 16) + ((7 - (square / 16)) * 16);
}

else
return 0;
}
``````

But anyway, the structure and the functionality is there if you wanted to modify the code to produce an answer for the max DTM on the 10x8 board, and all told there's only a few hundred lines of code.

I make it 21 moves, but it's quite likely that my home-made Python code (too long and messy to post here!) has mistakes, so please take this with a grain of salt. I get 112 positions which require 21 (white) moves to mate. The first one on the list is the following board, with black to play:

(Janus shown as a bishop because I couldn't easily find a suitable graphic. Image created using http://www.apronus.com/chess/wbeditor.php)

• The result looks plausible to me: There are two more files compared to the 8x8 board, so the King chase is two files longes. You nedd one Janus move and one white King move for each file. Apr 30, 2015 at 9:05
• In this page of results, the author calls this bishop+knight combo an archbishop. They give lengths of longest wins on the 10x8 board, and for king and archbishop and king their figure is 21 moves, agreeing with your answer. Oct 16, 2021 at 15:10