unique_id stringlengths 24 24 | difficulty stringclasses 3
values | nl_description stringlengths 177 973 | pygeox_code stringlengths 322 1.43k | Objs unknown | Rels listlengths 1 6 | Points listlengths 3 15 | extra_rel listlengths 0 3 | possible_solution dict |
|---|---|---|---|---|---|---|---|---|
1obj_2rel_2extra_gen7002 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a major arc with center A, start point B, and end point C. There are line segments AD and BE. The extensions of line AD and line BE intersect at point F. Point F lies on the major arc. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
semicircle1 = scene.add.major_arc(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
### relationships
scene.relate.line_extensions_intersect_at(line_A... | {
"semicircle1": "major_arc(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)"
} | [
"line_extensions_intersect_at(line_AD, line_BE, F)",
"point_lies_on(F, semicircle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-1.6036734519,
0.4007516202
],
"B": [
-1.3500417643,
0.0210561529
],
"C": [
-1.1485432406,
0.4375508134
],
"D": [
1.6262519937,
0.19090622670000001
],
"E": [
2.1242517684,
-1.9838102418
],
"F":... |
1obj_2rel_2extra_gen7003 | easy | Diagram description: The diagram contains points A, B, C, D, E. There is a major arc BC with center A. There is a line segment BD. There is a line segment CE. Line CE is the perpendicular bisector of line BD. Point D lies on the major arc BC. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
major_arc1 = scene.add.major_arc(A, B, C)
line1 = scene.add.line_segment(B, D)
line2 = scene.add.line_segment(C, E)
### relationships
scene.relate.perpendicular_bisector_at(line1, line2)
scene.re... | {
"major_arc1": "major_arc(A, B, C)",
"line1": "line_segment(B, D)",
"line2": "line_segment(C, E)"
} | [
"perpendicular_bisector_at(line1, line2)",
"point_lies_on(D, major_arc1)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
-2.8455349282,
-1.6403584298
],
"B": [
-1.4402711114,
-2.8908774012
],
"C": [
-3.078144934,
0.2263115179
],
"D": [
-4.7202241954,
-1.7956138301
],
"E": [
-4.6224950016,
-4.3985074774
]
},
"circ... |
1obj_2rel_2extra_gen7005 | easy | Diagram description: In the diagram, quadrilateral ABCD is defined by four vertices A, B, C, and D. The diagonals AC and BD are drawn and are constrained to be perpendicular to each other. This creates an orthodiagonal quadrilateral where the diagonals intersect at right angles. The additional constraints are: The diag... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
quadrilateral1 = scene.add.quadrilateral(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
### relationships
scene.relate.perpendicular(line_AC, line_BD)
### Extr... | {
"quadrilateral1": "quadrilateral(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)"
} | [
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
10,
10
],
"B": [
10,
-10
],
"C": [
-10,
-10
],
"D": [
-10,
10
]
},
"circles": {}
} |
1obj_2rel_2extra_gen7006 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a scalene triangle ABC. There is a line segment AD. There is a line segment BE. There is a line segment CF. Line AD is an altitude of triangle ABC from vertex A. Line BE is perpendicular to line CF. Further, the length of line BE is equal to th... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
triangleABC = scene.add.scalene_triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
### relationships
sc... | {
"triangleABC": "scalene_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"is_altitude(line_AD, triangleABC, A)",
"perpendicular(line_BE, line_CF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_BE').length, scene.get_object('line_CF').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-2.4183071577,
-3.534348788
],
"B": [
-9.6047730264,
5.906477393
],
"C": [
9.6179569964,
5.6277944342
],
"D": [
-2.2829770057,
5.8003291592
],
"E": [
-5.3820219228,
-2.899043536
],
"F": [
... |
1obj_2rel_2extra_gen7007 | easy | Diagram description: The diagram contains points A, B, C, D. There is an isosceles triangle ABC with AB = BC. There is a line segment AD. There is a line segment BC. Line AD is perpendicular to line BC. Line AD is an altitude of triangle ABC from vertex A. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
triangleABC = scene.add.isosceles_triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BC = scene.add.line_segment(B, C)
### relationships
scene.relate.perpendicular(line_AD, line_BC)
scene.rela... | {
"triangleABC": "isosceles_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)"
} | [
"perpendicular(line_AD, line_BC)",
"is_altitude(line_AD, triangleABC, A)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
-7.5871731788,
-8.7411979985
],
"B": [
8.585852622400001,
-2.4570574130000002
],
"C": [
-3.8869115546,
9.6047558632
],
"D": [
3.3688273952,
2.5880779863
]
},
"circles": {}
} |
1obj_2rel_2extra_gen7008 | easy | Diagram description: The diagram contains points A, B, C, D. There is a square ABCD. There is a line segment AC. There is a line segment BD. Right angle at B between BA and BC. Line AC is perpendicular to line BD. Further, length of line AC is equal to length of line BD and the area of the square is less than or equal ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
square1 = scene.add.square(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
### relationships
scene.relate.right_angle(A, B, C)
scene.relate.perpendicular(line_AC... | {
"square1": "square(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)"
} | [
"right_angle(A, B, C)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.leq(scene.get_object('square1').area, 16)"
] | {
"points": {
"A": [
2.5534582343,
-1.7947842359
],
"B": [
3.7086530642,
-1.114543752
],
"C": [
3.0284125755,
0.0406510722
],
"D": [
1.8732177524,
-0.6395894104000001
]
},
"circles": {}
} |
1obj_2rel_2extra_gen7009 | easy | Diagram description: In the diagram, rectangle ABCD is defined with right angles at each vertex. The diagonals AC and BD are perpendicular to each other. Line segment AB is adjacent to line segment BC, forming a right angle at vertex B. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
rectangle1 = scene.add.rectangle(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_AB = scene.add.line_segment(A, B)
line_BC = scene.add.line_segment(B, C)
###... | {
"rectangle1": "rectangle(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AB": "line_segment(A, B)",
"line_BC": "line_segment(B, C)"
} | [
"perpendicular(line_AC, line_BD)",
"right_angle(A, B, C)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
10,
10
],
"B": [
10,
-10
],
"C": [
-10,
-10
],
"D": [
-10,
10
]
},
"circles": {}
} |
1obj_2rel_2extra_gen7011 | easy | Diagram description: The diagram contains points A, B, C, D. There is a quadrilateral ABCD. There is a line segment AC. There is a line segment BD. Points A, C, and D are collinear. Line AC is perpendicular to line BD. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
quadrilateral1 = scene.add.quadrilateral(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
### relationships
scene.relate.collinear(A, C, D)
scene.relate.perpendic... | {
"quadrilateral1": "quadrilateral(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)"
} | [
"collinear(A, C, D)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
1.593226368,
-0.014472669700000001
],
"B": [
3.117506034,
-1.9124479725999999
],
"C": [
2.6629701364000002,
-1.9357953194
],
"D": [
2.7606084667,
-2.1111594934
]
},
"circles": {}
} |
1obj_2rel_2extra_gen7012 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a kite ABCD. There is a line segment AC. There is a line segment BD. There is a line segment EF. The extensions of line AC and line BD intersect at point G. Line AC is perpendicular to line BD. Further, the length of line AC is equal to the ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
kite1 = scene.add.kite(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### relationships
scene.rel... | {
"kite1": "kite(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"line_extensions_intersect_at(line_AC, line_BD, G)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
1.6802167833000001,
-2.2835401395
],
"B": [
-3.5460563887000003,
-3.6812181766
],
"C": [
-4.9437344308,
1.5450550091
],
"D": [
0.2825388038,
2.9427331034
],
"E": [
9.1350891268,
-8.6624407428
],
... |
1obj_2rel_2extra_gen7015 | easy | Diagram description: The diagram contains points A, B, C, D. There is a circle with center A. There is a line segment BD. There is a line segment AC. Line BD intersects the circle at points B and D. Line BD is perpendicular to line AC. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
circle1 = scene.add.circle(A)
line_BD = scene.add.line_segment(B, D)
line_AC = scene.add.line_segment(A, C)
### relationships
scene.relate.line_intersects_circle_at(line_BD, circle1, B, D)
scene.relate.p... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)"
} | [
"line_intersects_circle_at(line_BD, circle1, B, D)",
"perpendicular(line_BD, line_AC)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
5.0275586928,
-0.7093078437
],
"B": [
0.4441819484,
-1.0813375365
],
"C": [
3.2655211022,
-0.7795127529
],
"D": [
0.4291122106,
-0.7031097352
]
},
"circles": {
"A": 4.5984506598
}
} |
1obj_2rel_2extra_gen7018 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a triangle with vertices A, B, C. There is a line segment AD. There is a line segment BE. There is a line segment CF. Line AD is a median of triangle ABC from vertex A. Line BE is a median of triangle ABC from vertex B. Further, length of line ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
triangleABC = scene.add.triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
### relationships
scene.rela... | {
"triangleABC": "triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"is_median(line_AD, triangleABC, A)",
"is_median(line_BE, triangleABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_BE').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 60)"
] | {
"points": {
"A": [
-9.3003693864,
-4.8179452963
],
"B": [
-3.760937487,
5.963563956
],
"C": [
2.8064073414,
-4.2244792225
],
"D": [
-0.4772650941,
0.8695423808
],
"E": [
-3.2469809812,
-4.5212123
],
"F": [
... |
1obj_2rel_2extra_gen7020 | easy | Diagram description: The diagram contains points A, B, C, D. There is a circle with center A. There are line segments BD and AC. Point B lies on the circle. Line BD is a diameter of the circle. Line BD is perpendicular to line AC. Further, the length of line AC is half the length of line BD, and angle BAC is a right an... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
circle1 = scene.add.circle(A)
line_BD = scene.add.line_segment(B, D)
line_AC = scene.add.line_segment(A, C)
### relationships
scene.relate.point_lies_on(B, circle1)
scene.relate.is_diameter(line_BD, circ... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)"
} | [
"point_lies_on(B, circle1)",
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)"
] | [
"A",
"B",
"C",
"D"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length / 2)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-0.1375820837,
0.7910997338
],
"B": [
-3.4470529441,
-0.9136818572000001
],
"C": [
-1.8423636387000002,
4.1005705291
],
"D": [
3.171888794,
2.495881303
]
},
"circles": {
"A": 3.722751354
}
} |
1obj_2rel_2extra_gen7024 | easy | Diagram description: In the diagram, parallelogram ABCD is defined by four vertices. The diagonals AC and BD of the parallelogram are drawn. A line segment EF is constructed such that it is parallel to diagonal AC and perpendicular to diagonal BD. This configuration creates interesting geometric relationships between t... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
parallelogram1 = scene.add.parallelogram(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### relationships
... | {
"parallelogram1": "parallelogram(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"parallel(line_AC, line_EF)",
"perpendicular(line_BD, line_EF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
9.4316287385,
-9.7098465954
],
"B": [
9.5916871784,
9.3473454306
],
"C": [
-9.4646790023,
9.586290167
],
"D": [
-9.6247374424,
-9.4709018585
],
"E": [
9.4745108876,
-9.4530430901
],
"F": [
... |
1obj_2rel_2extra_gen7026 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a quadrilateral ABCD. There is a line segment AC. There is a line segment BD. There is a line segment EF. Point G is the centroid of quadrilateral ABCD. Line AC is perpendicular to line BD. Further, the length of line AC is equal to the leng... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
quadrilateral1 = scene.add.quadrilateral(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### relati... | {
"quadrilateral1": "quadrilateral(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"is_centroid(G, quadrilateral1)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('G'), scene.get_object('B')), 90)"
] | {
"points": {
"A": [
1.1254882563,
6.1327934175
],
"B": [
-0.6378445031000001,
-1.0790112737
],
"C": [
-8.1938323153,
1.2965554415
],
"D": [
-5.4740825102,
8.2403093704
],
"E": [
-5.3074892619,
-3.1937305419
],
"F"... |
1obj_2rel_2extra_gen7027 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a major arc with center A, start point B, and end point C. There is a line segment DE. There is a line segment CF. Points B, A, and C are collinear. Line DE intersects line CF at point G. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
major_arc1 = scene.add.major_arc(A, B, C)
line_DE = scene.add.line_segment(D, E)
line_CF = scene.add.line_segment(C, F)
### relationships
scene.relate.collinear(B, A, C)
scene.rel... | {
"major_arc1": "major_arc(A, B, C)",
"line_DE": "line_segment(D, E)",
"line_CF": "line_segment(C, F)"
} | [
"collinear(B, A, C)",
"lines_intersect_at(line_DE, line_CF, G)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-0.7606230996000001,
0.8216623777000001
],
"B": [
-0.1053720377,
2.1131189643
],
"C": [
-1.4158741679,
-0.46979420050000004
],
"D": [
-3.6104485404,
0.08605196870000001
],
"E": [
-0.3312980377,
0.53084... |
1obj_2rel_2extra_gen7028 | easy | Diagram description: The diagram contains points A, B, C, D. There is a circle with center A. There is a line segment BD. There is a line segment AC. Line BD intersects the circle at points B and D. Line BD is perpendicular to line AC. Further, the length of line AC is equal to two times the diameter of the circle and ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
circle1 = scene.add.circle(A)
line_BD = scene.add.line_segment(B, D)
line_AC = scene.add.line_segment(A, C)
### relationships
scene.relate.line_intersects_circle_at(line_BD, circle1, B, D)
scene.relate.p... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)"
} | [
"line_intersects_circle_at(line_BD, circle1, B, D)",
"perpendicular(line_BD, line_AC)"
] | [
"A",
"B",
"C",
"D"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, 2 * scene.get_object('circle1').diameter)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
0.9867517913,
3.9993086077
],
"B": [
3.0895953072,
3.3948285882
],
"C": [
0.7484542427,
-4.7494493588
],
"D": [
-1.1458789949,
3.5101939218
]
},
"circles": {
"A": 2.188000702
}
} |
1obj_2rel_2extra_gen7030 | easy | Diagram description: The diagram contains points A, B, C, D. There is a circle with center A. There are line segments BC and AD. B, A, and D are collinear. AD is a radius of the circle. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
circle1 = scene.add.circle(A)
line1 = scene.add.line_segment(B, C)
line2 = scene.add.line_segment(A, D)
### relationships
scene.relate.collinear(B, A, D)
scene.relate.is_radius(line2, circle1)
scene.sol... | {
"circle1": "circle(A)",
"line1": "line_segment(B, C)",
"line2": "line_segment(A, D)"
} | [
"collinear(B, A, D)",
"is_radius(line2, circle1)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
1.0076427021,
-1.0218763408
],
"B": [
1.7861636122000002,
-0.3794811335
],
"C": [
9.636009529,
6.9596683296
],
"D": [
0.3213010253,
-1.5882100101
]
},
"circles": {
"A": 0.8898307265000001
}
} |
1obj_2rel_2extra_gen7031 | easy | Diagram description: In the diagram, kite ABCD is constructed with AB = BC and CD = DA. The diagonals AC and BD intersect at point B, where B lies on diagonal AC. The diagonals are perpendicular to each other, with AC being vertical and BD horizontal. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
kite1 = scene.add.kite(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
### relationships
scene.relate.point_lies_on(B, line_AC)
scene.relate.perpendicular(line_A... | {
"kite1": "kite(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)"
} | [
"point_lies_on(B, line_AC)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
1.0554726212,
1.6758377408
],
"B": [
0.39631770590000004,
2.4113754413
],
"C": [
-0.2628372023,
3.1469131411
],
"D": [
-1.8895101805999999,
0.3629220757
]
},
"circles": {}
} |
1obj_2rel_2extra_gen7032 | easy | Diagram description: The diagram contains points A, B, C, D, E. There is a circle with center A. There are line segments BC and DE. Line BC extension intersects the circle at points B and C. Line BC is perpendicular to line DE. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
circle1 = scene.add.circle(A)
line1 = scene.add.line_segment(B, C)
line2 = scene.add.line_segment(D, E)
### relationships
scene.relate.line_extension_intersects_circle_at(line1, circle1, B, C)
sc... | {
"circle1": "circle(A)",
"line1": "line_segment(B, C)",
"line2": "line_segment(D, E)"
} | [
"line_extension_intersects_circle_at(line1, circle1, B, C)",
"perpendicular(line1, line2)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
-0.3271210865,
1.960002094
],
"B": [
-3.4161724285,
-1.9860389508
],
"C": [
2.3957181325,
-2.2470900972
],
"D": [
1.8566908222,
0.10691282240000001
],
"E": [
1.9603062519,
2.4137463753
]
},
"ci... |
1obj_2rel_2extra_gen7033 | easy | Diagram description: The diagram contains points A, B, C, D. There is a circle with center A. There are line segments BC and AD. Line BC intersects line AD at A. Line AD is a radius of the circle. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
circle1 = scene.add.circle(A)
line1 = scene.add.line_segment(B, C)
line2 = scene.add.line_segment(A, D)
### relationships
scene.relate.lines_intersect_at(line1, line2, A)
scene.relate.is_radius(line2, ci... | {
"circle1": "circle(A)",
"line1": "line_segment(B, C)",
"line2": "line_segment(A, D)"
} | [
"lines_intersect_at(line1, line2, A)",
"is_radius(line2, circle1)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
0.6541869495,
-3.0531568141
],
"B": [
1.6572742847000002,
-1.3563304164
],
"C": [
-0.8579067497,
-5.6110203315
],
"D": [
-5.2662315183,
5.0059154132
]
},
"circles": {
"A": 10
}
} |
1obj_2rel_2extra_gen7036 | easy | Diagram description: The diagram contains points A, B, C. There is a major arc with center A and endpoints B and C. There is a line segment AB. There is a line segment AC. The angle between line segment AB and line segment AC at A is a right angle. Point B lies on the major arc. Further, the central angle of the major ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C = scene.add.points(["A", "B", "C"])
major_arc1 = scene.add.major_arc(A, B, C)
line_AB = scene.add.line_segment(A, B)
line_AC = scene.add.line_segment(A, C)
### relationships
scene.relate.right_angle(B, A, C)
scene.relate.point_lies_on(B, major_arc... | {
"major_arc1": "major_arc(A, B, C)",
"line_AB": "line_segment(A, B)",
"line_AC": "line_segment(A, C)"
} | [
"right_angle(B, A, C)",
"point_lies_on(B, major_arc1)"
] | [
"A",
"B",
"C"
] | [
"scene.constraint.eq(scene.get_object('major_arc1').central_angle, 2 * scene.get_object('major_arc1').inscribed_angle)",
"scene.constraint.leq(scene.get_object('line_AB').length, scene.get_object('major_arc1').radius)"
] | {
"points": {
"A": [
10,
10
],
"B": [
10,
-10
],
"C": [
-10,
10
]
},
"circles": {}
} |
1obj_2rel_2extra_gen7038 | easy | Diagram description: In the diagram, rectangle ABCD has right angles at each vertex. The diagonals AC and BD are perpendicular to each other. The rectangle is defined by its four vertices A, B, C, and D, with AB parallel to DC and AD parallel to BC. The additional constraints are: The diagonals of the rectangle are equ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
rectangle1 = scene.add.rectangle(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
### relationships
scene.relate.right_angle(A, B, C)
scene.relate.perpendicular(l... | {
"rectangle1": "rectangle(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)"
} | [
"right_angle(A, B, C)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
10,
10
],
"B": [
-10,
10
],
"C": [
-10,
-10
],
"D": [
10,
-10
]
},
"circles": {}
} |
1obj_2rel_2extra_gen7039 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G.
There is a circle with center A.
There is a line segment BC.
There is a line segment DE.
Line BC is parallel to line DE.
Line BC intersects the circle at points F and G. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
circle1 = scene.add.circle(A)
line1 = scene.add.line_segment(B, C)
line2 = scene.add.line_segment(D, E)
### relationships
scene.relate.parallel(line1, line2)
scene.relate.line_int... | {
"circle1": "circle(A)",
"line1": "line_segment(B, C)",
"line2": "line_segment(D, E)"
} | [
"parallel(line1, line2)",
"line_intersects_circle_at(line1, circle1, F, G)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-1.1181061079,
0.4146413286
],
"B": [
-1.5215186122,
1.1664287808
],
"C": [
-0.4915942218,
0.5257471387
],
"D": [
-1.5293107521,
2.2990292711
],
"E": [
1.5362982191999999,
0.3920160901
],
"F": ... |
1obj_2rel_2extra_gen7042 | easy | Diagram description: The diagram contains points A, B, C, D. There is a rectangle with points A, B, C, D. There is a line segment AC. There is a line segment BD. The angle ABC is a right angle. Line AC is perpendicular to line BD. Further, the length of line AC is equal to the length of line BD. Further, the angle at v... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
rectangle1 = scene.add.rectangle(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
### relationships
scene.relate.right_angle(A, B, C)
scene.relate.perpendicular(l... | {
"rectangle1": "rectangle(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)"
} | [
"right_angle(A, B, C)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-10,
10
],
"B": [
-10,
-10
],
"C": [
10,
-10
],
"D": [
10,
10
]
},
"circles": {}
} |
1obj_2rel_2extra_gen7044 | easy | Diagram description: In the diagram, rectangle ABCD has diagonals AC and BD. Point E is the midpoint of diagonal AC. The diagonals of the rectangle are perpendicular to each other. The additional constraints are: The diagonals of the rectangle have equal length, and angle AEB is a right angle. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
rectangle1 = scene.add.rectangle(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
### relationships
scene.relate.is_midpoint(E, line_AC)
scene.relate.perp... | {
"rectangle1": "rectangle(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)"
} | [
"is_midpoint(E, line_AC)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('E'), scene.get_object('B')), 90)"
] | {
"points": {
"A": [
-1.4670236649000001,
-2.2308096575
],
"B": [
-0.8961831595,
-1.4098413074
],
"C": [
-0.0752148188,
-1.9806818029
],
"D": [
-0.6460553053,
-2.8016501531999998
],
"E": [
-0.7711192295,
-2.1057457263
... |
1obj_2rel_2extra_gen7045 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a square with A, B, C, D. There is a line segment AC. There is a line segment BD. There is a line segment EF. Line AC is parallel to line EF. Line BD is the perpendicular bisector of line AC. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
square1 = scene.add.square(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### relationships
scene.relate.... | {
"square1": "square(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"parallel(line_AC, line_EF)",
"perpendicular_bisector_at(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.0762763452,
0.8779559836
],
"B": [
-2.3017591376,
1.7119141684999999
],
"C": [
-3.1357173226,
-0.5135686288
],
"D": [
-0.9102345380000001,
-1.3475268168
],
"E": [
-0.4822176992,
-3.4566568888
],... |
1obj_2rel_2extra_gen7049 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a rectangle with points A, B, C, D. There is a line segment AC. There is a line segment BD. There is a line segment EF. Angle BAD is acute. Line AC is perpendicular to line BD. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
rectangle1 = scene.add.rectangle(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### relationships
scene.r... | {
"rectangle1": "rectangle(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"acute_angle(B, A, D)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-1.3259785866,
0.8138843696
],
"B": [
-1.2590516001,
1.0337448833
],
"C": [
-1.4788847877,
1.1006860392
],
"D": [
-1.5458259557,
0.8808528088
],
"E": [
0.1355594795,
6.8167395729999996
],
"F": ... |
1obj_2rel_2extra_gen7050 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a triangle with vertices A, B, C. There is a line segment AD. There is a line segment BE. There is a line segment CF. Line AD is an altitude of triangle ABC from vertex A. Angle BAC is a right angle. Further, the inradius of triangle ABC is 1.0... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
triangleABC = scene.add.triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
### relationships
scene.rela... | {
"triangleABC": "triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"is_altitude(line_AD, triangleABC, A)",
"right_angle(B, A, C)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('triangleABC').inradius, 1.0)",
"scene.constraint.leq(scene.get_object('line_AD').length, scene.get_object('line_BE').length)"
] | {
"points": {
"A": [
-0.7564786461,
1.9488999587
],
"B": [
3.400393066,
-0.7066156698
],
"C": [
-2.2003206764,
-0.3112509403
],
"D": [
-0.9223950430000001,
-0.4014620815
],
"E": [
-9.4643706236,
-4.3025189859
],
"F... |
1obj_3rel_3extra_gen7001 | easy | Diagram description: In the diagram, two squares ABCD and EFGH are constructed such that they are similar to each other. The diagonals AC and BD of square ABCD are perpendicular to each other, as are the diagonals EG and FH of square EFGH. Both squares have their respective diagonals intersecting at right angles, maint... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
square1 = scene.add.square(A, B, C, D)
square2 = scene.add.square(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EG = scene.a... | {
"square1": "square(A, B, C, D)",
"square2": "square(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EG": "line_segment(E, G)",
"line_FH": "line_segment(F, H)"
} | [
"similar(square1, square2)",
"perpendicular(line_AC, line_BD)",
"perpendicular(line_EG, line_FH)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
1.0746878362,
-1.0394280651
],
"B": [
1.2455013386,
0.762620097
],
"C": [
-0.5565468256,
0.9334337067
],
"D": [
-0.7273603569,
-0.8686144874
],
"E": [
-3.4541128389,
-0.9078109838
],
"F": [
... |
1obj_3rel_3extra_gen7004 | easy | Diagram description: In the diagram, kite ABCD is constructed with AB = BC and CD = DA. The diagonals AC and BD are perpendicular to each other, with BD parallel to line segment EF. Angle ABD is acute. The additional constraints are: The area of kite ABCD is 24 square units, the length of diagonal AC is less than or eq... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
kite1 = scene.add.kite(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line EF = scene.add.line_segment(E, F)
### relationships
scene.relate.perp... | {
"kite1": "kite(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line EF": "line_segment(E, F)"
} | [
"perpendicular(line_AC, line_BD)",
"parallel(line_BD, line EF)",
"acute_angle(A, B, D)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('kite1').area, 24.0)",
"scene.constraint.leq(scene.get_object('line_AC').length, 2 * scene.get_object('line_BD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('D')), 60)"
] | {
"points": {
"A": [
-1.0827776076,
7.0343881407
],
"B": [
1.0042092585,
3.9327605113
],
"C": [
-0.638385624,
0.5745630364000001
],
"D": [
-6.3913330309,
3.423997559
],
"E": [
-1.0465025119,
2.3184817756
],
"F": [
... |
1obj_3rel_3extra_gen7010 | easy | Diagram description: The diagram contains points A, B, C, D, G. There is an isosceles trapezoid ABCD. There is a line segment AC. There is a line segment BD. Line AC bisects angle DAB. Line AC is perpendicular to line BD. Line AC intersects line BD at point G. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, G = scene.add.points(["A", "B", "C", "D", "G"])
trapezoid_ABCD = scene.add.isosceles_trapezoid(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
### relationships
scene.relate.angle_bisector(D, A, B, lin... | {
"trapezoid_ABCD": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)"
} | [
"angle_bisector(D, A, B, line_AC)",
"perpendicular(line_AC, line_BD)",
"lines_intersect_at(line_AC, line_BD, G)"
] | [
"A",
"B",
"C",
"D",
"G"
] | [] | {
"points": {
"A": [
2.6759040742,
2.477968115
],
"B": [
2.3033104529,
-1.0311901557
],
"C": [
-1.1956083909,
-1.4900858098
],
"D": [
-0.8230147304000001,
2.0190725216
],
"G": [
0.7401478753,
0.49394118670000003
]
},... |
1obj_3rel_3extra_gen7013 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a triangle ABC. There is a line segment AD. There is a line segment BE. There is a line segment CF. There is a line segment GH. The extensions of line AD and line BE intersect at point F. Line AD is an altitude of triangle ABC from vertex... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
triangleABC = scene.add.triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
line_GH = scen... | {
"triangleABC": "triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)",
"line_GH": "line_segment(G, H)"
} | [
"line_extensions_intersect_at(line_AD, line_BE, F)",
"is_altitude(line_AD, triangleABC, A)",
"is_altitude(line_BE, triangleABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
-0.37270477700000004,
0.3417189296
],
"B": [
-2.1181044875,
0.2900825125
],
"C": [
4.517717412,
8.7058968392
],
"D": [
-1.423861176,
1.170549654
],
"E": [
-0.8398707423,
-0.4572834438
],
"F": [... |
1obj_3rel_3extra_gen7014 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a square with vertices A, B, C, D. There are line segments AC, BD, and EF. Point E lies on line AC. Point F lies on line BD. Line AC is perpendicular to line BD. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
square1 = scene.add.square(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### relationships
scene.relate.... | {
"square1": "square(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"point_lies_on(E, line_AC)",
"point_lies_on(F, line_BD)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
1.4582459103,
-0.639830593
],
"B": [
0.3267820227,
-0.8053541601
],
"C": [
0.4923055837,
-1.9368180153
],
"D": [
1.6237694432,
-1.7712944469
],
"E": [
1.3328873816,
-0.8081520767
],
"F": [
... |
1obj_3rel_3extra_gen7016 | easy | Diagram description: In the diagram, square ABCD has diagonals AC and BD that intersect at point G. The diagonals are perpendicular to each other. Point E lies on diagonal AC, and line segment EF is drawn such that E is constrained to lie on AC. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
square1 = scene.add.square(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### relationships
scene... | {
"square1": "square(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"lines_intersect_at(line_AC, line_BD, G)",
"perpendicular(line_AC, line_BD)",
"point_lies_on(E, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-0.8323475717000001,
-1.3544255984
],
"B": [
-0.5347746478000001,
-0.7409698642
],
"C": [
0.0786813288,
-1.0385428971
],
"D": [
-0.2188917842,
-1.6519989217000002
],
"E": [
-0.5722071188,
-1.2642267185... |
1obj_3rel_3extra_gen7017 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is an isosceles trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line segment EF. Line AC intersects line BD at point G. Line AC is perpendicular to line BD. Point E lies on line AC. Further, length of line AC ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
trapezoid_ABCD = scene.add.isosceles_trapezoid(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### ... | {
"trapezoid_ABCD": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"lines_intersect_at(line_AC, line_BD, G)",
"perpendicular(line_AC, line_BD)",
"point_lies_on(E, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.leq(scene.get_object('trapezoid_ABCD').area, 20)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('G'), scene.get_object('B')), 90)"
] | {
"points": {
"A": [
-1.9140076758000002,
-2.677530473
],
"B": [
-1.4189195371,
3.0263959168
],
"C": [
1.3954795934,
0.1033283314
],
"D": [
1.361939219,
-0.28309128040000003
],
"E": [
1.0229605727,
-0.20968776400000003
... |
1obj_3rel_3extra_gen7019 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a right trapezoid ABCD. There is a line segment BE. There is a line segment DF. Line BE bisects angle ABC. Line DF is perpendicular to line BE. Point F lies on line DF. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
trapezoidABCD = scene.add.right_trapezoid(A, B, C, D)
line_angle_bisector = scene.add.line_segment(B, E)
line_perp = scene.add.line_segment(D, F)
### relationships
scene.relate.angle_bise... | {
"trapezoidABCD": "right_trapezoid(A, B, C, D)",
"line_angle_bisector": "line_segment(B, E)",
"line_perp": "line_segment(D, F)"
} | [
"angle_bisector(A, B, C, line_angle_bisector)",
"perpendicular(line_perp, line_angle_bisector)",
"point_lies_on(F, line_perp)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
0.6406566704000001,
1.2807879348
],
"B": [
-2.9703307201999998,
0.4891603914
],
"C": [
3.3447246236,
1.0947184549
],
"D": [
0.8035774979,
0.5376291812
],
"E": [
-8.6846193779,
-0.40785002880000004
... |
1obj_3rel_3extra_gen7021 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a scalene triangle ABC. There is a line segment AD. There is a line segment BE. There is a line segment CF. There is a line segment GH. Line AD is an altitude of triangle ABC from vertex A. Line BE is a median of triangle ABC from vertex ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
triangleABC = scene.add.scalene_triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
line_G... | {
"triangleABC": "scalene_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)",
"line_GH": "line_segment(G, H)"
} | [
"lines_intersect_at(line_AD, line_BE, F)",
"is_altitude(line_AD, triangleABC, A)",
"is_median(line_BE, triangleABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
5.7397989897,
-1.4998514748
],
"B": [
1.2324262588,
-0.1570521164
],
"C": [
2.2491492269,
-5.5851700763
],
"D": [
1.6281924583,
-2.2699829803
],
"E": [
3.9944740099000002,
-3.5425107453
],
"F":... |
1obj_3rel_3extra_gen7022 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There is a line segment BC. There is a line segment AD. There is a line segment EF. Line BC is perpendicular to line AD. Line BC is a chord of the circle. Point D lies on the circle. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
circle1 = scene.add.circle(A)
line1 = scene.add.line_segment(B, C)
line2 = scene.add.line_segment(A, D)
line3 = scene.add.line_segment(E, F)
### relationships
scene.relate.perpendicular(l... | {
"circle1": "circle(A)",
"line1": "line_segment(B, C)",
"line2": "line_segment(A, D)",
"line3": "line_segment(E, F)"
} | [
"perpendicular(line1, line2)",
"is_chord(line1, circle1)",
"point_lies_on(D, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
0.4847260713,
3.3320120457
],
"B": [
-2.5352021735,
0.8850510867
],
"C": [
-2.1909796356,
0.5127597496
],
"D": [
-2.3691680901,
0.6932864750000001
],
"E": [
-6.7371369628,
5.4057868882
],
"F": ... |
1obj_3rel_3extra_gen7023 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is an isosceles trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line segment EF. Point E lies on line AC. Line AC is perpendicular to line BD. Line AC intersects line BD at point F. Further, the length of line AC... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
trapezoid1 = scene.add.isosceles_trapezoid(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### relationship... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"point_lies_on(E, line_AC)",
"perpendicular(line_AC, line_BD)",
"lines_intersect_at(line_AC, line_BD, F)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.leq(scene.get_object('trapezoid1').area, 20)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('F'), scene.get_object('B')), 90)"
] | {
"points": {
"A": [
-5.7784123472,
2.889620657
],
"B": [
2.642901758,
2.5848006956000003
],
"C": [
-1.5192100499999999,
-1.6894955820000002
],
"D": [
-1.936214472,
-1.6744015964
],
"E": [
-2.6161380953,
-0.5101759201
... |
1obj_3rel_3extra_gen7025 | easy | Diagram description: In the diagram, acute triangle ABC has an altitude from vertex A to side BC, labeled as line segment AD, where D lies on side BC. Additionally, a median from vertex B to the midpoint of side AC is drawn as line segment BE, where E is the midpoint of AC. The altitude AD and median BE intersect at po... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
triangleABC = scene.add.acute_triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
### relationships
scene.relate.lines_intersect_at(line_AD, li... | {
"triangleABC": "acute_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)"
} | [
"lines_intersect_at(line_AD, line_BE, F)",
"is_altitude(line_AD, triangleABC, A)",
"is_median(line_BE, triangleABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_BE').length)",
"scene.constraint.leq(scene.get_object('triangleABC').area, 10.0)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 60)"
] | {
"points": {
"A": [
1.9638487672,
2.1471326238
],
"B": [
-0.178083621,
-1.0438916085
],
"C": [
-1.8706262744000002,
2.4065899911
],
"D": [
-1.0243548385,
0.6813481972000001
],
"E": [
0.046612087100000005,
2.2768608831
... |
1obj_3rel_3extra_gen7029 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There is a line segment BD. There is a line segment AC. There is a line segment EF. Line BD is congruent to line AC. Line BD is perpendicular to line AC. Line BD is a chord of the circle. Further, length of line AC is eq... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
circle1 = scene.add.circle(A)
line_BD = scene.add.line_segment(B, D)
line_AC = scene.add.line_segment(A, C)
line_EF = scene.add.line_segment(E, F)
### relationships
scene.relate.congruent... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"congruent(line_BD, line_AC)",
"perpendicular(line_BD, line_AC)",
"is_chord(line_BD, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.leq(scene.get_object('line_AC').length, scene.get_object('circle1').diameter)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-0.4531695495,
-0.6352411522
],
"B": [
2.476266959,
-2.1562780534
],
"C": [
2.5889042494,
5.2236318504
],
"D": [
-3.382606036,
0.8857957522000001
],
"E": [
6.0947042939,
4.8988605392
],
"F": [
... |
1obj_3rel_3extra_gen7034 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a major arc with center A, start point B, and end point C. There is a line segment AD. There is a line segment BE. There is a line segment CF. Angle DAB is acute. Point D lies on the major arc. Line AD and line BE intersect at point E. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
semicircle1 = scene.add.major_arc(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
### relationships
scene.rel... | {
"semicircle1": "major_arc(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"acute_angle(D, A, B)",
"point_lies_on(D, semicircle1)",
"lines_intersect_at(line_AD, line_BE, E)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.0328103536,
-5.3984315808
],
"B": [
-1.101086375,
-4.5113861039
],
"C": [
0.9462792830000001,
-4.4138266767
],
"D": [
-0.1985742533,
-4.0198142787
],
"E": [
-0.0566984497,
-5.1997602268
],
"... |
1obj_3rel_3extra_gen7035 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a circle with center A. There is a line segment BC. There is a line segment DE. There is a line segment FG. Line BC is parallel to line DE. Line BC intersects the circle at points B and C. Line DE is perpendicular to line FG. Further, the le... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
circle1 = scene.add.circle(A)
line1 = scene.add.line_segment(B, C)
line2 = scene.add.line_segment(D, E)
line3 = scene.add.line_segment(F, G)
### relationships
scene.relate.paralle... | {
"circle1": "circle(A)",
"line1": "line_segment(B, C)",
"line2": "line_segment(D, E)",
"line3": "line_segment(F, G)"
} | [
"parallel(line1, line2)",
"line_intersects_circle_at(line1, circle1, B, C)",
"perpendicular(line2, line3)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('line1').length, scene.get_object('line2').length)",
"scene.constraint.leq(scene.get_object('line3').length, scene.get_object('circle1').diameter)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-2.9690932716000003,
-2.9640187977
],
"B": [
1.4234001555,
-2.3543697434
],
"C": [
-3.5787423248,
1.4284746288
],
"D": [
-4.6651348373,
2.2490742561
],
"E": [
0.3370076273,
-1.5337700972000001
],
... |
1obj_3rel_3extra_gen7037 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a scalene triangle ABC. There are line segments AD, BE, CF, and GH. Line AD is an altitude of triangle ABC from vertex A. Line BE is a median of triangle ABC from vertex B. The extensions of line AD and line BE intersect at point F. Furth... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
triangleABC = scene.add.scalene_triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
line_G... | {
"triangleABC": "scalene_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)",
"line_GH": "line_segment(G, H)"
} | [
"line_extensions_intersect_at(line_AD, line_BE, F)",
"is_altitude(line_AD, triangleABC, A)",
"is_median(line_BE, triangleABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_BE').length)",
"scene.constraint.leq(scene.get_object('triangleABC').area, 12.0)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 60)"
] | {
"points": {
"A": [
-2.7277344721,
-2.4527377478
],
"B": [
1.3034778728,
-1.1913543678
],
"C": [
-1.8037809233000002,
1.6684067599999999
],
"D": [
-0.2506317025,
0.238759414
],
"E": [
-2.2659010275,
-0.3921480851
],
... |
1obj_3rel_3extra_gen7040 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is an isosceles triangle ABC. There is a line segment AD. There is a line segment BE. There is a line segment CF. The angle ABC is obtuse. Line AD is an altitude of triangle ABC from vertex A. Line BE is a median of triangle ABC from vertex B. Fur... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
triangleABC = scene.add.isosceles_triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
### relationships
... | {
"triangleABC": "isosceles_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"obtuse_angle(A, B, C)",
"is_altitude(line_AD, triangleABC, A)",
"is_median(line_BE, triangleABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, 3.0)",
"scene.constraint.leq(scene.get_object('line_BE').length, scene.get_object('line_AD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 120)"
] | {
"points": {
"A": [
-0.5433492792,
-0.6040120116000001
],
"B": [
-0.154730806,
2.8382206582
],
"C": [
3.0206399659,
4.2227837756
],
"D": [
-1.7424154769,
2.1459399569
],
"E": [
1.2386455486,
1.8093865689
],
"F": [... |
1obj_3rel_3extra_gen7041 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a scalene triangle ABC. There is a line segment AD. There is a line segment BE. There is a line segment CF. There is a line segment GH. Point G is the centroid of triangle ABC. Line AD is an altitude of triangle ABC from vertex A. Line BE... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
triangleABC = scene.add.scalene_triangle(A, B, C)
lineAD = scene.add.line_segment(A, D)
lineBE = scene.add.line_segment(B, E)
lineCF = scene.add.line_segment(C, F)
lineGH = ... | {
"triangleABC": "scalene_triangle(A, B, C)",
"lineAD": "line_segment(A, D)",
"lineBE": "line_segment(B, E)",
"lineCF": "line_segment(C, F)",
"lineGH": "line_segment(G, H)"
} | [
"is_centroid(G, triangleABC)",
"is_altitude(lineAD, triangleABC, A)",
"is_median(lineBE, triangleABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
0.2812943003,
-6.0746004617
],
"B": [
-9.9963372022,
-8.4130439519
],
"C": [
3.925603019,
-0.3872172479
],
"D": [
-1.2705370049,
-3.3827278707
],
"E": [
2.1034486823,
-3.230908864
],
"F": [
... |
1obj_3rel_3extra_gen7043 | easy | Diagram description: In the diagram, kite ABCD is constructed with AB = BC and CD = DA. The diagonals AC and BD are perpendicular to each other. Point E lies on diagonal AC, and line EF is parallel to diagonal AC. This configuration creates a symmetric kite with specific alignment properties between its diagonals and a... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
kite1 = scene.add.kite(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene.add.line_segment(E, F)
### relationships
scene.relate.poin... | {
"kite1": "kite(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"point_lies_on(E, line_AC)",
"perpendicular(line_AC, line_BD)",
"parallel(line_EF, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.leq(scene.get_object('kite1').area, 12.0)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-0.9289862449,
2.1844261802
],
"B": [
2.4970315393,
2.3801839292
],
"C": [
2.692789291,
-1.0458338708
],
"D": [
-0.7332286704000001,
-1.241591762
],
"E": [
1.3462080386,
0.1551814065
],
"F": [
... |
1obj_3rel_3extra_gen7046 | easy | Diagram description: The diagram contains points A, B, C, D, E, F. There is a right isosceles triangle ABC. There is a line segment AD. There is a line segment BE. There is a line segment CF. Points A, D, and E are collinear. Line AD is perpendicular to line BE. Line CF is a median of triangle ABC from vertex C. Furthe... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
triangle_ABC = scene.add.right_isosceles_triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
### relation... | {
"triangle_ABC": "right_isosceles_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"collinear(A, D, E)",
"perpendicular(line_AD, line_BE)",
"is_median(line_CF, triangle_ABC, C)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_BE').length)",
"scene.constraint.leq(scene.get_object('line_CF').length, scene.get_object('triangle_ABC').area)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
5.4867250392,
2.1429800361
],
"B": [
0.6313982779,
2.7997787326
],
"C": [
-0.025400393,
-2.0555478201
],
"D": [
4.207172851,
1.9729047343000001
],
"E": [
0.8014736841000001,
1.5202265804000001
],
... |
1obj_3rel_3extra_gen7047 | easy | Diagram description: The diagram contains points A, B, C, D, P, Q. There is a rectangle with A, B, C, D. There is a line segment AC. There is a line segment BD. There is a line segment AP. There is a line segment QB. Line AC is perpendicular to line BD. Point P lies on line AC. Point P is the midpoint of line AC. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, P, Q = scene.add.points(["A", "B", "C", "D", "P", "Q"])
rectangle1 = scene.add.rectangle(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_AP = scene.add.line_segment(A, P)
line_QB = scene.add.line_se... | {
"rectangle1": "rectangle(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AP": "line_segment(A, P)",
"line_QB": "line_segment(Q, B)"
} | [
"perpendicular(line_AC, line_BD)",
"point_lies_on(P, line_AC)",
"is_midpoint(P, line_AC)"
] | [
"A",
"B",
"C",
"D",
"P",
"Q"
] | [] | {
"points": {
"A": [
0.046212784800000004,
2.3759324598
],
"B": [
-1.3494944616,
2.074054072
],
"C": [
-1.0476160676,
0.6783468387
],
"D": [
0.3480911599,
0.9802252239
],
"P": [
-0.5007016305,
1.5271396782000002
],
... |
1obj_3rel_3extra_gen7048 | easy | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, point_of_intersection. There is an equilateral triangle ABC. There is a line segment AD. There is a line segment BE. There is a line segment CF. There is a line segment GH. Line AD intersects line BE at point_of_intersection. Point_of_intersection... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, point_of_intersection = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "point_of_intersection"])
triangle_ABC = scene.add.equilateral_triangle(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segmen... | {
"triangle_ABC": "equilateral_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)",
"line_GH": "line_segment(G, H)"
} | [
"lines_intersect_at(line_AD, line_BE, point_of_intersection)",
"is_orthocenter(point_of_intersection, triangle_ABC)",
"parallel(line_CF, line_GH)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"point_of_intersection"
] | [] | {
"points": {
"A": [
-2.9176929045,
-0.7601012115
],
"B": [
-3.630963287,
-0.1306924529
],
"C": [
-2.7292442883,
0.17231371480000002
],
"D": [
-3.2274016694,
0.1615648799
],
"E": [
-1.5423354715,
-0.5528207537000001
],... |
2obj_3rel_1extra_gen7051 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is an isosceles trapezoid ABCD. There is a major arc FG with center E. There is a line segment AB. There is a line segment CD. There is a line segment AC. There is a line segment BD. There is a line segment EF. There is a line segment EG. Point... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
trapezoid1 = scene.add.isosceles_trapezoid(A, B, C, D)
arc1 = scene.add.major_arc(E, F, G)
line_AB = scene.add.line_segment(A, B)
line_CD = scene.add.line_segment(C, D)
line_AC = sc... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"arc1": "major_arc(E, F, G)",
"line_AB": "line_segment(A, B)",
"line_CD": "line_segment(C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)",
"line_EG": "line_segment(E, G)"
} | [
"collinear(A, B, C)",
"point_lies_on(F, arc1)",
"point_lies_on(G, arc1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
1.2147578668,
-0.3703119837
],
"B": [
1.3005156659,
-0.5536091061
],
"C": [
5.5387680135,
-9.6049474993
],
"D": [
-3.0163671891,
8.6843614713
],
"E": [
-0.7215928246000001,
-2.9171540901
],
"F"... |
2obj_3rel_1extra_gen7052 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a quadrilateral with vertices A, B, C, D. There is a rectangle with vertices E, F, G, H. There is a line segment AC. There is a line segment BD. There is a line segment EF. There is a line segment FG. Points A, C, and G are collinear. Lin... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
quadrilateral1 = scene.add.quadrilateral(A, B, C, D)
rectangle1 = scene.add.rectangle(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, ... | {
"quadrilateral1": "quadrilateral(A, B, C, D)",
"rectangle1": "rectangle(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)",
"line_FG": "line_segment(F, G)"
} | [
"collinear(A, C, G)",
"perpendicular(line_AC, line_BD)",
"parallel(line_EF, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)"
] | {
"points": {
"A": [
3.5530997227,
2.4795779373
],
"B": [
-0.9401290457,
3.4058349722
],
"C": [
1.1347186475,
0.1374375313
],
"D": [
1.4020112593,
0.9874541305000001
],
"E": [
2.4714331719000002,
1.1291963622
],
"F... |
2obj_3rel_1extra_gen7053 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, I, J. There is a regular hexagon with vertices A, B, C, D, E, F. There is a rhombus with vertices G, H, I, J. There is a line segment AC. There is a line segment GI. There is a line segment HJ. Point G is the midpoint of line AC. Line AC is parall... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I, J = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
hexagon1 = scene.add.regular_hexagon(A, B, C, D, E, F)
rhombus1 = scene.add.rhombus(G, H, I, J)
line_AC = scene.add.line_segment(A, C)
line_GI = scene.add.li... | {
"hexagon1": "regular_hexagon(A, B, C, D, E, F)",
"rhombus1": "rhombus(G, H, I, J)",
"line_AC": "line_segment(A, C)",
"line_GI": "line_segment(G, I)",
"line_HJ": "line_segment(H, J)"
} | [
"is_midpoint(G, line_AC)",
"parallel(line_AC, line_GI)",
"perpendicular(line_AC, line_HJ)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J"
] | [
"scene.constraint.eq(scene.get_object('line_HJ').length, scene.get_object('line_GI').length)",
"scene.constraint.eq(scene.get_object('rhombus1').area, 2 * scene.get_object('hexagon1').area)"
] | {
"points": {
"A": [
-2.4511935197,
-0.1283085228
],
"B": [
-3.0536591975,
0.0524089963
],
"C": [
-3.5113979989,
-0.3789828259
],
"D": [
-3.3666711225,
-0.9910921674000001
],
"E": [
-2.7642054448,
-1.1718096865
],
... |
2obj_3rel_1extra_gen7054 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, I, J, K. There is a regular hexagon with vertices A, B, C, D, E, F. There is a rectangle with vertices G, H, I, J. There is a line segment AC. There is a line segment GI. There is a line segment HJ. K is the midpoint of line AC. line AC is paralle... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I, J, K = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K"])
hexagon1 = scene.add.regular_hexagon(A, B, C, D, E, F)
rectangle1 = scene.add.rectangle(G, H, I, J)
line_AC = scene.add.line_segment(A, C)
line_GI = ... | {
"hexagon1": "regular_hexagon(A, B, C, D, E, F)",
"rectangle1": "rectangle(G, H, I, J)",
"line_AC": "line_segment(A, C)",
"line_GI": "line_segment(G, I)",
"line_HJ": "line_segment(H, J)"
} | [
"is_midpoint(K, line_AC)",
"parallel(line_AC, line_GI)",
"perpendicular(line_HJ, line_GI)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J",
"K"
] | [
"scene.constraint.eq(scene.get_object('hexagon1').side_length, scene.get_object('rectangle1').perimeter)"
] | {
"points": {
"A": [
5.3905586439,
3.2083652726
],
"B": [
4.6059768751,
2.8364296609
],
"C": [
4.5357916791,
1.9709941119
],
"D": [
5.2501882518,
1.4774941746
],
"E": [
6.0347700206,
1.8494297864
],
"F": [
6.... |
2obj_3rel_1extra_gen7055 | medium | Diagram description: The diagram contains points A, B, C, D, E, F. There is a scalene triangle ABC. There is an isosceles triangle DEF. There is a line segment AD. There is a line segment BE. There is a line segment CF. Point A lies on line segment AD. Points A, D, and F are collinear. Line segment AD is perpendicular ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
scalene_tri = scene.add.scalene_triangle(A, B, C)
isosceles_tri = scene.add.isosceles_triangle(D, E, F)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF... | {
"scalene_tri": "scalene_triangle(A, B, C)",
"isosceles_tri": "isosceles_triangle(D, E, F)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"point_lies_on(A, line_AD)",
"collinear(A, D, F)",
"perpendicular(line_AD, line_BE)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('scalene_tri').area, scene.get_object('isosceles_tri').area)",
"scene.constraint.leq(scene.get_object('line_AD').length, scene.get_object('line_BE').length)"
] | {
"points": {
"A": [
-2.7691538438,
-0.1489013512
],
"B": [
-0.2212309382,
3.6742530334
],
"C": [
-2.6773534107,
6.8346862872
],
"D": [
-1.5472447152000002,
-0.1891125561
],
"E": [
-0.1102694047,
7.0460724324
],
"F... |
2obj_3rel_1extra_gen7057 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, I. There is a quadrilateral ABCD. There is a regular pentagon EFGHI. There is a line segment AC. There is a line segment BD. There is a line segment EG. Point F is the midpoint of line segment AC. Line segment AC is perpendicular to line segment B... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I"])
quad1 = scene.add.quadrilateral(A, B, C, D)
pentagon1 = scene.add.regular_pentagon(E, F, G, H, I)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_seg... | {
"quad1": "quadrilateral(A, B, C, D)",
"pentagon1": "regular_pentagon(E, F, G, H, I)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EG": "line_segment(E, G)"
} | [
"is_midpoint(F, line_AC)",
"perpendicular(line_AC, line_BD)",
"parallel(line_EG, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_EG').length)"
] | {
"points": {
"A": [
1.5172845981,
-3.5379512544000002
],
"B": [
-3.8492234153,
1.0165311948
],
"C": [
1.0154418217,
-3.2956408933
],
"D": [
-3.2439599075,
2.2700769637000002
],
"E": [
1.1034662144,
-3.1133358187
],
... |
2obj_3rel_1extra_gen7058 | medium | Diagram description: The diagram contains points A, B, C, D, E, F. There is a minor arc with center A and endpoints B and C. There is an obtuse triangle with vertices D, E, F. There is a line segment DE. There is a line segment DF. There is a line segment EF. The point B lies on the minor arc. The line segment DE is ro... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
arc1 = scene.add.minor_arc(A, B, C)
triangle1 = scene.add.obtuse_triangle(D, E, F)
line_DE = scene.add.line_segment(D, E)
line_DF = scene.add.line_segment(D, F)
line_EF = scene.add.line_seg... | {
"arc1": "minor_arc(A, B, C)",
"triangle1": "obtuse_triangle(D, E, F)",
"line_DE": "line_segment(D, E)",
"line_DF": "line_segment(D, F)",
"line_EF": "line_segment(E, F)"
} | [
"rotation_around_point(line_DE, line_DF, D, 90)",
"point_lies_on(B, arc1)",
"obtuse_angle(E, D, F)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_DF').length, scene.get_object('line_DE').length)",
"scene.constraint.eq(scene.angle(scene.get_object('E'), scene.get_object('D'), scene.get_object('F')), 90)"
] | {
"points": {
"A": [
4.3866039144,
4.5093453411
],
"B": [
-4.3157925607,
5.0764503454
],
"C": [
-2.6379130845,
-0.6587755525
],
"D": [
9.9889938621,
9.9744134814
],
"E": [
9.9801202721,
-10
],
"F": [
-9.98541... |
2obj_3rel_1extra_gen7062 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a minor arc with center A and endpoints B and C. There is a scalene triangle DEF. There is a line segment DE. There is a line segment EF. There is a line segment FD. There is a line segment AG. There is a line segment BH. Line DE is an al... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
arc1 = scene.add.minor_arc(A, B, C)
triangle1 = scene.add.scalene_triangle(D, E, F)
line_DE = scene.add.line_segment(D, E)
line_EF = scene.add.line_segment(E, F)
line_FD = s... | {
"arc1": "minor_arc(A, B, C)",
"triangle1": "scalene_triangle(D, E, F)",
"line_DE": "line_segment(D, E)",
"line_EF": "line_segment(E, F)",
"line_FD": "line_segment(F, D)",
"line_AG": "line_segment(A, G)",
"line_BH": "line_segment(B, H)"
} | [
"is_altitude(line_DE, triangle1, D)",
"point_lies_on(G, arc1)",
"point_lies_on(H, arc1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('line_DE').length, scene.get_object('line_AG').length)",
"scene.constraint.leq(scene.get_object('line_BH').length, scene.get_object('line_FD').slope)"
] | {
"points": {
"A": [
-0.008231363,
-1.2062969578
],
"B": [
-0.0382165475,
-1.6253254498
],
"C": [
0.4078856189,
-1.2640088552
],
"D": [
-6.6194568962,
-2.1373496277
],
"E": [
-6.8329184105,
-1.7755234171
],
"F": [
... |
2obj_3rel_1extra_gen7063 | medium | Diagram description: The diagram contains points A, B, C, D, E, F. There is a minor arc BC with center A. There is a triangle DEF. There is a line segment DE. There is a line segment EF. There is a line segment FD. Points B, A, and C are collinear with A between B and C. Point D is the orthocenter of triangle DEF. Poin... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
arc1 = scene.add.minor_arc(A, B, C)
triangle1 = scene.add.triangle(D, E, F)
line_DE = scene.add.line_segment(D, E)
line_EF = scene.add.line_segment(E, F)
line_FD = scene.add.line_segment(F,... | {
"arc1": "minor_arc(A, B, C)",
"triangle1": "triangle(D, E, F)",
"line_DE": "line_segment(D, E)",
"line_EF": "line_segment(E, F)",
"line_FD": "line_segment(F, D)"
} | [
"collinear(B, A, C)",
"is_orthocenter(D, triangle1)",
"point_lies_on(E, arc1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-1.8538414996,
5.6730152521
],
"B": [
-2.3232092679,
5.5072448018
],
"C": [
-1.3844737316,
5.8387857149
],
"D": [
-0.3649344453,
5.819498334
],
"E": [
-2.1855586846,
5.3018688579
],
"F": [
... |
2obj_3rel_1extra_gen7064 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a triangle with vertices A, B, C. There is a rectangle with vertices D, E, F, G. There is a line segment AG. There is a line segment CF. There is a line segment BE. Points A, G, and C are collinear. Point B is the orthocenter of triangle ABC... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
triangle_ABC = scene.add.triangle(A, B, C)
rectangle_DEFG = scene.add.rectangle(D, E, F, G)
line_AG = scene.add.line_segment(A, G)
line_CF = scene.add.line_segment(C, F)
line_BE = s... | {
"triangle_ABC": "triangle(A, B, C)",
"rectangle_DEFG": "rectangle(D, E, F, G)",
"line_AG": "line_segment(A, G)",
"line_CF": "line_segment(C, F)",
"line_BE": "line_segment(B, E)"
} | [
"collinear(A, G, C)",
"is_orthocenter(B, triangle_ABC)",
"parallel(line_AG, line_CF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('triangle_ABC').area, scene.get_object('rectangle_DEFG').area)"
] | {
"points": {
"A": [
-1.501932236,
0.4400654868
],
"B": [
-0.3587694395,
0.3498948189
],
"C": [
-0.24017006700000001,
1.8534702264
],
"D": [
-0.3258023397,
0.9566905236000001
],
"E": [
0.7539960720000001,
2.1662625544
... |
2obj_3rel_1extra_gen7065 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, I. There is a rectangle with A, B, C, D. There is a rhombus with E, F, G, H. There is a line segment AC. There is a line segment EG. There is a line segment BF. Line AC intersects line EG at I. Line AC is parallel to line BF. Line AC is perpendicu... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I"])
rectangle1 = scene.add.rectangle(A, B, C, D)
rhombus1 = scene.add.rhombus(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_EG = scene.add.line_segment(E, G)
l... | {
"rectangle1": "rectangle(A, B, C, D)",
"rhombus1": "rhombus(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_EG": "line_segment(E, G)",
"line_BF": "line_segment(B, F)"
} | [
"lines_intersect_at(line_AC, line_EG, I)",
"parallel(line_AC, line_BF)",
"perpendicular(line_AC, line_EG)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_EG').length)",
"scene.constraint.eq(scene.get_object('rectangle1').area, scene.get_object('rhombus1').area)"
] | {
"points": {
"A": [
0.8159818958,
0.7795441505
],
"B": [
0.6293690988,
0.5570392295000001
],
"C": [
2.7728616357,
-1.2406883632
],
"D": [
2.9594742742,
-1.018183699
],
"E": [
1.4036023037,
-2.2635181817
],
"F": [
... |
2obj_3rel_1extra_gen7070 | medium | Diagram description: The diagram contains points A, B, C, D, E. There is a right trapezoid ABCD. There is a circle with center E. There is a line segment AB. There is a line segment CD. There is a line segment AD. There is a line segment BC. There is a line segment AC. There is a line segment EC. The angle BAD is acute... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
trapezoid1 = scene.add.right_trapezoid(A, B, C, D)
circle1 = scene.add.circle(E)
line_AB = scene.add.line_segment(A, B)
line_CD = scene.add.line_segment(C, D)
line_AD = scene.add.line_segment(A, D)... | {
"trapezoid1": "right_trapezoid(A, B, C, D)",
"circle1": "circle(E)",
"line_AB": "line_segment(A, B)",
"line_CD": "line_segment(C, D)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)",
"line_AC": "line_segment(A, C)",
"line_EC": "line_segment(E, C)"
} | [
"acute_angle(B, A, D)",
"perpendicular(line_AB, line_AD)",
"is_chord(line_AC, circle1)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AB').length, scene.get_object('line_AD').length)",
"scene.constraint.leq(scene.get_object('line_AC').length, scene.get_object('circle1').diameter)"
] | {
"points": {
"A": [
1.6270014656,
0.7435593558
],
"B": [
-1.0354530363,
2.6165113556
],
"C": [
-0.0218082494,
-2.0765744844
],
"D": [
-0.245992216,
-1.9188655847
],
"E": [
-0.9874279283,
0.3800419337
]
},
"circles... |
2obj_3rel_1extra_gen7072 | medium | Diagram description: In the diagram, a semicircle is defined by points A, B, and C, with B being the center and A and C as endpoints on the circumference. A rectangle DEFG is constructed such that its diagonal DF is perpendicular to the line AG connecting A and G. The point B lies on the semicircle, and the line BE ser... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
semicircle1 = scene.add.major_arc(A, B, C)
rectangle1 = scene.add.rectangle(D, E, F, G)
line_DF = scene.add.line_segment(D, F)
line_AG = scene.add.line_segment(A, G)
line_BE = scene... | {
"semicircle1": "major_arc(A, B, C)",
"rectangle1": "rectangle(D, E, F, G)",
"line_DF": "line_segment(D, F)",
"line_AG": "line_segment(A, G)",
"line_BE": "line_segment(B, E)"
} | [
"angle_bisector(A, B, C, line_BE)",
"perpendicular(line_DF, line_AG)",
"point_lies_on(B, semicircle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-2.2628930836,
-3.6025785178
],
"B": [
-2.0086261076,
-0.5342984076
],
"C": [
-2.5171600969,
-6.6708586501
],
"D": [
-2.418946698,
-0.9730927264
],
"E": [
-1.4412193008,
-0.7327892222
],
"F": [... |
2obj_3rel_1extra_gen7075 | medium | Diagram description: The diagram contains points A, B, C, D, E, F. There is a trapezoid ABCD. There is a circle with center E. There are line segments AC, BD, AD, BC. F is the midpoint of line AC. Line AC is perpendicular to line BD. Point F lies on the circle. Further, length of line AD equals length of line BC and le... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
trapezoid1 = scene.add.trapezoid(A, B, C, D)
circle1 = scene.add.circle(E)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_AD = scene.add.line_segment(A, ... | {
"trapezoid1": "trapezoid(A, B, C, D)",
"circle1": "circle(E)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)"
} | [
"is_midpoint(F, line_AC)",
"perpendicular(line_AC, line_BD)",
"point_lies_on(F, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_BC').length)",
"scene.constraint.eq(scene.get_object('line_AC').length, 2 * scene.get_object('circle1').diameter)"
] | {
"points": {
"A": [
-1.3888394795,
0.0194497504
],
"B": [
-0.1736336942,
-0.4378794582
],
"C": [
1.3389927267,
1.2555135971
],
"D": [
-1.4096974909,
2.2899526919
],
"E": [
0.7009854787,
0.45414052400000005
],
"F":... |
2obj_3rel_1extra_gen7077 | medium | Diagram description: The diagram contains points A, B, C, D. There is a major arc with center A, start point B, end point C. There is a circle with center D. There is a line segment AC. There is a line segment BC. There is a line segment AD. There is a line segment BD. Line AC and line BC intersect at point C. Point C ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
semicircle1 = scene.add.major_arc(A, B, C)
circle1 = scene.add.circle(D)
line_AC = scene.add.line_segment(A, C)
line_BC = scene.add.line_segment(B, C)
line_AD = scene.add.line_segment(A, D)
line_BD = scene... | {
"semicircle1": "major_arc(A, B, C)",
"circle1": "circle(D)",
"line_AC": "line_segment(A, C)",
"line_BC": "line_segment(B, C)",
"line_AD": "line_segment(A, D)",
"line_BD": "line_segment(B, D)"
} | [
"lines_intersect_at(line_AC, line_BC, C)",
"point_lies_on(C, circle1)",
"is_radius(line_AD, circle1)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
-0.1899918927,
2.8692755287000002
],
"B": [
0.0762213562,
3.89490817
],
"C": [
-0.7441872953,
1.9661369632999999
],
"D": [
3.0857224686,
0.2375843973
]
},
"circles": {
"D": 4.2019165607
}
} |
2obj_3rel_1extra_gen7078 | medium | Diagram description: In the diagram, rhombus ABCD and rhomboid EFGH are positioned such that the diagonals AC and BD of the rhombus intersect at point I. The diagonal EG of the rhomboid is parallel to diagonal AC of the rhombus. Additionally, the diagonals EG and FH of the rhomboid intersect at point J. The additional ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I, J = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
rhombus1 = scene.add.rhombus(A, B, C, D)
rhomboid1 = scene.add.rhomboid(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B... | {
"rhombus1": "rhombus(A, B, C, D)",
"rhomboid1": "rhomboid(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EG": "line_segment(E, G)",
"line_FH": "line_segment(F, H)"
} | [
"lines_intersect_at(line_AC, line_BD, I)",
"parallel(line_AC, line_EG)",
"lines_intersect_at(line_EG, line_FH, J)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J"
] | [
"scene.constraint.eq(scene.get_object('rhombus1').inradius, scene.get_object('rhomboid1').area / scene.get_object('rhomboid1').perimeter)"
] | {
"points": {
"A": [
3.3945304598,
2.7413347571999997
],
"B": [
4.6327011985,
3.0238398463
],
"C": [
3.802760616,
2.0625526408
],
"D": [
2.5645883694,
1.7800464374
],
"E": [
0.2838991436,
2.5581461327
],
"F": [
... |
2obj_3rel_1extra_gen7079 | medium | Diagram description: In the diagram, a right triangle ABC with the right angle at B is positioned such that side AB is parallel to side EF of trapezoid DEFG. Side BC of the triangle is perpendicular to side AB. The trapezoid has parallel sides DE and FG, with non-parallel sides DG and EF connecting them. The additional... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
right_tri = scene.add.right_triangle(A, B, C)
trapezoid1 = scene.add.trapezoid(D, E, F, G)
line_AB = scene.add.line_segment(A, B)
line_BC = scene.add.line_segment(B, C)
line_DE = sc... | {
"right_tri": "right_triangle(A, B, C)",
"trapezoid1": "trapezoid(D, E, F, G)",
"line_AB": "line_segment(A, B)",
"line_BC": "line_segment(B, C)",
"line_DE": "line_segment(D, E)",
"line_EF": "line_segment(E, F)"
} | [
"parallel(line_AB, line_EF)",
"perpendicular(line_BC, line_AB)",
"right_angle(A, B, C)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('line_AB').length, scene.get_object('line_BC').length)"
] | {
"points": {
"A": [
1.5349122134000002,
0.2333368428
],
"B": [
-0.7814887512,
2.2021111065
],
"C": [
-2.750263018,
-0.1142898581
],
"D": [
-0.7006266218,
-3.1344297377
],
"E": [
-0.3768141773,
-1.3644252719
],
"F"... |
2obj_3rel_1extra_gen7080 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a regular pentagon with vertices A, B, C, D, E. There is a triangle with vertices F, G, H. There is a line segment AC. There is a line segment HG. G is the midpoint of line segment AC. H is the orthocenter of triangle FGH. Line segment AC... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
pentagon1 = scene.add.regular_pentagon(A, B, C, D, E)
triangle1 = scene.add.triangle(F, G, H)
line_AC = scene.add.line_segment(A, C)
line_HG = scene.add.line_segment(H, G)
... | {
"pentagon1": "regular_pentagon(A, B, C, D, E)",
"triangle1": "triangle(F, G, H)",
"line_AC": "line_segment(A, C)",
"line_HG": "line_segment(H, G)"
} | [
"is_midpoint(G, line_AC)",
"is_orthocenter(H, triangle1)",
"perpendicular(line_AC, line_HG)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('line_HG').length, scene.get_object('pentagon1').inradius)"
] | {
"points": {
"A": [
-0.8997644334,
-1.4125643076
],
"B": [
-0.6705717561,
-2.8436576208
],
"C": [
0.7613032971,
-3.0679145859
],
"D": [
1.4170580704,
-1.7754196993
],
"E": [
0.3904617553,
-0.7523569640000001
],
"F... |
2obj_3rel_1extra_gen7082 | medium | Diagram description: In the diagram, trapezoid ABCD and quadrilateral EFGH are positioned such that the diagonals AC and BD of the trapezoid intersect at point I, which is the midpoint of diagonal AC. The diagonals AC and BD are perpendicular to each other. Additionally, side EF of quadrilateral EFGH is parallel to sid... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I"])
trapezoid1 = scene.add.trapezoid(A, B, C, D)
quad1 = scene.add.quadrilateral(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D... | {
"trapezoid1": "trapezoid(A, B, C, D)",
"quad1": "quadrilateral(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)",
"line_FG": "line_segment(F, G)"
} | [
"is_midpoint(I, line_AC)",
"perpendicular(line_AC, line_BD)",
"parallel(line_EF, line_FG)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [
"scene.constraint.eq(scene.get_object('trapezoid1').area, scene.get_object('quad1').area)",
"scene.constraint.leq(scene.get_object('line_AC').length, 8.0)"
] | {
"points": {
"A": [
1.3157782340000002,
-2.8115447337
],
"B": [
-1.3722459365000002,
-1.4998416633
],
"C": [
-0.1446068534,
-4.0780938058
],
"D": [
1.6036985177,
-4.9312325214
],
"E": [
-5.1152397906000004,
-2.0272972885
... |
2obj_3rel_1extra_gen7083 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a rhomboid ABCD. There is a parallelogram EFGH. There is a line segment AB. There is a line segment BC. There is a line segment EF. There is a line segment FG. rhomboid ABCD is similar to parallelogram EFGH. line AB is parallel to line EF... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
rhomboid1 = scene.add.rhomboid(A, B, C, D)
parallelogram1 = scene.add.parallelogram(E, F, G, H)
line_AB = scene.add.line_segment(A, B)
line_BC = scene.add.line_segment(B, C)... | {
"rhomboid1": "rhomboid(A, B, C, D)",
"parallelogram1": "parallelogram(E, F, G, H)",
"line_AB": "line_segment(A, B)",
"line_BC": "line_segment(B, C)",
"line_EF": "line_segment(E, F)",
"line_FG": "line_segment(F, G)"
} | [
"similar(rhomboid1, parallelogram1)",
"parallel(line_AB, line_EF)",
"parallel(line_BC, line_FG)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('rhomboid1').area, scene.get_object('parallelogram1').area)"
] | {
"points": {
"A": [
-2.03611015,
3.5564973115000003
],
"B": [
-2.6514458097,
5.2519087307
],
"C": [
0.4172312117,
4.7836399427
],
"D": [
1.0325662104,
3.0882290142
],
"E": [
-0.4278422705,
-1.0086217982
],
"F": [
... |
2obj_3rel_1extra_gen7084 | medium | Diagram description: In the diagram, parallelogram ABCD and regular pentagon EFGHI are positioned such that an acute angle is formed at vertex D of the parallelogram. Side AB of the parallelogram is parallel to side EF of the pentagon. Additionally, side BC of the parallelogram and side FG of the pentagon intersect at ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I, J = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
parallelogram1 = scene.add.parallelogram(A, B, C, D)
pentagon1 = scene.add.regular_pentagon(E, F, G, H, I)
line_AB = scene.add.line_segment(A, B)
line_BC = s... | {
"parallelogram1": "parallelogram(A, B, C, D)",
"pentagon1": "regular_pentagon(E, F, G, H, I)",
"line_AB": "line_segment(A, B)",
"line_BC": "line_segment(B, C)",
"line_EF": "line_segment(E, F)",
"line_FG": "line_segment(F, G)"
} | [
"acute_angle(A, D, B)",
"parallel(line_AB, line_EF)",
"lines_intersect_at(line_BC, line_FG, J)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J"
] | [
"scene.constraint.eq(scene.get_object('line_AB').slope, scene.get_object('line_EF').slope)"
] | {
"points": {
"A": [
6.1258583822,
0.1591462454
],
"B": [
4.882690619,
-0.3473983947
],
"C": [
1.4592423039,
-0.0427020386
],
"D": [
2.7024099956,
0.4638426029
],
"E": [
4.8578446541,
0.5076182371
],
"F": [
4... |
2obj_3rel_1extra_gen7085 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is an isosceles trapezoid with vertices A, B, C, D. There is an equilateral triangle with vertices E, F, G. There is a line segment AB. There is a line segment CD. There is a line segment EF. There is a line segment FG. There is a line segment ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
trapezoid1 = scene.add.isosceles_trapezoid(A, B, C, D)
triangle1 = scene.add.equilateral_triangle(E, F, G)
line_AB = scene.add.line_segment(A, B)
line_CD = scene.add.line_segment(C,... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"triangle1": "equilateral_triangle(E, F, G)",
"line_AB": "line_segment(A, B)",
"line_CD": "line_segment(C, D)",
"line_EF": "line_segment(E, F)",
"line_FG": "line_segment(F, G)",
"line_GE": "line_segment(G, E)"
} | [
"parallel(line_AB, line_CD)",
"point_lies_on(E, line_AB)",
"is_midpoint(F, line_AB)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('triangle1').area, scene.get_object('trapezoid1').area)"
] | {
"points": {
"A": [
0.4964117042,
0.8239498789
],
"B": [
1.6680966208,
2.8315174906
],
"C": [
0.054352919400000005,
1.4396605499000001
],
"D": [
0.9145842403000001,
2.9135828872
],
"E": [
0.7280332435,
1.2208106445
],... |
2obj_3rel_1extra_gen7087 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a square with vertices A, B, C, D. There is a right trapezoid with vertices E, F, G, H. There is a line segment AC. There is a line segment EG. Line AC is collinear with points A, C, and E. Line EG is perpendicular to line AC. Point H lie... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
square1 = scene.add.square(A, B, C, D)
trapezoid1 = scene.add.right_trapezoid(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_EG = scene.add.line_segment(E, G)
### ... | {
"square1": "square(A, B, C, D)",
"trapezoid1": "right_trapezoid(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_EG": "line_segment(E, G)"
} | [
"collinear(A, C, E)",
"perpendicular(line_AC, line_EG)",
"point_lies_on(H, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('square1').area, scene.get_object('trapezoid1').area)"
] | {
"points": {
"A": [
0.9546205485,
-3.5203115765
],
"B": [
0.9304279879,
-3.1794684454
],
"C": [
1.2711736131,
-3.1553903158
],
"D": [
1.2953906879,
-3.4961687572
],
"E": [
1.4079063272,
-3.0093311103
],
"F": [
... |
2obj_3rel_1extra_gen7090 | medium | Diagram description: In the diagram, square ABCD is inscribed in circle O, meaning all four vertices of the square lie on the circumference of the circle. The diagonals AC and BD of the square are perpendicular to each other. Line segment OA is a radius of the circle, connecting the center O to vertex A of the square. ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, O = scene.add.points(["A", "B", "C", "D", "O"])
square1 = scene.add.square(A, B, C, D)
circle1 = scene.add.circle(O)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_OA = scene.add.line_segment(O, A)
### relati... | {
"square1": "square(A, B, C, D)",
"circle1": "circle(O)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_OA": "line_segment(O, A)"
} | [
"is_circumcircle(circle1, square1)",
"is_radius(line_OA, circle1)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"O"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, 2 * scene.get_object('circle1').radius)"
] | {
"points": {
"A": [
-1.3321962609,
-2.2744392163000002
],
"B": [
-0.4466050708,
-2.4159373126
],
"C": [
-0.3051069823,
-1.5303461127
],
"D": [
-1.1906981583,
-1.3888480644
],
"O": [
-0.8186516135,
-1.9023926446
]
},... |
2obj_3rel_1extra_gen7091 | medium | Diagram description: The diagram contains points A, B, C, D, E, G, O. There is an isosceles triangle ABC with AB = BC. There is a circle with center O. There is a line segment AD. There is a line segment BE. There is a line segment OC. Line AD and line BE intersect at G. Line AD is an altitude of triangle ABC from vert... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, G, O = scene.add.points(["A", "B", "C", "D", "E", "G", "O"])
triangleABC = scene.add.isosceles_triangle(A, B, C)
circleO = scene.add.circle(O)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_OC = scene.add.l... | {
"triangleABC": "isosceles_triangle(A, B, C)",
"circleO": "circle(O)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_OC": "line_segment(O, C)"
} | [
"lines_intersect_at(line_AD, line_BE, G)",
"is_altitude(line_AD, triangleABC, A)",
"is_radius(line_OC, circleO)"
] | [
"A",
"B",
"C",
"D",
"E",
"G",
"O"
] | [
"scene.constraint.eq(scene.get_object('triangleABC').inradius, scene.get_object('circleO').area / (4 * scene.get_object('triangleABC').perimeter))",
"scene.constraint.leq(scene.get_object('line_OC').length, scene.get_object('triangleABC').circumradius)"
] | {
"points": {
"A": [
2.04072157,
-1.8201214334
],
"B": [
1.0960889683,
0.1777545466
],
"C": [
1.8543312235,
2.2535454484
],
"D": [
0.5634210466,
-1.2804951359
],
"E": [
1.2074631766000001,
-2.3736802873
],
"G": [
... |
2obj_3rel_1extra_gen7092 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a triangle with vertices A, B, C. There is a scalene triangle with vertices D, E, F. There is a line segment AD. There is a line segment BE. There is a line segment CF. There is a line segment BG. Line BG is the perpendicular bisector of lin... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
triangle1 = scene.add.triangle(A, B, C)
scalene_triangle1 = scene.add.scalene_triangle(D, E, F)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF... | {
"triangle1": "triangle(A, B, C)",
"scalene_triangle1": "scalene_triangle(D, E, F)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)",
"line_perp": "line_segment(B, G)"
} | [
"perpendicular_bisector_at(line_AD, line_perp)",
"is_altitude(line_AD, triangle1, A)",
"is_median(line_BE, triangle1, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('line_AD').slope, scene.get_object('line_BE').slope)"
] | {
"points": {
"A": [
0.383570675,
1.2145111406
],
"B": [
-0.3174331426,
1.4725706151
],
"C": [
-0.6889832016,
1.9745050192
],
"D": [
0.054116407000000005,
0.9706360883
],
"E": [
-0.1527063313,
1.5945078639
],
"F": ... |
2obj_3rel_1extra_gen7094 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a major arc with center A, start point B, end point C. There is a rectangle with vertices D, E, F, G. There is a line segment AC. There is a line segment DF. Angle ABC is acute. The major arc with center A, start B, end C is symmetric with r... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
semicircle1 = scene.add.major_arc(A, B, C)
rectangle1 = scene.add.rectangle(D, E, F, G)
line_AC = scene.add.line_segment(A, C)
line_DF = scene.add.line_segment(D, F)
### relationsh... | {
"semicircle1": "major_arc(A, B, C)",
"rectangle1": "rectangle(D, E, F, G)",
"line_AC": "line_segment(A, C)",
"line_DF": "line_segment(D, F)"
} | [
"acute_angle(A, B, C)",
"mirror_across_line(semicircle1, semicircle1, line_AC)",
"perpendicular(line_DF, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-3.1474272282,
-0.9648145279
],
"B": [
-1.1395884286,
0.1866466944
],
"C": [
-5.1552660178,
-2.116275757
],
"D": [
-1.3623086381,
1.6824402303000001
],
"E": [
0.24799000200000001,
2.0640984495
],
... |
2obj_3rel_1extra_gen7098 | medium | Diagram description: The diagram contains points A, B, C, D, E. There is a circle with center A. There are line segments BC, CD, DE, and BE. There is a parallelogram BCDE. Line BC is a chord of the circle. Line BC intersects the circle at points B and C. Line CD is parallel to line BE. Further, the area of the circle e... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
circle1 = scene.add.circle(A)
parallelogram1 = scene.add.parallelogram(B, C, D, E)
line_BC = scene.add.line_segment(B, C)
line_CD = scene.add.line_segment(C, D)
line_DE = scene.add.line_segment(D, ... | {
"circle1": "circle(A)",
"parallelogram1": "parallelogram(B, C, D, E)",
"line_BC": "line_segment(B, C)",
"line_CD": "line_segment(C, D)",
"line_DE": "line_segment(D, E)",
"line_BE": "line_segment(B, E)"
} | [
"line_extension_intersects_circle_at(line_BC, circle1, B, C)",
"is_chord(line_BC, circle1)",
"parallel(line_CD, line_BE)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('circle1').area, scene.get_object('parallelogram1').area)"
] | {
"points": {
"A": [
1.5655811518,
-0.8796897296
],
"B": [
1.6472791367,
-0.3571030712
],
"C": [
1.0389049599,
-0.8308679886
],
"D": [
1.8472252703,
-1.6461129299000001
],
"E": [
2.4555994179000002,
-1.1723479905
]
}... |
2obj_3rel_1extra_gen7099 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is an equilateral triangle with vertices A, B, C. There is a square with vertices D, E, F, G. There is a line segment AD. There is a line segment CF. There is a line segment BE. E is the midpoint of line AD. Line AD is perpendicular to line CF.... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
triangle1 = scene.add.equilateral_triangle(A, B, C)
square1 = scene.add.square(D, E, F, G)
line_AD = scene.add.line_segment(A, D)
line_CF = scene.add.line_segment(C, F)
line_BE = sc... | {
"triangle1": "equilateral_triangle(A, B, C)",
"square1": "square(D, E, F, G)",
"line_AD": "line_segment(A, D)",
"line_CF": "line_segment(C, F)",
"line_BE": "line_segment(B, E)"
} | [
"is_midpoint(E, line_AD)",
"perpendicular(line_AD, line_CF)",
"parallel(line_BE, line_CF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-0.7606103903,
-1.1107187887
],
"B": [
-1.3617414593000001,
-0.639891666
],
"C": [
-0.6534267036,
-0.3547109939
],
"D": [
-1.2545589986999999,
0.1161156227
],
"E": [
-1.0075848048,
-0.497302163
],
... |
2obj_4rel_2extra_gen7056 | medium | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There is a circle with center B. There is a line segment CD. There is a line segment EF. Circle with center A is the mirror image of circle with center B across line CD. Point F is the midpoint of line CD. Line CD is per... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
circle1 = scene.add.circle(A)
circle2 = scene.add.circle(B)
line_CD = scene.add.line_segment(C, D)
line_EF = scene.add.line_segment(E, F)
### relationships
scene.relate.mirror_across_line... | {
"circle1": "circle(A)",
"circle2": "circle(B)",
"line_CD": "line_segment(C, D)",
"line_EF": "line_segment(E, F)"
} | [
"mirror_across_line(circle1, circle2, line_CD)",
"is_midpoint(F, line_CD)",
"perpendicular(line_CD, line_EF)",
"point_lies_on(F, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('circle1').area, scene.get_object('circle2').area)",
"scene.constraint.eq(scene.angle(scene.get_object('C'), scene.get_object('F'), scene.get_object('E')), 90)"
] | {
"points": {
"A": [
-1.5751458823,
3.2942710614
],
"B": [
-2.6523065797000003,
4.1348718363
],
"C": [
0.4192719059,
6.9603999343
],
"D": [
-4.6741392862,
0.4336127991
],
"E": [
2.6178142889,
-0.0061172505
],
"F": ... |
2obj_4rel_2extra_gen7059 | medium | Diagram description: In the diagram, rhombus ABCD and square EFGH are positioned such that the diagonals of the rhombus intersect at point I, and the diagonals of the square intersect at point J. Line segment AC is a diagonal of the rhombus, and BD is the other diagonal; similarly, EG and FH are diagonals of the square... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I, J = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
rhombus1 = scene.add.rhombus(A, B, C, D)
square1 = scene.add.square(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)... | {
"rhombus1": "rhombus(A, B, C, D)",
"square1": "square(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EG": "line_segment(E, G)",
"line_FH": "line_segment(F, H)",
"line_AF": "line_segment(A, F)",
"line_CE": "line_segment(C, E)"
} | [
"line_extensions_intersect_at(line_AC, line_BD, I)",
"line_extensions_intersect_at(line_EG, line_FH, J)",
"point_lies_on(I, line_AC)",
"point_lies_on(J, line_EG)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J"
] | [
"scene.constraint.eq(scene.get_object('line_AF').length, scene.get_object('line_CE').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('F'), scene.get_object('E')), 90)"
] | {
"points": {
"A": [
-1.2286655239,
1.0264057457
],
"B": [
-0.3968773874,
-0.8922705407
],
"C": [
1.5044013203,
-1.7630851923000002
],
"D": [
0.6726115529000001,
0.1555926458
],
"E": [
0.3049129136,
-0.5631191331000001
... |
2obj_4rel_2extra_gen7060 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, I. There is a rectangle with A, B, C, D. There is a parallelogram with E, F, G, H. There is a line segment AC. There is a line segment EG. There is a line segment BF. There is a line segment DH. The extensions of line AC and line EG intersect at p... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I"])
rectangle1 = scene.add.rectangle(A, B, C, D)
parallelogram1 = scene.add.parallelogram(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_EG = scene.add.line_seg... | {
"rectangle1": "rectangle(A, B, C, D)",
"parallelogram1": "parallelogram(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_EG": "line_segment(E, G)",
"line_BF": "line_segment(B, F)",
"line_DH": "line_segment(D, H)"
} | [
"line_extensions_intersect_at(line_AC, line_EG, I)",
"point_lies_on(I, line_AC)",
"point_lies_on(I, line_EG)",
"parallel(line_BF, line_DH)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [
"scene.constraint.eq(scene.get_object('rectangle1').area, scene.get_object('parallelogram1').area)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('D')), 90)"
] | {
"points": {
"A": [
-3.0729882789,
-0.3019546829
],
"B": [
-1.1451627195,
1.6712705436
],
"C": [
0.9359417652,
-0.36195319260000003
],
"D": [
-0.9918834232,
-2.3351779314
],
"E": [
0.1645740998,
-1.44478082
],
"F"... |
2obj_4rel_2extra_gen7061 | medium | Diagram description: In the diagram, rhomboid ABCD and isosceles trapezoid EFGH are positioned such that the diagonals AC and BD of the rhomboid are perpendicular to each other. An acute angle is formed at vertex D of the rhomboid. The diagonal AC of the rhomboid intersects the diagonal EG of the trapezoid at point I. ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I"])
rhomboid1 = scene.add.rhomboid(A, B, C, D)
trapezoid1 = scene.add.isosceles_trapezoid(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_seg... | {
"rhomboid1": "rhomboid(A, B, C, D)",
"trapezoid1": "isosceles_trapezoid(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EG": "line_segment(E, G)",
"line_FH": "line_segment(F, H)"
} | [
"perpendicular(line_AC, line_BD)",
"acute_angle(A, D, C)",
"lines_intersect_at(line_AC, line_EG, I)",
"parallel(line_BD, line_FH)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [] | {
"points": {
"A": [
-1.084552894,
0.6218217413
],
"B": [
-0.9046809446,
-0.0928205765
],
"C": [
-0.195348402,
0.1068514503
],
"D": [
-0.37519165,
0.8215097934000001
],
"E": [
-0.7396564235,
0.5711545155000001
],
"... |
2obj_4rel_2extra_gen7066 | medium | Diagram description: Two circles, circle A and circle B, are positioned such that a line segment CD is a chord of circle A and is parallel to another line segment EF. The extensions of line segments CD and GH intersect at point I. Line segment EF is tangent to circle B at point J. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I, J = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
circle1 = scene.add.circle(A)
circle2 = scene.add.circle(B)
line_CD = scene.add.line_segment(C, D)
line_EF = scene.add.line_segment(E, F)
line_GH = scene.add... | {
"circle1": "circle(A)",
"circle2": "circle(B)",
"line_CD": "line_segment(C, D)",
"line_EF": "line_segment(E, F)",
"line_GH": "line_segment(G, H)"
} | [
"parallel(line_CD, line_EF)",
"line_extensions_intersect_at(line_CD, line_GH, I)",
"is_chord(line_CD, circle1)",
"tangent_to_circle(line_EF, circle2, J)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J"
] | [] | {
"points": {
"A": [
0.3624995514,
-1.7374181262000001
],
"B": [
-2.6659797615,
0.3873629357
],
"C": [
0.1476765693,
-1.6180328661
],
"D": [
0.1412734153,
-1.8444728539000002
],
"E": [
-0.7410907624,
2.502974922
],
... |
2obj_4rel_2extra_gen7067 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a major arc with center A and endpoints B and C. There is a semicircle with center D and endpoints E and F. There is a line segment BE. There is a line segment CF. There is a line segment DE. Point B lies on the major arc. Point C lies on th... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
major_arc1 = scene.add.major_arc(A, B, C)
semicircle1 = scene.add.semicircle(D, E, F)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_segment(C, F)
line_DE = scene.a... | {
"major_arc1": "major_arc(A, B, C)",
"semicircle1": "semicircle(D, E, F)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)",
"line_DE": "line_segment(D, E)"
} | [
"point_lies_on(B, major_arc1)",
"point_lies_on(C, major_arc1)",
"lines_intersect_at(line_BE, line_CF, G)",
"perpendicular(line_BE, line_CF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-0.6335225901,
0.6262636206000001
],
"B": [
-1.0450873689,
0.201746646
],
"C": [
-1.2184682666,
0.5400149232
],
"D": [
-0.6524107892000001,
1.1872637483
],
"E": [
-0.7642441734000001,
1.9437980405
... |
2obj_4rel_2extra_gen7068 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a regular pentagon ABCDE. There is a triangle FGH. There is a line segment AG. There is a line segment DH. There is a line segment BF. There is a line segment CE. Points A, G, and H are collinear. Points B, F, and E are collinear. Triangl... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
pentagon1 = scene.add.regular_pentagon(A, B, C, D, E)
triangle1 = scene.add.triangle(F, G, H)
line_AG = scene.add.line_segment(A, G)
line_DH = scene.add.line_segment(D, H)
l... | {
"pentagon1": "regular_pentagon(A, B, C, D, E)",
"triangle1": "triangle(F, G, H)",
"line_AG": "line_segment(A, G)",
"line_DH": "line_segment(D, H)",
"line_BF": "line_segment(B, F)",
"line_CE": "line_segment(C, E)"
} | [
"collinear(A, G, H)",
"collinear(B, F, E)",
"congruent(triangle1, triangle1)",
"perpendicular(line_AG, line_DH)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
0.2685249783,
3.4813237867
],
"B": [
-0.6235433714,
3.7654965949
],
"C": [
-1.1694720526,
3.004903405
],
"D": [
-0.6148061833,
2.2506581538
],
"E": [
0.2739248575,
2.5451021426000002
],
"F": [
... |
2obj_4rel_2extra_gen7069 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, I, J. There is a kite with vertices A, B, C, D. There is a rhombus with vertices E, F, G, H. There is a line segment AC. There is a line segment BD. There is a line segment EG. There is a line segment FH. Line segment AC intersects line segment BD... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I, J = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
kite1 = scene.add.kite(A, B, C, D)
rhombus1 = scene.add.rhombus(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
lin... | {
"kite1": "kite(A, B, C, D)",
"rhombus1": "rhombus(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EG": "line_segment(E, G)",
"line_FH": "line_segment(F, H)"
} | [
"lines_intersect_at(line_AC, line_BD, I)",
"lines_intersect_at(line_EG, line_FH, J)",
"similar(kite1, rhombus1)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J"
] | [] | {
"points": {
"A": [
2.6552567699000003,
1.208395294
],
"B": [
-0.6201550263,
1.1233686064
],
"C": [
-0.016908995200000002,
-2.0971770534
],
"D": [
3.2584707975000002,
-2.01202625
],
"E": [
-1.5160560553,
5.6908910576
... |
2obj_4rel_2extra_gen7071 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a rhombus with A, B, C, D. There is a square with E, F, G, H. There is a line segment AC. There is a line segment BD. There is a line segment EF. There is a line segment FG. Point A lies on line segment EF. Point C lies on line segment FG... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
rhombus1 = scene.add.rhombus(A, B, C, D)
square1 = scene.add.square(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EF = scene... | {
"rhombus1": "rhombus(A, B, C, D)",
"square1": "square(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)",
"line_FG": "line_segment(F, G)"
} | [
"point_lies_on(A, line_EF)",
"point_lies_on(C, line_FG)",
"obtuse_angle(B, A, D)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('rhombus1').area, scene.get_object('square1').area)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('D')), 120)"
] | {
"points": {
"A": [
-1.4619855779,
0.9218956984000001
],
"B": [
0.9919581349000001,
-0.3666758403
],
"C": [
-1.3509496024,
-1.8475670437
],
"D": [
-3.8048955000999998,
-0.5589975432000001
],
"E": [
-1.3414319342,
1.129522... |
2obj_4rel_2extra_gen7073 | medium | Diagram description: The diagram contains points A, B, C, D, E. There is a circle with center E. There is a kite ABCD. There is a line segment AC. There is a line segment BD. There is a line segment AB. There is a line segment CD. Point A lies on the circle. Point C lies on the circle. Angle BAD is a right angle. Line ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
kite1 = scene.add.kite(A, B, C, D)
circle1 = scene.add.circle(E)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_AB = scene.add.line_segment(A, B)
line_CD = scene... | {
"kite1": "kite(A, B, C, D)",
"circle1": "circle(E)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AB": "line_segment(A, B)",
"line_CD": "line_segment(C, D)"
} | [
"point_lies_on(A, circle1)",
"point_lies_on(C, circle1)",
"right_angle(B, A, D)",
"perpendicular_bisector_at(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AB').length, scene.get_object('line_CD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('D')), 90)"
] | {
"points": {
"A": [
-3.2830190546,
-1.1807341043
],
"B": [
0.1293591217,
-1.3381089278
],
"C": [
0.286734011,
2.0742693158
],
"D": [
-3.12564423,
2.2316440578
],
"E": [
-2.7487741298,
1.8183317823
]
},
"circles": ... |
2obj_4rel_2extra_gen7074 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is an isosceles trapezoid ABCD. There is a rhomboid EFGH. There is line AD. There is line BC. There is line EF. There is line GH. angle ADC is obtuse. point H is the midpoint of line AD. line AD is perpendicular to line BC. line EF is parall... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H"])
trapezoid1 = scene.add.isosceles_trapezoid(A, B, C, D)
rhomboid1 = scene.add.rhomboid(E, F, G, H)
line_AD = scene.add.line_segment(A, D)
line_BC = scene.add.line_segment(B, ... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"rhomboid1": "rhomboid(E, F, G, H)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)",
"line_EF": "line_segment(E, F)",
"line_GH": "line_segment(G, H)"
} | [
"obtuse_angle(A, D, C)",
"is_midpoint(H, line_AD)",
"perpendicular(line_AD, line_BC)",
"parallel(line_EF, line_GH)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
-1.4976841498,
2.8747719469
],
"B": [
-3.2208893826000002,
-4.2331736181
],
"C": [
-0.6361968283,
-2.6571731151
],
"D": [
0.07831635840000001,
0.29007933150000004
],
"E": [
0.3834340137,
-1.32853390640... |
2obj_4rel_2extra_gen7076 | medium | Diagram description: Two circles are drawn with centers A and B respectively. Points C and D lie on the first circle, and line segment CD is a chord of circle A. Lines CD and EF intersect at point G. Line segment EF intersects the second circle at points E and F, making EF a chord of circle B. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
circle1 = scene.add.circle(A)
circle2 = scene.add.circle(B)
line_CD = scene.add.line_segment(C, D)
line_EF = scene.add.line_segment(E, F)
### relationships
scene.relate.point_lies... | {
"circle1": "circle(A)",
"circle2": "circle(B)",
"line_CD": "line_segment(C, D)",
"line_EF": "line_segment(E, F)"
} | [
"point_lies_on(C, circle1)",
"point_lies_on(D, circle1)",
"lines_intersect_at(line_CD, line_EF, G)",
"line_intersects_circle_at(line_EF, circle2, E, F)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
0.4267382899,
-0.6744665107000001
],
"B": [
-4.140643632,
1.1698463431000001
],
"C": [
-1.1550855531,
2.0560988984
],
"D": [
2.7956928594,
1.4102896749
],
"E": [
-0.6161288832,
2.1697223267
],
... |
2obj_4rel_2extra_gen7081 | medium | Diagram description: In the diagram, trapezoid ABCD has parallel sides AB and CD. Quadrilateral EFGH is positioned such that points A and C lie on side EH of the quadrilateral. Line segments AC and BD intersect at point I. Points A, C, and E are collinear, creating a configuration where the diagonal AC of the trapezoid... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I"])
trapezoid1 = scene.add.trapezoid(A, B, C, D)
quad1 = scene.add.quadrilateral(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D... | {
"trapezoid1": "trapezoid(A, B, C, D)",
"quad1": "quadrilateral(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EH": "line_segment(E, H)"
} | [
"point_lies_on(A, line_EH)",
"point_lies_on(C, line_EH)",
"collinear(A, C, E)",
"lines_intersect_at(line_AC, line_BD, I)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [
"scene.constraint.eq(scene.get_object('trapezoid1').area, scene.get_object('quad1').area)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('D')), 90)"
] | {
"points": {
"A": [
-1.6385999217,
-0.8388733422
],
"B": [
-0.983964041,
1.3028460983999999
],
"C": [
1.738551911,
0.7299219252
],
"D": [
1.6660839489,
0.4928350261
],
"E": [
2.3045860478,
0.9928628848000001
],
"F... |
2obj_4rel_2extra_gen7086 | medium | Diagram description: In the diagram, rectangle ABCD and right trapezoid EFGH are positioned such that the diagonal AC of the rectangle intersects the diagonal EG of the trapezoid at point I. Point I is the centroid of rectangle ABCD, and the sides BF and DH of the trapezoid are perpendicular to each other. The configur... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I"])
rectangle1 = scene.add.rectangle(A, B, C, D)
right_trapezoid1 = scene.add.right_trapezoid(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_EG = scene.add.line... | {
"rectangle1": "rectangle(A, B, C, D)",
"right_trapezoid1": "right_trapezoid(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_EG": "line_segment(E, G)",
"line_BF": "line_segment(B, F)",
"line_DH": "line_segment(D, H)"
} | [
"lines_intersect_at(line_AC, line_EG, I)",
"collinear(A, I, C)",
"perpendicular(line_BF, line_DH)",
"is_centroid(I, rectangle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [] | {
"points": {
"A": [
-0.1923701625,
-2.1043543261
],
"B": [
-1.1299068241999999,
-1.5962084738
],
"C": [
-1.0342295934,
-1.4196825797
],
"D": [
-0.0966928772,
-1.9278283187
],
"E": [
-0.6086389408,
-0.0558662482
],
... |
2obj_4rel_2extra_gen7088 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a triangle with vertices A, B, C. There is a rectangle with vertices D, E, F, G. There is a line segment AD. There is a line segment BE. There is a line segment CF. There is a line segment AG. There is a line segment BF. Line AD is perpendic... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
triangleABC = scene.add.triangle(A, B, C)
rectangleDEFG = scene.add.rectangle(D, E, F, G)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = sce... | {
"triangleABC": "triangle(A, B, C)",
"rectangleDEFG": "rectangle(D, E, F, G)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)",
"line_AG": "line_segment(A, G)",
"line_BF": "line_segment(B, F)"
} | [
"perpendicular(line_AD, line_BE)",
"is_midpoint(G, line_AD)",
"lines_intersect_at(line_AD, line_BE, A)",
"is_orthocenter(A, triangleABC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
6.5997725236,
-3.7180048614
],
"B": [
8.1254068477,
-5.1676386058
],
"C": [
5.3245638228,
-5.0600593955
],
"D": [
6.3246695276,
-4.0075237588
],
"E": [
-7.2339353959,
9.4265620611
],
"F": [
... |
2obj_4rel_2extra_gen7089 | medium | Diagram description: The diagram contains points A, B, C, D, E. There is a kite ABCD. There is a circle with center E. There is a line segment AC. There is a line segment BD. There is a line segment EA. There is a line segment ED. Point A lies on the circle. Point D lies on the circle. The extensions of line segment AC... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
kite1 = scene.add.kite(A, B, C, D)
circle1 = scene.add.circle(E)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_EA = scene.add.line_segment(E, A)
line_ED = scene... | {
"kite1": "kite(A, B, C, D)",
"circle1": "circle(E)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EA": "line_segment(E, A)",
"line_ED": "line_segment(E, D)"
} | [
"point_lies_on(A, circle1)",
"point_lies_on(D, circle1)",
"line_extensions_intersect_at(line_AC, line_BD, E)",
"perpendicular_bisector_at(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('E'), scene.get_object('D')), 90)"
] | {
"points": {
"A": [
-0.568690958,
3.1748264146
],
"B": [
1.7516123908,
2.1787408831
],
"C": [
0.7555268092,
-0.1415624398
],
"D": [
-1.5647765319,
0.8545230899
],
"E": [
0.0934179185,
1.5166319652
]
},
"circles": ... |
2obj_4rel_2extra_gen7093 | medium | Diagram description: In the diagram, a circle with center A has two radii AC and AD that are equal in length. A right triangle BCD is constructed such that the right angle is at vertex C, with sides BC and CD forming the legs and BD as the hypotenuse. The side BC of the triangle is parallel to the line segment AD, whic... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
circle1 = scene.add.circle(A)
right_tri1 = scene.add.right_triangle(B, C, D)
line_BC = scene.add.line_segment(B, C)
line_CD = scene.add.line_segment(C, D)
line_BD = scene.add.line_segment(B, D)
line_AD = s... | {
"circle1": "circle(A)",
"right_tri1": "right_triangle(B, C, D)",
"line_BC": "line_segment(B, C)",
"line_CD": "line_segment(C, D)",
"line_BD": "line_segment(B, D)",
"line_AD": "line_segment(A, D)",
"line_AC": "line_segment(A, C)"
} | [
"right_angle(D, C, B)",
"is_radius(line_AC, circle1)",
"is_radius(line_AD, circle1)",
"parallel(line_BC, line_AD)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
0.3452384784,
5.5801607354
],
"B": [
-1.3628565355,
-2.1286036418
],
"C": [
-1.4394402017,
-2.5210230911
],
"D": [
-1.2436634641,
-2.5616778347
]
},
"circles": {
"A": 8.295431678
}
} |
2obj_4rel_2extra_gen7095 | medium | Diagram description: The diagram contains points A, B, C, D, E, F. There is an acute triangle ABC. There is an obtuse triangle DEF. There is a line segment AD. There is a line segment BE. There is a line segment CF. Line AD is perpendicular to line BE. Points A, D, and E are collinear. Point E is the orthocenter of tri... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
acute_tri = scene.add.acute_triangle(A, B, C)
obtuse_tri = scene.add.obtuse_triangle(D, E, F)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.a... | {
"acute_tri": "acute_triangle(A, B, C)",
"obtuse_tri": "obtuse_triangle(D, E, F)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"perpendicular(line_AD, line_BE)",
"collinear(A, D, E)",
"is_orthocenter(E, acute_tri)",
"is_centroid(F, obtuse_tri)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-7.5187842351,
-8.0752735446
],
"B": [
7.3833999789,
8.3920239688
],
"C": [
7.9226550116,
7.8820380789
],
"D": [
-7.3149573696,
-7.8597493886
],
"E": [
7.7343244812,
8.053192154
],
"F": [
... |
2obj_4rel_2extra_gen7096 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, I. There is a trapezoid ABCD. There is an isosceles trapezoid EFGH. There is a line segment AC. There is a line segment BD. There is a line segment EG. The trapezoid ABCD is similar to the isosceles trapezoid EFGH. The isosceles trapezoid EFGH is ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I"])
trapezoid1 = scene.add.trapezoid(A, B, C, D)
isosceles_trapezoid1 = scene.add.isosceles_trapezoid(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.... | {
"trapezoid1": "trapezoid(A, B, C, D)",
"isosceles_trapezoid1": "isosceles_trapezoid(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EG": "line_segment(E, G)"
} | [
"similar(trapezoid1, isosceles_trapezoid1)",
"scale(trapezoid1, isosceles_trapezoid1, 2)",
"lines_intersect_at(line_AC, line_BD, I)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('I'), scene.get_object('B')), 90)"
] | {
"points": {
"A": [
-4.8370871766,
0.5440624373
],
"B": [
-2.6447894191,
-0.015459693100000001
],
"C": [
-2.4382360446,
1.9674137421000002
],
"D": [
-4.0681357236,
2.383394183
],
"E": [
-3.2637934518,
2.580333279
],
... |
2obj_4rel_2extra_gen7097 | medium | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There is a minor arc BC. There is a line segment BD. There is a line segment AC. There is a line segment EF. Line BD is perpendicular to line AC. Line BD is mirrored across line AC to line EF. Point B lies on the circle.... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F = scene.add.points(["A", "B", "C", "D", "E", "F"])
circle1 = scene.add.circle(A)
minor_arc1 = scene.add.minor_arc(A, B, C)
line_BD = scene.add.line_segment(B, D)
line_AC = scene.add.line_segment(A, C)
line_EF = scene.add.line_segment(E, F)
... | {
"circle1": "circle(A)",
"minor_arc1": "minor_arc(A, B, C)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"perpendicular(line_BD, line_AC)",
"mirror_across_line(line_BD, line_EF, line_AC)",
"point_lies_on(B, circle1)",
"point_lies_on(C, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
0.014563214100000001,
-0.9771531835
],
"B": [
0.1600795682,
-0.1864222274
],
"C": [
0.6138335087,
-0.44114431060000003
],
"D": [
0.0224202695,
-0.0325158862
],
"E": [
0.8165659299,
-0.9203890643
],... |
2obj_4rel_2extra_gen7100 | medium | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, I. There is a square ABCD. There is a square EFGH. There is a line segment AC. There is a line segment EG. There is a line segment DH. There is a right angle at D formed by points A and H. Line AC intersects line EG at I. Point I lies on line AC. ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G, H, I = scene.add.points(["A", "B", "C", "D", "E", "F", "G", "H", "I"])
square1 = scene.add.square(A, B, C, D)
square2 = scene.add.square(E, F, G, H)
line_AC = scene.add.line_segment(A, C)
line_EG = scene.add.line_segment(E, G)
line_DH =... | {
"square1": "square(A, B, C, D)",
"square2": "square(E, F, G, H)",
"line_AC": "line_segment(A, C)",
"line_EG": "line_segment(E, G)",
"line_DH": "line_segment(D, H)"
} | [
"right_angle(A, D, H)",
"lines_intersect_at(line_AC, line_EG, I)",
"point_lies_on(I, line_AC)",
"point_lies_on(I, line_EG)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [
"scene.constraint.eq(scene.get_object('square1').perimeter, scene.get_object('square2').perimeter)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('D'), scene.get_object('H')), 90)"
] | {
"points": {
"A": [
0.9844011891000001,
3.2210260798
],
"B": [
-1.5159269118,
1.8948199118
],
"C": [
-0.1897210909,
-0.6055069934
],
"D": [
2.3106078708,
0.7207002809
],
"E": [
-0.6737108725000001,
-4.0306299228
],
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.