The rectangle-based description was noted by Sridhar Ramesh when he solved this.

All examples in this Bongard Problem feature some points in 2D connected by arced line segments; these segments do not cross across one another and no segments are nowhere vertical; they never double back over themselves in the horizontal direction.So, in a chain of segments it should be clear when one is to the left of another. It should also be clear when one segment ought to be considered above another.

Note that all examples do result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but are collapsed further: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

All examples in this Bongard Problem feature some points in 2D connected by arced line segments; these segments do not cross across one another and no segments are vertical. It should be clear when one segment ought to be considered above another, and in a chain of segments it should be clear when one is to the left of another.

Note that all examples do result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but are collapsed further: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

All examples in this Bongard Problem feature some points in 2D connected by arced line segments; these segments do not cross across one another and no segments are vertical. It should be clear when one segment ought to be considered above another, or in a chain of segments when one is to the left of another.

Note that all examples do result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but are collapsed further: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

All examples in this Bongard Problem feature some points in 2D connected by arced line segments; these segments do not cross across one another and no segments are vertical. It should be clear when one segment ought to be considered above another, or in a chain of segments when one should be considered to the left of another.

Note that all examples do result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but are collapsed further: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

All examples in this Bongard Problem feature some points in 2D connected by arced line segments; these segments do not cross across one another and no segments are vertical. It should be clear when one ought to be considered above another, or to the left of another in a chain of segments.

Note that all examples do result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but are collapsed further: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

All examples in this Bongard Problem feature some points in 2D connected by arced line segments; these segments do not cross across one another and no segments are vertical. Thus it is clear when one should be considered above another, or to the left of another in a chain of segments.

Note that all examples do result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but are collapsed further: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

All examples in this Bongard Problem are some points in space connected by arced line segments; these segments do not cross across one another and no segments are vertical. Thus it is clear when one should be considered above another, or to the left of another in a chain of segments.

Note that all examples do result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but are collapsed further: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

All examples in this Bongard Problem are some points in space connected by arced line segments; these segments do not cross across one another and no segments are vertical. Thus it is clear when one should be considered above another, or to the left of another in a chain of segments.

Note that all examples do result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

All examples in this Bongard Problem are some points in space connected by arced line segments; these segments do not cross across one another and no segments are vertical. Thus it is clear when one should be considered above or to the left of another.

Note that all examples do result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is the same as the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them. (Otherwise the two entrance or exit points may vertically slide independently in the rectangle timing picture while still collapsing into the same shape.)

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

When the string hesitates, that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-and-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

If the string hesitates that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is also equivalent to the line-segment-is-adjacent-to-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

If the string hesitates that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is equivalent to the line-segment-is-adjacent-to-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

If the string hesitates that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area.

(And if either of these segments cutting across exists, it and X can be extended to eventually join up on the left. This is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is equivalent to the line-segment-is-adjacent-to-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

If the string hesitates that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area. (And since if either of these segments cutting across exists, then it and X can be extended to eventually join on the left, this is equivalent to a loop containing X separating it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is equivalent to the line-segment-is-adjacent-to-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

If the string hesitates that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area. (And since these bounding segments can be extended to eventually join up on the left, this is equivalent to a loop containing X separating and it from A and B, which themselves can be extended to eventually join up on the right, forming a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is equivalent to the line-segment-is-adjacent-to-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

If the string hesitates that means it enters a line segment at a distinct time from when it exits.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area. (And since these bounding segments can be extended to eventually join up on the left, this is equivalent to a loop containing X separating and it from A and B, which themselves can be extended to eventually join up on the right, and thus form a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is equivalent to the line-segment-is-adjacent-to-loop answer. Here is roughly the reasoning (hopefully it is not too hard to convert into language about rectangles):

If the string hesitates that means it enters a line segment at a distinct time from when it exits it.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area. (And since these bounding segments can be extended to eventually join up on the left, this is equivalent to a loop containing X separating and it from A and B, which themselves can be extended to eventually join up on the right, and thus form a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is equivalent to the line-segment-is-adjacent-to-loop answer. Here is roughly the reasoning (hopefully it shouldn't be too hard to convert into language about rectangles):

If the string hesitates that means it enters a line segment at a distinct time from when it exits it.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there is a white region shared above X and A and a white region shared below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area. (And since these bounding segments can be extended to eventually join up on the left, this is equivalent to a loop containing X separating and it from A and B, which themselves can be extended to eventually join up on the right, and thus form a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The string-sweeping answer is equivalent to the line-segment-is-adjacent-to-loop answer. Here is roughly the reasoning (hopefully it shouldn't be too hard to convert into language about rectangles):

If the string hesitates that means it enters a line segment at a distinct time from when it exits it.

The string is forced to enter/exit a line segment at the same time as another line segment just in case the two line segments have a shared region above/below them.

Suppose a line segment X must be entered at the same time as line segment A and exited at the same time as line segment B; that is, there are white regions shared above X and A and below X and B. Without loss of generality one can equivalently assume A and B are adjacent to X (since some line segment along the shared white region must be adjacent to X in each case).

Now suppose A is above B. Note this means A and B are on the same side of X (say, on the right). So, there are white regions shared above X and A and below X and B, and A and B, distinct segments, are both adjacent to X on the same side. Equivalently, there are no segments above and below X, joining at its (right) end, cutting across that area. (And since these bounding segments can be extended to eventually join up on the left, this is equivalent to a loop containing X separating and it from A and B, which themselves can be extended to eventually join up on the right, and thus form a loop.)

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and it is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.

The rectangle-based description was noted by Sridhar Ramesh when he solved this.

Note that all examples shown in this Bongard Problem result from collapsing a subdivided rectangle (such that all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are examples that would fit left, but further collapsed: some 2D regions have been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some loop is adjacent to a flat line segment, and the line segment is not separated from the loop by a taller loop containing it."

And this was the original, more vague description:

"Start with a string along the top path. Sweep it down, region-by-region, until it lies along the bottom path. Only in left images can this be done so that no segment of the string ever hesitates."

Here are some subtleties to this string sweeping rule. Each point on the string can only move vertically. The string may only enter a region when the string fully covers that region's top edge and likewise it must exit by fully covering the bottom edge. Thus a portion of string cannot enter a region until the string is finished sweeping down the regions directly above.

It seems quite convoluted spelled out in detail, at least like this. (Although it is not terribly complicated imagined visually. See the keyword "unwordable" left-BP506.)

The string-sweeping answer is equivalent to the rectangle answer because a rectangle indexes the animation of a string through an interval of time. (A horizontal cross-section of the rectangle represents the string, and the vertical position is time.) Distorting the rectangle into a new shape is the same as animating a string sweeping across that new shape.

In particular, shrinking vertical lines of a rectangle into points means just those points of the string can stay still as the string sweeps down.