We use a pattern to specify when a certain description for a bid must be shown. For example, we want the 2♣ bid to have the description Stayman after an opening of 1NT, but when we open 2♣, we want a different description to be shown.
The way we do this, is by specifying how an auction must look for a specific description to be apply. We specify an auction by a list of bids, separated by a -. For example, the pattern for the 2♣ Stayman bid, looks like this:
1N - P - 2CHere 1N denotes a bid of 1NT, P means a pass and 2C is the 2♣ bid. You can click on the pattern to view what auctions will match on it. For simplicity and readability we use only one-letter codes for all suits and no trumps:
| Suit | Code |
|---|---|
| ♣ | C |
| ♦ | D |
| ♥ | H |
| ♠ | S |
| NT | N |
Because we have four players in an auction we have to include bids for all four players. The pattern
1N - 2C will be incorrect for a Stayman bid, because the 2♣ bid is made by the left hand opponent of the 1NT opener.
Thus, pass bids always have to be included in a pattern. Since 1NT opening (often) has the same meaning irrespective of the number of passes that came before it, these options have to be explicitly included in it's pattern:
1N, P - 1N, P - P - 1N, P - P - P - 1NThis pattern consists of 4 sub-patterns. If patterns are separated by a , then the whole pattern will match if any of it's sub-patterns match on the auction. As we often have opening bids that have the same meaning irrespective of the number of passes that preceded them, we have made a more consice way of writing the pattern above:
*P - 1N*P can be interpreted as 0, 1, 2 or 3 passes. This shortcut makes the pattern much more readable. We have also added several other 'shortcuts':
| Shortcut | Equivalent pattern |
|---|---|
*P | 0, 1, 2 or 3 passes |
0/1P | 0 or 1 passes |
1/2P | 1 or 2 passes |
2/3P | 2 or 3 passes |
0/1/2P | 0, 1, or 2 passes |
1/2/3P | 1, 2 or 3 passes |
We have now covered the basic syntax of a pattern. However, most bidding systems contain many forms of symmetry. For example, in most natural systems, the responses of 1NT to a 1♣, 1♦, 1♥ or 1♠ opening has the same meaning: 6-10 HCP, no fit and no biddable 4 card on the 1 level. Therefore we would like to only create one bid in our system with this meaning that matches on all these auctions:
1C - 1N, 1D - 1N, 1H - 1N, 1S - 1NOf course this pattern is valid, but it looks bloated and is not very readable. To mitigate this, we can use a suit selector 1X:
1X - 1NHere the character X means ♣/♦/♥/♠. This greatly simplifies our pattern. Below is the list of all suit-selectors that can be used:
| Suit Selector | Matching suits |
|---|---|
X | ♣/♦/♥/♠ |
A | ♣/♦/♥/♠/NT |
m | ♣/♦ |
M | ♥/♠ |
B | ♣/♠ |
R | ♦/♥ |
L | ♣/♦/♥ |
U | ♦/♥/♠ |
To make our patterns more powerful, we have included syntax for other types of auctions.
Imagine we always play Puppet Stayman after partner has bid 2NT showing a strong balanced hand. There might be multiple auctions that lead up to such a 2NT bid, for example it can be after a direct 2NT opening, a 2NT rebid after a 2♣ opening or when partner has followed 2NT over a weak opening of the opponents. Ideally we do not want to include all these sub-patterns in the pattern of the 3♣ Puppet Stayman bid. For this we have added a trick:
#2N - P - 3CThe # in the pattern above says match on all auctions that end with 2NT - Pass - 3♣, no matter how we got there. Using this pattern we only have to add one pattern for our 3♣ Puppet Stayman bid. There is however a problem with this approach.
Since we match on all auctions ending in this sequence, we will likely also include auctions where we do not want 3♣ to mean Puppet Stayman. To sove this issue, we will also match on the name of the 2NT bid:
#2N[Strong NT] - P - 3CThe text between [] is used to check against the name of the 2NT bid in the auction. If the name of that bid is equal to 'Strong NT', then the pattern will apply. This check is not case-sensitive. Now all we have to do is to make sure that every time we want a 2NT bid to have 3♣ mean Puppet Stayman that the 2NT bid should be named 'Strong NT'.
The name-matching option [] can be used on every bid in the pattern where it is needed. The use of the step-in selector # can only be used once per sub-pattern and only at the start.
The syntax that has been described up until now is already quite powerful! But bidding systems are complex and to keep the number of unique bids in our system limited, we will need more tools to capture these in patterns of reasonable length. A concept we have in every system are suit raises. For example, when partner opens 1 of a major and we have a fit with a minimum hand, we will raise partner to the 2 level. With our current syntax, there is no way to specify such a raise in a pattern, without creating a sub-pattern for each individual suit.
We cannot use the pattern
1M - P - 2M for a simple major suit raise. This is because besides 1♥ - P - 2♥ and 1♠ - P - 2♠, this pattern will also match on the auctions 1♥ - P - 2♠ and 1♠ - P - 2♥. What we want to express is that for both 1M and 2M we want M to be the same suit. We can solve this issue by introducing variables:
1a - P - 2aa=M
This pattern uses one variable a with the value M. This means that the variable is either ♥ or ♠. The difference is that in the pattern, the variable always has the same value everywhere. Therefore this combination of pattern and variables gives the desired result: 1♥ - 2♥ and 1♠ - 2♠.
Variables can be used in a pattern together with regular suit-selectors. However, variables must always be in lower-case, whereheas suit-selectors are always in upper-case. Here is an example of a pattern combining the use of a suit selector and a variable. Try to guess what auctions this pattern matches on!
1m - 1a - P - 2aa=M
This pattern can be interpreted as: "after an opening of 1♣/1♦, an overcall of 1 Major followed by a pass and a raise to 2 Major". Note that we could have also defined a variable for m, for example b=m. However, this makes the pattern more complex without altering it's meaning. Therefore best practice is to only use variables where neccesary and use regular suit-selectors in the pattern wherever possible.
When we use multiple variables in a pattern, we might want to ensure that some variables can never be the same suit simultaneously. For example, the following pattern describes an 2-level overcall over a 1-level opening:
1a - 2ba=X, b=X
Although perfectly valid, this pattern might include several instances that we do not want to have the meaning of a regular overcall. For example a and b can have the same value, meaning that the auction 1♠ - 2♠ is included in this pattern. Obviously, we do not want this. To prevent such behavour, we can add a conditioning on b to not have the same value as a:
1a - 2ba=X, b=X^!a
This variable statement can be interpreted as follows: "a can be ♣/♦/♥/♠ and b can be ♣/♦/♥/♠ and (^) in any instance, b cannot have the same value as a (!a)".
The pattern above as an another problem. Most people play that regular overcalls have a different meaning from jump overcalls. With our current syntax, we cannot easily express this in our pattern. This is because whether 1a - 2b is a jump is determined by the number of bids between a and b. To address this issue, we have extended the syntax as follows:
1a - +0b(2)a=X, b=X^!a
The statement +0b(2) can be read as "a jump (+) of magnitude 0 (0) to bid 2b b(2)". The specification of the level (2) is optional, but if we want to distinguish overcalls on the 1 or 2 level, we will need it.
Now the pattern for a jump overcall, like 1♣ - 2♠ or 1♥ - 3♣,would look very similar:
1a - +1ba=X, b=X^!a
Note that we have removed the specification of the level, as it is not mandatory to use.
We now have a syntax to describe jumps. However, we still need to extend our syntax if we want to accurately and easily describe bids like reverses. Consider the following two auctions:
Both auctions can be described with the following pattern:
1a - P - 1b - P - +0c(2)a=X, b=X, c=X^!a^!b
This pattern says "A 1-level opening, followed by a 1-level response and finally a rebid on the 2-level by opener of a new suit without jump". The conditioning a=X, b=X, c=X^!a^!b ensures that each bid is a new suit.
The problem here is that, in a natural system, the first auction shows a normal opening with diamonds and clubs, while the second auction is knows as reverse and shows a strong hand with diamnods and hearts. Ideally we would like to split this pattern in two. One pattern that matches on all non-reverse bids and one that matches all reverse bids. For this, we will need to introduce two new symbols, namely < and >:
1a - P - 1b - P - +0c(2)a=X, b=X, c=X^!a^!b^<a
1a - P - 1b - P - +0c(2)a=X, b=X, c=X^!a^!b^>a
You can see by clicking these patterns that they indeed differentiate between reverse and non-reverse. This is achieved by the addition of the specification ^<a which says that the rank of suit c must be lower than that of suit a. Similar logic is used to match on the reverse variants.
We have now covered all that is possible in the pattern syntax. Are you ready to try expirimenting with it yourself? Click here to give it a try!