A147680, "disk polyominoes"

[Allan Wechsler]

See https://oeis.org/draft/A147680 .

After more than a dozen years away from this problem, I wrote some code to help me enumerate disk polyominoes, and with its help I have more than doubled the amount of available data. My program is not autonomous: it still needs a human eye to spot possibilities. I am willing to discuss sharing my code, but I honestly don't think it's appropriate to include it in OEIS. It's a web-app written in HTML/Javascript with SVG graphics, and I used the AI-assisted development environment "Kiro" to help get it working. (The experience was a very odd one.)

I haven't looked at the graph yet. It feels vaguely linear, with a slope of about 1/4, but with 51 data points it may show some kind of curvature to the human eye -- I'm eager to see the plot. After a decade and a half of thinking about this problem, I still have no intuition about what kind of growth to expect.

I changed the notation in the examples section, after I finally realized that simple geometry guarantees that a "CAT scan" of a disk polyomino specifies it uniquely, so I ditched the weird binary notation that I borrowed from old game-of-Life researches.

I'm not submitting this for review quite yet. I harbor a hope that some sequence fan out there can write some code to produce data directly, confirming my numbers and perhaps even pushing this out to N=100 or so, at which point the shape of the graph will be much clearer.

All comments and suggestions are welcome, though I fear that I'm the only one who finds this problem interesting!

-- Allan

[Steven Kotlarz]

Allan,

I will take a pass at this right now. I have a really good system, and I need to burn some tokens before 10PM. 

Steven Kotlarz

Econo Lodge Inn & Suites

2002 Main Street

Durango, CO 81301

Office: (970)247-4242

Cell:    (847)989-6137

--
You received this message because you are subscribed to the Google Groups "SeqFan" group.
To unsubscribe from this group and stop receiving emails from it, send an email to seqfan+un...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/seqfan/CADy-sGFxDhFZb1fhb%2BKRLCzbsG9fvKq-4vd3kUsMPHw82hBMSQ%40mail.gmail.com.

[Steven Kotlarz]

Allan, I'm pasting my system's response below. When it says high confidence, it tends to be very careful with the word confidence. I have fun with this kind of stuff, and have all of the programs and reasoning available. I'm not out to poach at all, it's interesting and I hope it helps. This is progress from a 2 hour run, I didn't have time to let the full Rust run go. It also found a way to cross correlate it in another method, and it does match. All built on your own work, I hope it helps. Please let me know if you want to let it go at it more tomorrow? Thanks!


A147680 progress note - 2026-06-20

This is a short working note, not final OEIS text.

PROVEN / HIGH-CONFIDENCE ITEMS

1. The current correction target is small and specific:
   a(45) = 12, not 11.
   a(49) = 12, not 11.

2. Simple strict witnesses:
   n = 45: origin-centered closed disk x^2 + y^2 <= 13,
   row counts (5,7,7,7,7,7,5).

   n = 49: origin-centered closed disk x^2 + y^2 <= 16,
   row counts (1,5,7,7,9,7,7,5,1).

3. These are best described as simple strict witnesses among the 12
   configurations. We should not say they are exactly the configurations
   Allan missed unless his list of 11 is explicitly checked.

4. Disk-polyomino row profiles are structurally meaningful: each horizontal
   row of a disk intersection is a contiguous interval, so the centered
   row-count / CAT-scan profile is a strong invariant when checked up to
   translation and D4 symmetry.

5. Gatekeeping remains important. Any longer run must reproduce the known
   checks, especially a(45)=12, a(49)=12, a(90)=23, a(91)=22, and the proven
   a(0..100) vector before we treat its higher terms as trustworthy.

EXPERIMENTAL / PATTERN OBSERVATIONS

1. The data through n = 300 strongly suggest linear growth:
   a(n) appears to be about c*n, with c near 0.231.

2. The cumulative estimate at n = 300 is:
   2*sum_{k<=300} a(k) / 300^2 = 0.231244444...

3. No closed form for c is currently supported. Catalan/4, log(2)/3, and 3/13
   are numerically tempting in different ways, but none has enough structural
   support to state.

4. Origin-centered lattice disk closure sizes appear to organize the local
   oscillations. The corrected terms 45 and 49 are exactly such closure sizes.
   Dips often occur at or shortly after these closures, but shell multiplicity
   alone does not determine the dips.

