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 they 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, for two chains of segments that only join up at a leftmost point and rightmost point, which is above the other.

Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some junction point has a single line coming out from one side."

Here is another answer:

"Right examples: some line segment is horizontally adjacent to a loop, and the line segment is not separated from that loop by a loop containing the segment." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.

The string-sweeping answer is also the same as 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 segments' entrances/exits may vertically slide independently in the potential rectangle timing picture.)

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). To recap, 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 they 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, for two chains of segments that only join up at a leftmost point and rightmost point, which is above the other.

Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also been collapsed down into horizontal line segments.

Here is another answer:

"Right examples: some junction point has a single line coming out from one side."

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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.

The string-sweeping answer is also the same as 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 segments' entrances/exits may vertically slide independently in the potential rectangle timing picture.)

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). To recap, 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 they 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, for two chains of segments that only join up at a leftmost point and rightmost point, which is above the other.

Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.

The string-sweeping answer is also the same as 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 segments' entrances/exits may vertically slide independently in the potential rectangle timing picture.)

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). To recap, 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 they 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, for two chains of segments that only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.

The string-sweeping answer is also the same as 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 segments' entrances/exits may vertically slide independently in the potential rectangle timing picture.)

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). To recap, 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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.

The string-sweeping answer is also the same as 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 segments' entrances/exits may vertically slide independently in the potential rectangle timing picture.)

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). To recap, 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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.

The string-sweeping answer is also the same as 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 segments' entrances/exits may vertically slide independently in the potential rectangle timing picture.)

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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.

The string-sweeping answer is also the same as 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 potential rectangle timing picture.)

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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.

The string-sweeping answer is also the same as 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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.

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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

(Note that regions in the rectangle being turned into regions in the final shape corresponds to the idea that the string must enter or exit a single region all at once. The string may enter an arc-segment, hesitate there, and then exit just in case a 2D region of the rectangle has been collapsed down into that arc-segment.)

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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

(Note that horizontal lines in the rectangle being turned into arc-segments in the final shape corresponds to the idea that the string must enter or exit a single arc-segment all at once. The exit happens delayed in time after the entrance just in case a 2D region of the rectangle has been collapsed down into that arc-segment.)

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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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.

(Note that horizontal lines in the rectangle getting turned into arc-segments in the final shape corresponds to that the string must enter or exit an arc-segment all at once. The exit happens delayed in time after the entrance just in case a 2D region of the rectangle has been collapsed down into that arc-segment.)

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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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 loop containing it." (A loop means two chains of segments with the same left ending point and right ending point.)

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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like examples that would fit left, but are collapsed further: some 2D regions have also 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." (A loop means two chains of segments with the same left ending point and right ending point.)

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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from the single leftmost point to the single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like 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." (A loop means two chains of segments with the same left ending point and right ending point.)

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 they 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 two chains of segments only join up at a leftmost point and rightmost point, which is above the other. Furthermore, in these examples, every segment is part of a chain reaching from a single leftmost point to a single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like 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." (A loop means two chains of segments with the same left ending point and right ending point.)

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 they 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. Furthermore, in these examples, every segment is part of a chain reaching from a single leftmost point to a single rightmost point. So, it should be clear which chain of segments is the top chain and which chain of segments is the bottom chain.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like 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." (A loop means two chains of segments with the same left ending point and right ending point.)

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 they 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.

Any example like this can be obtained by collapsing a subdivided rectangle so that all vertical lines are shrunken to points; examples shown on the right of this Bongard Problem are like 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." (A loop means two chains of segments with the same left ending point and right ending point.)

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 they 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.

Any example like this results from a way of collapsing a subdivided rectangle (where all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are like 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." (A loop means two chains of segments with the same left ending point and right ending point.)

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 they 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.

Any example like this results from a way of collapsing a subdivided rectangle (where all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are like 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." (A loop means two chains of segments the same left ending point and right ending point.)

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 they 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.

Any example like this results from a way of collapsing a subdivided rectangle (where all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are like 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." (A loop means two chains of segments with left ends and right ends glued.)

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 they 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.

Any example like this results from a way of collapsing a subdivided rectangle (where all vertical lines are shrunken to points). Examples shown on the right of this Bongard Problem are like 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 they 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.

All examples 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 they 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 they 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.)