use-bms

Files (3)

• README-ja.md
• README.md
• SKILL.md

SKILL.md (first lines)

[← Back](../../README.md) | [English](README.md) | [Japanese](README-ja.md)

# use-bms

Drive the `bms` C command in `c/` of the yaBMS repository. Target: Linux (also
WSL). The MCP server in `mcp/` is a separate, optional path — do not use it for
these tasks.

## Locate the repository

All paths below are relative to a yaBMS checkout. Find it in this order:

1. the current working directory, if it contains `c/bms.c`;
2. `~/code/yaBMS`;
3. otherwise clone it — `git clone https://github.com/koteitan/yaBMS.git`.

This skill is mirrored in `~/my-skills`, so it may be active outside the yaBMS
tree. Never assume the skill directory sits inside the checkout.

## Build first

`bms` is not committed; it must be compiled before any use.

```bash
cd <repo>/c
make            # gcc -O0 -g -std=c99 -o bms bms.c
```

Requires `gcc` only — no libraries beyond libc. Re-run `make` after editing
`bms.c` / `bms.h`. `make clean` removes the binary.

Check that the binary exists before running anything; if `./bms` is missing,
run `make` rather than reporting a failure.

## Input syntax

A Bashicu Matrix is written as consecutive parenthesised columns, optionally
followed by brackets:

```
(0,0,0)(1,1,1)(2,1,0)(1,1,1)[2]
 \_____ columns _____________/ \_ bracket
```

- Each `(...)` is one **column**; the numbers inside are the rows.
- **Every column must have the same number of rows.** A mismatch prints
  `error:ys mismatch` and then segfaults.
- `[n]` is the expansion count. Multiple brackets `[2][1]` are allowed and are
  consumed left to right (see `-r`).
- Always quote the argument in the shell — parentheses are shell metacharacters.

## Commands

All forms take the matrix as the last positional argument(s).

| Task | Command |
|------|---------|
| Expand | `./bms [-e] [-d] [-r] [-v ver] "<bm>"` |
| Standard check | `./bms -s [-d] [-v ver] "<bm>"` |
| Compare | `./bms -c [-d] "<bm0>" "<bm1>"` |
| Loop check (single) | `./bms -l [-d] [-v ver] "<bm>"` |
| Loop search (range) | `./bms -lr [-d] [-v ver] "<bm0>" "<bm1>" [<depth>]` |
| Help | `./bms -h` (add `-d` for copyright) |

Options combine into one token (`-sd`, `-lrd`, `-ed`, `-lrdv 1.1`).

### Expand — `-e` (default)

Expansion is the default when no command flag is given, so `-e` is optional.

```bash
$ ./bms "(0,0,0)(1,1,1)(2,1,0)(1,1,1)[2]"
(0,0,0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,2,0)(2,2,0)(3,3,1)(4,3,0)
```

`-r` keeps expanding while brackets remain, printing every intermediate step:

```bash
$ ./bms -r "(0)(1)(2)(3)[1][1][1][1]"
(0)(1)(2)(2)[1][1][1]
(0)(1)(2)(1)(2)[1][1]
(0)(1)(2)(1)(1)[1]
(0)(1)(2)(1)(0)(1)(2)(1)
```

`-d` prints the internal decomposition (parent index matrix, good/bad part, bad
root, `lnz`, delta, ascension matrix) before the result.

### Standard check — `-s`

Prints `1` if the matrix is standard, `0` otherwise. With `-d`, prints the
comparison trace and `standard.` / `non-standard.` instead.

```bash
$ ./bms -s "(0)(1)"
1
$ ./bms -s "(1)"
0
```

### Compare — `-c`

Prints `1` / `0` / `-1` for `bm0 > bm1` / `==` / `<`. Brackets are ignored, and
so is `-v` (comparison is version-independent).

```bash
$ ./bms -c "(0,0)(1,1)(2,0)" "(0,0)(1,1)(1,1)"
1
$ ./bms -cd "(0,0)(1,1)(2,0)" "(0,0)(1,1)(1,1)"
(0,0)(1,1)(2,0) > (0,0)(1,1)(1,1)
```

### Loop finding — `-l`, `-lr`

`-l <bm>` first expands the matrix until no brackets remain, then reports `1` if
the result loops (gets no smaller under a further expansion), `0` otherwise.

`-lr <bm0> <bm1> [depth]` searches for a loop from `bm1` down to `bm0` within
`depth` expansions (default `3`). Detection is heuristic and may miss loops.

From koteitan/my-skills, MIT.

More from koteitan/my-skills