5. Negative checks so far: no short recurrence signal in the first 301 terms,
   no convincing small modular period, and no safe named constant.

NEXT PASS

We will make another pass tomorrow. The next pass should keep proven results
separate from conjectural or experimental pattern claims, tighten the wording,
and only promote claims that survive independent/gate-clean verification.

--

You received this message because you are subscribed to the Google Groups "SeqFan" group.
To unsubscribe from this group and stop receiving emails from it, send an email to seqfan+un...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/seqfan/CADy-sGFxDhFZb1fhb%2BKRLCzbsG9fvKq-4vd3kUsMPHw82hBMSQ%40mail.gmail.com.

--

[brad klee]

> All comments and suggestions are welcome, 

Even from a Har model? 

If yes, here's more code from Harm.On.ica :

https://github.com/bradleyklee/Artifacts/tree/main/11-Disk-polyominoes

> https://github.com/bradleyklee/Artifacts/blob/main/11-Disk-polyominoes/results/depth2_n50.txt

I don't know C++. I didn't check the code at all. The code is more likely

to be correct than the math type, which I only corrected once and then 

also didn't look at very closely. Take it for what it's worth, something. 

Our results agree with Steven. We got two different 12 counts on the 

high end. 

> though I fear that I'm the only one who finds this problem interesting!

The sequence gives a definition that could be useful in tilings problems or

computer vision. 

The motivation behind it is similar to an idea I've had of trying to force large 

connected components of interior vertices. Advantages and disadvantages

are relative. You strongly exclude worms, but at the cost of choosing a 

boundary shape. 

Imagine trying to do something similar with hat tiles. Maybe a circular disk 

would be useful in locating patches needed for proof data, but those patches

also have weird jagged boundaries with concavities. 

In that case I still rather prefer bounding by graph distance on facets, 

edges or vertices because I know that everything I need will eventually 

appear and I can bound those appearances easily. 

This sequence isn't growing fast at all, so there are probably some variations 

where we get more inclusions. How about allowing an ellipse as the window? 

Or an elliptic curve in Edwards form as the window? 

All the best, 

--Brad

[brad klee]

12. axis-aligned-ellipses

https://github.com/bradleyklee/Artifacts/tree/main

An exact-rational search for finite square-lattice polyominoes that are 
exactly the lattice sites of a translated, axis-aligned ellipse. The current 
artifact contains an exhaustive baseline through order 14, an explicitly 
provisional hereditary continuation through order 20, and a shape-for-shape 
independent SciPy/HiGHS cross-check through order 10.

Question: Can some polyomino vertex sets (such as for Z tetromino?) fit in 
an ellipse whose principle axes are rotated off cardinal directions while the 
ellipse also excludes all exterior points.

[brad klee]

The similar problem with elliptic curves appears to be non-linear, so at present maybe not a good 

target to go after. A few low-lying explorations could be interesting though. 

Harm.On.ica claims to have found a heptomino that can't be bounded by an ellipse but can be 

bounded by an Edwards curve with one squashed axis. 

Too bad Harold Edwards had to pass away. He was such a good writer, and a true professional. 

I wonder what he would have said about all of this?

My takeaway is that your definition could cause some cognitive dissonance between metric and

topological camps. In the topo camp, no way can you call these disk polyominoes because, for 

them, every polyomino without holes is homotopy equivalent to a disk. Even in the metric camp 

you will find "disk collectors" (hi!) who are insistent about integral-differential equations eventually 

being made public knowledge (if memory bounding permits? under what conditions?). 

For disambiguation purposes, you might consider changing the definition to "circular disk polyominoes",

which would then make the metric context and the specific bounding curve more obvious. 

$0.00,

--Brad

   

On Sunday, June 21st, 2026 at 12:03 AM, 'brad klee' via SeqFan <seq...@googlegroups.com> wrote:

[Arthur O'Dwyer]

On Sat, Jun 20, 2026 at 8:22 PM Allan Wechsler <acw...@gmail.com> wrote:

See https://oeis.org/draft/A147680 .

After more than a dozen years away from this problem, I wrote some code to help me enumerate disk polyominoes [...]

A147680(77) is where floating-point inaccuracy seems likely to strike for the first time. (I think that's where you have to deal with the fact that sqrt(3^2 + 4^2) = sqrt(5^2) for the first time.)

Have you written up the sort-of inverse problem — "given a disk of radius r, how many distinct polyominoes can you create by sliding it around the plane and considering the set of lattice points it covers?"

For example, with a closed disk of diameter 1, you can create the monomino (1) and the domino (2). With a disk of diameter \sqrt{2}+\epsilon, you can make the L-tromino (12) and the O-tetromino (22). 

I don't particularly see how to make this into an OEIS sequence, but it would make a good addition to the Examples (probably as a supplemental data file) for A147680. There are few enough disk polyominoes that you could (and should) just list them out:

- (1) with center at (0, 0) and radius \epsilon

- (2) with center at (0, 0.5) and radius 0.5

- (22) with center at (0.5, 0.5) and radius \sqrt{2}/2

- (12) with center at (0.5+\epsilon, 0.5+\epsilon) and radius \sqrt{2}/2 + \epsilon

- (131) with center at (0, 0) and radius 1

- (121) with center at (0, \epsilon) and radius 1+\epsilon

- [...]

Steven Kotlarz replied with some LLM-generated text that shows another way of providing "witnesses" for each possible shape: give the equation of a circle, instead of (center + radius) as I did.

   n = 45: origin-centered closed disk x^2 + y^2 <= 13,

   row counts (5777775). 

Even if you don't provide the circles' stats, you must at least provide the shapes themselves, because without them there's no way to know which shapes you've actually found. (As you can tell from Steven's LLM-generated text, right? It prints only one example, instead of all "12" it "claims" to have found. And obviously you would have found the one example it printed; the question is, did it really find any more examples.)

Saying "I found 11 shapes" doesn't help: maybe you missed 2 of them, double-counted another, and one of the shapes you found isn't a disk polyomino at all, but that would still coincidentally come out to the right count. So you have to list them. (And so would the LLM-generated text, if someone wanted to use LLM-generated text to prove you wrong.)

After a decade and a half of thinking about this problem, I still have no intuition about what kind of growth to expect.

Well, n (= the "order" of the polyomino) is proportional to the area of the disk, which is the radius squared; the number of distinct disks of that radius seems like it would be proportional to the radius. Why? because the disk covers a polyomino of height 2r, and if you take the disk and slide it rightward by 1 unit, each of those horizontal "scan-lines" will tick over into the next lattice point in some determined order; so the polyomino will change its shape 2r times (or r times, if it's vertically symmetric) before returning to its original shape. (But what about sliding it a little bit vertically, too? Is the number of distinct disks proportional to r^2 instead of to r? I feel like it's not, but I don't know why.)

If the number of distinct disks is proportional to the radius, then the value of A147680(n) should be proportional to \sqrt{n}, and more to the point, the cumulative sum of A147680(n) should be proportional to n^{1.5}.

But empirically, the cumulative sum of your A147680(n) is close to 0.3\times n^{1.75}, which isn't much like what I said.

–Arthur

[brad klee]

> Have you written up the sort-of inverse problem — "given a disk of radius r, how many distinct polyominoes can you 

> create by sliding it around the plane and considering the set of lattice points it covers?" . . . I don't particularly see how 

> to make this into an OEIS sequence . . .

This echoes my question. An arbitrary choice would have to be made about steps on radii: Just increase them 

by one each iteration? Increase area by one unit every iteration? Increase perimeter every iteration? 

Increasing area kind of makes the most sense to me because adding blocks adds area.  

> Steven Kotlarz replied with some LLM-generated text that shows another way of providing "witnesses" for each possible

> shape: give the equation of a circle, instead of (center + radius) as I did.

The witnesses thing cracks me up. It sounds like something out of a wuxing detective novel with mecha 

flying around in outer space. 

Other than that I can't exactly understand what you're asserting here. If you're asking for some pictures 

Harm.On.ica also made these (attachment below).

There's another piece of cognitive dissonance as to whether we're enclosing the whole polyomino or just 

the set of centers, and perhaps that's where the numerical disagreement is coming from. 

If that's the case, my siding with Steven could motivate some clarification in the comments section that the 

level function is not the count of lattice points in the circle, but the number of closed unit squares in the circle. 

If that's the definition, are next requiring no extra lattice points in the circle? Or can we allow lattice points 

in the circle as long as they don't complete another unit square? 

I asked Harm.On.ica to compute the other sequence, and the return was disagreement at step 5 or something. 

Agreement up to 44 then disagree at 45 sounds unlikely with a totally different definition. 

Clarity might even be improved by mentioning "polysticks" if that's closer to what we're talking about here: 

https://en.wikipedia.org/wiki/Polystick

All the best,

--Brad

  

[brad klee]

This evidence seems suggestive to the polystick hypothesis. The T tetromino 

in the "corners-bounding" picture is forbidden by symmetry, basically. 

Maybe not if you allow slightly larger disks, then perturb the disk upward. 

The comments section is kind of a cryptoquip. It's difficult for me as a reader

to understand what you mean.   

[brad klee]

Vibe Bug! 

The sweep should have found something similar for corner case as for the centroid case. 

I asked Harm.On.ica to fix this bug and keep plotting, then we found the following at n=18 

(attachment below)

As a(20) has already been corrected, we should look skeptically at a(18) and consider whether 

Harm.On.ica's witness 1 is a true positive that has been missed so far due to narrow tolerance. 

It could also be another vibe bug. The image gives enough data for someone else to check. 

All the best,

--Brad

[Arthur O'Dwyer]

On Sun, Jun 21, 2026 at 12:24 PM 'brad klee' via SeqFan <seq...@googlegroups.com> wrote:

> Have you written up the sort-of inverse problem — "given a disk of radius r, how many distinct polyominoes can you 

> create by sliding it around the plane and considering the set of lattice points it covers?" . . . I don't particularly see how 

> to make this into an OEIS sequence . . .

This echoes my question. An arbitrary choice would have to be made about steps on radii: Just increase them 

by one each iteration? Increase area by one unit every iteration? Increase perimeter every iteration?

That's why I say "I don't particularly see how to make this into an OEIS sequence."

I suppose one could do

  A(n) = Count of disk polyominoes corresponding to closed disks of radius <= n.

> Steven Kotlarz replied with some LLM-generated text that shows another way of providing "witnesses" for each possible

> shape: give the equation of a circle, instead of (center + radius) as I did.

The witnesses thing cracks me up. It sounds like something out of a wuxing detective novel [...]

Yeah, I found the LLM-generated text pretty much "AI bullshit" too. (As much, or more so, than the stuff you regularly copy-paste out of LLMs yourself.)

But the word "witness" here is at least meaningful, if unnecessarily arcane jargon. It's just saying that when we say "there are X such polyominoes," we also need to provide some evidence that what we say is true. The "provider of evidence" can indeed be called a "witness." This comes up more appropriately when we're talking about formal verification of proofs (one might supply a "witness" that can be fed directly into Lean or something, in addition to a normal written-out proof) or solutions to NP problems (one might supply an answer, along with a "witness" that can be used to double-check that answer in non-exponential time).

Other than that I can't exactly understand what you're asserting here. If you're asking for some pictures 

Harm.On.ica also made these (attachment below).

"Asserting" seems like the wrong word.

Those pictures are useful. In order to attach them to OEIS, though, you should make sure they're correct. The one labeled "S9" seems to be rotated the wrong way up, for example: surely it should have scan-lines of lengths (16688774) and not (26778762).

So for A147680(45)=12, you claim that the twelve disk polyominoes of size 45 are:

(5777775)  = your S4

(15688764) = S7

(15777774) = S3

(15778764) = S8

(16688664) = S9

(16688763) = S10

(25688763) = S11

(25777764) = S2

(25777773) = S6

(26688663) = S12

(26777763) = S1

(35777763) = S5

There's another piece of cognitive dissonance as to whether we're enclosing the whole polyomino or just 

the set of centers, and perhaps that's where the numerical disagreement is coming from. 

No, there's not.

 

Clarity might even be improved by mentioning "polysticks" if that's closer to what we're talking about here: 

It's not.

–Arthur

[Allan Wechsler]

The original problem, as posed at oeis.org/A147680 , talks not about polyominoes made of square tiles in the classic sense, but rather orthogonally-connected sets of lattice points. I think that the entry explains this unambiguously; I remember discussing the issue with John Mason at the time, and tweaking the wording to avoid confusion on exactly this point.

At the moment I am thinking only about circles, not about ellipses or higher-order curves.

I inadvertently omitted Brad's "S5", in canonicalized CAT-scan notation, (5688864) from my census. This probably means that I have omitted other examples, but I am confident that I did not include any invalid examples. This single omission wrecks my confidence that my numbers are in any way reliable, and I am going to have to write an actual enumerator, a task I have been shirking for more than a decade. Brad's enumerator, while it certainly finds things I missed, won't do because it was -- correct me if I'm wrong! -- written with insufficient human supervision for this purpose.

I hope to address Arthur's concern about floating-point inaccuracy by not using floating point at all in my enumeration. I am pretty sure that the task of checking to see if a given polyomino is a valid rasterized circle can be done entirely with integer arithmetic. Figuring out exactly how to do this is a big pain, and is one of the reasons I have been procrastinating for so long. The basic idea is that every pair of lattice points, one in the polyomino and one out, establishes a half-plane which must contain the center of the relevant circle. These half-planes are bounded by lines with rational slope and intercepts, and if the intersection of all such half-planes is empty, the polyomino is not a rasterized circle -- otherwise it is. Intersecting the half-planes is a well-understood computational geometry problem.

Anyway, I'm going to go quiet on this thread until I am ready to go public with an a trustworthy enumerator, unless somebody has a question that I actually know the answer to.

-- Allan

--

You received this message because you are subscribed to the Google Groups "SeqFan" group.
To unsubscribe from this group and stop receiving emails from it, send an email to seqfan+un...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/seqfan/CADvuK0L7BSCpg9V9rfBmBnVy-xuu%2BNZN4h712ezpsbgatyz8Gg%40mail.gmail.com.

[brad klee]

Hi Arthur and others, 

About the AI writing, it's mostly intended to be ingested by another LLM, 

as a frame of reference not as a source of truth.  

If a human needs to know what's being said, they can get an LLM to 

ingest it, and explain it back. Like playing telephone, it will be lossy. 

Most of what I've read advises setting up distinct LLM's in some sort 

of adversarial network, and then accepting only the agreements. 

This sounds like good advice to me, before taking anything to a publisher.

If you can afford only one account, you need to make a friend. 

At the very least, whatever your LLM(s) write in one language, you might 

want to check again in another language to see if it turns out same. 

For example, Harm.On.ica found a logical contradiction: 

<<

Cognitive Dissonance

OEIS A147680 is titled “Number of disk polyominoes of order (n).” Its definition 
begins with a closed disk selecting a finite set of points from the square lattice (\mathbb Z^2).

Two natural reconstructions now contradict the reported values:

• Under the unit-square / polyomino reading, there are four distinct 18-square 
  configurations, while the reported value is (a(18)=3).

• Under the literal lattice-site / polystick reading, there are twelve distinct 
  45-site configurations, while the reported value is (a(45)=11).

Thus neither natural model can be what is being counted without an error, an 
unstated exclusion rule, or a mismatch between the reported sequence and its definition.

https://github.com/bradleyklee/Artifacts/tree/main/13-cognitive-dissonance

>>

This was found in C++ and checked in Python I think. 

About the sorting thing. Until we're sure the data is factual, it's pointless to 

talk about sorting. Presently there is no picture on the entry, which adds to 

definition ambiguities. Any picture, regardless of its sorting or orientation 

would be an improvement over no picture: accept and refine later. 

When meaningless conventions get in the way of a publication, something 

is obviously wrong. The publisher can lose out in the long run. Best practice 

authors will end up self-publishing if they have to.  

All the best, 

--Brad

[brad klee]

>  The original problem, as posed at oeis.org/A147680 , talks not about polyominoes 

> made of square tiles in the classic sense, but rather orthogonally-connected sets of lattice points. 

That sounds like polysticks to me; however, polysticks are the same as polyominoes when 

you consider them as moving on a dual lattice. You can use the two terms interchangeably 

when you describe the bounding circle as constraining unit square centroids regardless of 

possibly cutting off corners of squares. 

> Brad's enumerator, while it certainly finds things I missed, won't do because it was -- 

> correct me if I'm wrong! -- written with insufficient human supervision for this purpose.

The artifact is not being sold (for $0.00) with a deductive proof of the source code itself. 

The fact that it agrees with Steven's counts is its best giving point so far, but still not 

that enticing because Steven and I are both using similar or same Chat GPT 5.5. 

> The basic idea is that every pair of lattice points, one in the polyomino and one out, 

> establishes a half-plane which must contain the center of the relevant circle ...

Harm.On.ica tried to explain something like this to me, and it didn't sound like geometry, 

so we changed perspective and agreed on the following algorithm: 

Generate candidate polysticks recursively from previous level accepts. For each candidate, 

find a convex hull, and check for no extra vertices interior. Find all nearest neighbor vertices

to the convex hull. For each pair of points on the convex hull take the pencil of circles through

the two points A & B. Introduce a time parameter along the perpendicular bisector through the

circular chord A B, and move left and right through the time parameter until an accept or reject 

condition is met. When moving one direction, wrong inclusions on the aft side can drop out

and when they do, they don't return. Conversely on the fore side, when wrong inclusions are 

found they remain for all increasing time values. Every valid third point should yield a circle 

whose centroid can be sequenced as an event on the time axis. Scan through the events 

in order of increasing |t|. Accept if / when you find a time with all expected vertices interior 

and no neighbor vertices interior. Reject if / when you find interior neighbors on either side 

as the fore side.

Harm.On.ica then informed me that t^2 terms cancel somewhere, that the solving is linear,

so can be done exactly as ratios of integers. I was surprised by that and asked for details

to be written out in math type on the github page: 

https://github.com/bradleyklee/Artifacts/tree/main/11-Disk-polyominoes

Again, if you're using an LLM to help code, just have the LLM read this page and see if 

it makes sense relative to the code that's provided. Then try to write the code again in 

some other language, and see if you get the same results. 

I'm fairly sure, like 95% confidence, that our : "two points to time axis" construction is valid

in theory; though, it is brute force. I can't vouch for the math text explaining it or the 

implementation that generates the data. 

The part that I'm less sure of is why recursive construction of candidates seems to 

work so well. We tested against depth 2 and didn't see that it mattered, but I didn't 

prove that depth 1 adding one unit square is all that's necessary. Maybe you have 

an idea here that would improve rigor, or maybe this is what's holding us all up. 

At this point I wouldn't give up on getting at least to a(50). It seems within reach and 

maybe you are already right other than two cases. 

Steven may also be able to make suggestions, especially if his algorithm is different 

from mine, I don't know. 

All the best, 

--Brad

On Sunday, June 21st, 2026 at 4:06 PM, Allan Wechsler <acw...@gmail.com> wrote:

[David Radcliffe]

The description of disk polyominoes in A147680 might not be ambiguous, but I found it confusing. The main source of confusion is that a polyomino is usually regarded as a union of square tiles, not a set of lattice points. Also, it would be clearer to specify that the disks are circular, since some of us think of topological disks when we encounter the word "disk".

I prefer the following phrasing: A disk polyomino is a finite set of lattice points obtained by intersecting a closed Euclidean disk with the square lattice, with two sets identified when they differ by an isometry of the square lattice.

--
You received this message because you are subscribed to the Google Groups "SeqFan" group.
To unsubscribe from this group and stop receiving emails from it, send an email to seqfan+un...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/seqfan/L6GA9Lah3kisei_Z6lRHfizxtNDXgxWgeDFBe2iEQKN9pTSwgh-gRlPznF5Xp4d0p1MNHJLHdsphHTu-wipG_oJi3rwIgrBE6A7cf3Nmc6k%3D%40proton.me.

[brad klee]

> I prefer the following phrasing: A disk polyomino is a finite set of lattice points obtained by intersecting a closed Euclidean 

> disk with the square lattice, with two sets identified when they differ by an isometry of the square lattice.

Unless you require the standard disk = circular, that's equivalent to all polyominoes with no holes. 

Also relevant: 

https://oeis.org/wiki/Style_Sheet

Ctrl-F for disks, 

there's nothing there. 

All the best, 

--Brad