Datasets:
unique_id stringlengths 24 24 | nl_description stringlengths 177 973 | pygeox_code stringlengths 322 1.43k | Objs unknown | Rels listlengths 1 6 | Points listlengths 4 15 | extra_rel listlengths 0 3 | possible_solution dict |
|---|---|---|---|---|---|---|---|
1obj_2rel_2extra_gen0001 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is an obtuse triangle ABC. There is a line segment AD. There is a line segment BE. There is a line segment FG. Line AD is an altitude of triangle ABC from vertex A. Line BE is a median of triangle ABC from vertex B. Lines AD and BE intersect... | 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.obtuse_triangle(A, B, C)
line_altitude = scene.add.line_segment(A, D)
line_median = scene.add.line_segment(B, E)
line_perp_bisector = scene.add.line_... | {
"triangleABC": "obtuse_triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_median": "line_segment(B, E)",
"line_perp_bisector": "line_segment(F, G)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"is_median(line_median, triangleABC, B)",
"lines_intersect_at(line_altitude, line_median, H)",
"perpendicular_bisector_at(line_median, line_perp_bisector, E)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('line_altitude').length, scene.get_object('line_median').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('D')), 30)"
] | {
"points": {
"A": [
-3.5000437557,
0.9446227476
],
"B": [
1.5854318531,
1.5754688009
],
"C": [
-0.41097961650000003,
-3.144087828
],
"D": [
0.5872278499,
-0.7843184553
],
"E": [
-1.9555131543000002,
-1.0997301945
],
... |
1obj_2rel_2extra_gen0002 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a triangle with vertices A, B, and C. There is a line segment AD. There is a line segment BE. There is a line segment FG. Line AD is an altitude of triangle ABC from vertex A. The extensions of line AD and line BE intersect at point H. Fu... | 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_altitude = scene.add.line_segment(A, D)
line_median = scene.add.line_segment(B, E)
line_perp_bisector = scene.add.line_segment... | {
"triangleABC": "triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_median": "line_segment(B, E)",
"line_perp_bisector": "line_segment(F, G)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"line_extensions_intersect_at(line_altitude, line_median, H)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('line_altitude').length, scene.get_object('line_median').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('D')), 90)"
] | {
"points": {
"A": [
1.7168169593,
8.6309137149
],
"B": [
-4.1272910288,
-7.5742908699000004
],
"C": [
-0.9589882114,
0.8909190269
],
"D": [
1.9116740079,
8.5606421368
],
"E": [
-4.0005903057,
-7.4104509538
],
"F":... |
1obj_2rel_2extra_gen0005 | Diagram description: The diagram contains points A, B, C, D. There is a quadrilateral with vertices A, B, C, D. There is a line segment AC. There is a line segment BD. There is a line segment AB. Line AB is parallel to line AC. 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)
line_AB = scene.add.line_segment(A, B)
### relationships
scene.relate.pa... | {
"quadrilateral1": "quadrilateral(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AB": "line_segment(A, B)"
} | [
"parallel(line_AB, line_AC)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
-3.0038797154,
1.6180145596000002
],
"B": [
-3.4538348223,
1.8427389346
],
"C": [
-0.4514881821,
0.34325496250000004
],
"D": [
-4.2923253918,
0.16386847670000002
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0007 | 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. The extension of line BC intersects the circle at points B and C. Line BC is perpendicular to line DE. Further, the length of line BC is equal to the length of line DE and the angle BAC is... | 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)
line_seg1 = scene.add.line_segment(B, C)
line_seg2 = scene.add.line_segment(D, E)
### relationships
scene.relate.line_extension_intersects_circle_at(line_seg1, circl... | {
"circle1": "circle(A)",
"line_seg1": "line_segment(B, C)",
"line_seg2": "line_segment(D, E)"
} | [
"line_extension_intersects_circle_at(line_seg1, circle1, B, C)",
"perpendicular(line_seg1, line_seg2)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_seg1').length, scene.get_object('line_seg2').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-0.43144048890000003,
-0.8062527401
],
"B": [
-1.7938108258,
1.9846313046000001
],
"C": [
-3.2223245341,
-2.1686230743
],
"D": [
1.5294961904000002,
1.0319270256
],
"E": [
-2.6237581805,
2.4604407401
... |
1obj_2rel_2extra_gen0008 | Diagram description: The diagram contains points A, B, C, D, E. There is a kite ABCD. There is a line AC. There is a line BD. There is a line BE. Line AC is perpendicular to line BD. Line BE is the angle bisector of angle ABD. Further, length of line AC is equal to length of line BD. Further, angle ABD is 45 degrees. | 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)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_angle_bisector = scene.add.line_segment(B, E)
### relationships
scene.relate.... | {
"kite1": "kite(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_angle_bisector": "line_segment(B, E)"
} | [
"perpendicular(line_AC, line_BD)",
"angle_bisector(A, B, D, line_angle_bisector)"
] | [
"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('B'), scene.get_object('D')), 45)"
] | {
"points": {
"A": [
0.1013207498,
-2.7686980817
],
"B": [
-4.3902366703,
-4.1487695095
],
"C": [
-5.7703081062,
0.3427879077
],
"D": [
-1.2787506472999999,
1.7228594126
],
"E": [
1.5820966831,
0.7884720203000001
]
}... |
1obj_2rel_2extra_gen0009 | Diagram description: The diagram contains points A, B, C, D, E. There is a circle with center A. There is a line segment BD. There is a line segment AC. There is a line segment ED. Line BD is a diameter of the circle. Angle EAC is acute. | 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)
line_BD = scene.add.line_segment(B, D)
line_AC = scene.add.line_segment(A, C)
line_ED = scene.add.line_segment(E, D)
### relationships
scene.relate.is_diameter(line_... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_ED": "line_segment(E, D)"
} | [
"is_diameter(line_BD, circle1)",
"acute_angle(E, A, C)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
1.0128277655,
2.3042623716
],
"B": [
0.6766183155000001,
2.0674577414
],
"C": [
-9.3579496834,
-10
],
"D": [
1.3490372188,
2.5410670049
],
"E": [
1.4169908481,
0.41692359840000004
]
},
"circles... |
1obj_2rel_2extra_gen0010 | Diagram description: The diagram contains points A, B, C, D. There is a rectangle with points A, B, C, D. There are line segments AC and BD. Line AC is perpendicular to line BD. Further, length of line AC is equal to length of line BD and angle ABC is a right angle. | 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.perpendicular(line_AC, line_BD)
### Extra relati... | {
"rectangle1": "rectangle(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_gen0012 | Diagram description: The diagram contains points A, B, C, D, E. There is a minor arc BC with center A. There is a line segment AD. There is a line segment BE. There is a line segment CE. Angle DAB is bisected by line AD. Point E lies on the minor arc BC. Further, length of line AD is equal to length of line BE and angl... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
arc1 = scene.add.minor_arc(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CE = scene.add.line_segment(C, E)
### relationships
scene.relate.angle_bisec... | {
"arc1": "minor_arc(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CE": "line_segment(C, E)"
} | [
"angle_bisector(D, A, B, line_AD)",
"point_lies_on(E, arc1)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"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": [
1.5949643520999999,
-3.431032231
],
"B": [
2.8580745641,
0.3831991106
],
"C": [
-1.0767017851,
-0.4300310269
],
"D": [
2.6499982032,
-0.2451320236
],
"E": [
-0.4773014042,
0.011281355600000001
]
... |
1obj_2rel_2extra_gen0013 | Diagram description: The diagram contains points A, B, C, D. There is an isosceles trapezoid ABCD. There is a line CD. Trapezoid ABCD is a mirror image of itself across line CD. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
trapezoid1 = scene.add.isosceles_trapezoid(A, B, C, D)
line_m = scene.add.line(C, D)
### relationships
scene.relate.mirror_across_line(trapezoid1, trapezoid1, line_m)
scene.solver.numerical()
scene.plot... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"line_m": "line(C, D)"
} | [
"mirror_across_line(trapezoid1, trapezoid1, line_m)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
-9.8557699356,
9.8106867035
],
"B": [
9.9941030139,
-9.9995477312
],
"C": [
9.8498717992,
-9.8536082414
],
"D": [
-10,
9.956625126
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0015 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a kite with points A, B, C, D. There is a line segment AC. There is a line segment BD. There is a line segment EG. Line AC intersects line BD at point F. Line AC is perpendicular to line BD. Further, the length of line AC is equal to the len... | 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_EG = scene.add.line_segment(E, G)
### relationships
scene.rel... | {
"kite1": "kite(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EG": "line_segment(E, G)"
} | [
"lines_intersect_at(line_AC, line_BD, F)",
"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.get_object('kite1').area, 12)"
] | {
"points": {
"A": [
-5.015203398,
-2.9569165693
],
"B": [
-0.6989463383000001,
-3.8609015399
],
"C": [
-1.5167677351000002,
0.4725072844
],
"D": [
-4.1283701951,
-0.3624658758
],
"E": [
-1.6728527883000002,
3.9377093194
... |
1obj_2rel_2extra_gen0016 | 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. Line AD is an altitude of triangle ABC from vertex A. Line BE is congruent to line CF. Further, the length of ... | 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"])
triangle_ABC = 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 = sce... | {
"triangle_ABC": "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)"
} | [
"is_altitude(line_AD, triangle_ABC, A)",
"congruent(line_BE, line_CF)"
] | [
"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.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 60)"
] | {
"points": {
"A": [
6.5401665155,
4.3373143244
],
"B": [
-4.3639238125,
-6.0724293288
],
"C": [
-7.9495130457,
8.6682928923
],
"D": [
-6.1454524355,
1.2516162388
],
"E": [
6.3494883822,
1.3887542501
],
"F": [
... |
1obj_2rel_2extra_gen0017 | Diagram description: The diagram contains points A, B, C, D. There is a circle with center A. There are line segments BD and AC. Line BD is a diameter of the circle. Angle CAB is obtuse. Further, the length of line AC equals the length of line BD and angle CAB equals 120 degrees. | 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.is_diameter(line_BD, circle1)
scene.relate.obtuse_angle(C, A, B)... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)"
} | [
"is_diameter(line_BD, circle1)",
"obtuse_angle(C, A, B)"
] | [
"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('C'), scene.get_object('A'), scene.get_object('B')), 120)"
] | {
"points": {
"A": [
1.2776835189,
-1.409638355
],
"B": [
3.9280116622000003,
1.4446805349
],
"C": [
-6.3164701533,
0.3265458003
],
"D": [
-1.3726446328,
-4.2639572226
]
},
"circles": {
"A": 3.8950449956
}
} |
1obj_2rel_2extra_gen0018 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a square with points A, B, C, D. There is a line segment AC. There is a line segment BD. There is a line segment EF. The square is congruent to itself. Line segment AC is perpendicular to line segment 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)"
} | [
"congruent(square1, square1)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-10,
-10
],
"B": [
-10,
10
],
"C": [
10,
10
],
"D": [
10,
-10
],
"E": [
-7.5786949707,
-8.9949154915
],
"F": [
-2.0337572274,
-6.568932008
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0019 | Diagram description: The diagram contains points A, B, C, D. There is a scalene triangle ABC. There is a line segment AD. There is a line segment BC. Line AD is an altitude of triangle ABC from vertex A. Point D lies on line BC. Further, length of line AD is equal to half the length of line BC, and the angle BAD is equ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
triangleABC = scene.add.scalene_triangle(A, B, C)
line_altitude_from_A = scene.add.line_segment(A, D)
line_BC = scene.add.line_segment(B, C)
### relationships
scene.relate.is_altitude(line_altitude_from_... | {
"triangleABC": "scalene_triangle(A, B, C)",
"line_altitude_from_A": "line_segment(A, D)",
"line_BC": "line_segment(B, C)"
} | [
"is_altitude(line_altitude_from_A, triangleABC, A)",
"point_lies_on(D, line_BC)"
] | [
"A",
"B",
"C",
"D"
] | [
"scene.constraint.eq(scene.get_object('line_altitude_from_A').length, scene.get_object('line_BC').length / 2)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('D')), 30)"
] | {
"points": {
"A": [
1.7368759088,
3.2069960816
],
"B": [
-2.4060853570000003,
0.8953450901000001
],
"C": [
4.6493008292999995,
-3.3171480216
],
"D": [
-0.3693707553,
-0.3206969382
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0020 | Diagram description: The diagram contains points A, B, C, D. There is an isosceles trapezoid ABCD. There is a line segment AD. There is a line segment BC. There is a line segment AC. There is a line segment BD. There is a line BD. The trapezoid ABCD is similar to itself. Line AD is perpendicular to line BC. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
trapezoid1 = scene.add.isosceles_trapezoid(A, B, C, D)
line_AD = scene.add.line_segment(A, D)
line_BC = scene.add.line_segment(B, C)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_m": "line(B, D)"
} | [
"similar(trapezoid1, trapezoid1)",
"perpendicular(line_AD, line_BC)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
9.932393306,
-9.843041221
],
"B": [
9.9213736998,
9.9836490935
],
"C": [
-9.786831125199999,
-9.7464754189
],
"D": [
-9.7977312066,
9.8651636041
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0023 | Diagram description: The diagram contains points A, B, C, D. There is a trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line segment AD. There is a line segment BC. The angle ADC is a right angle. Line AC is perpendicular to line BD. Further, the length of line AD equals the length of... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
trapezoid1 = scene.add.trapezoid(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_AD = scene.add.line_segment(A, D)
line_BC = scene.add.line_segment(B, C)
###... | {
"trapezoid1": "trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)"
} | [
"right_angle(A, D, C)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_BC').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('D'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
10,
-10
],
"B": [
-10,
-10
],
"C": [
-10,
10
],
"D": [
10,
10
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0024 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a rectangle with vertices A, B, C, D. There is a line segment AC. There is a line segment BD. There is a line segment EF. Line segment AC intersects line segment BD at point G. Line segment AC is perpendicular to line segment BD. Further, 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"])
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
... | {
"rectangle1": "rectangle(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)"
] | [
"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": [
-0.6754986366,
1.4391086465
],
"B": [
-1.8592606311000002,
1.4282513644
],
"C": [
-1.8484033326,
0.24448937310000002
],
"D": [
-0.6646413631,
0.2553466776
],
"E": [
0.45325551610000003,
2.0149134282
... |
1obj_2rel_2extra_gen0025 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a rectangle ABCD. There are line segments AC, BD, and EF. Point E lies on line AC. Line AC is perpendicular to line BD. Further, length of line AC is equal to length of line BD and angle ABC is 90 degrees. | 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)"
} | [
"point_lies_on(E, line_AC)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"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": [
-8.2773845001,
-7.5580886904
],
"B": [
-8.1551334448,
8.0685599015
],
"C": [
7.4715151469,
7.9463088467
],
"D": [
7.3492640925,
-7.6803397449
],
"E": [
-7.9588706816,
-7.2445198077
],
"F": [
... |
1obj_2rel_2extra_gen0026 | Diagram description: The diagram contains points A, B, C, D, E. There is a minor arc with center A, start B, and end C. There are line segments AD and BE. Line AD is parallel to line BE. Point D lies on the minor arc. Further, the central angle of the minor arc is 90 degrees. Further, the length of line AD is less than... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
arc1 = scene.add.minor_arc(A, B, C)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
### relationships
scene.relate.parallel(line_AD, line_BE)
scene.relate.point_lies... | {
"arc1": "minor_arc(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)"
} | [
"parallel(line_AD, line_BE)",
"point_lies_on(D, arc1)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('arc1').central_angle, 90)",
"scene.constraint.leq(scene.get_object('line_AD').length, scene.get_object('arc1').radius)"
] | {
"points": {
"A": [
3.3736154057,
2.6287469828
],
"B": [
0.0577756595,
2.7584404773999998
],
"C": [
3.243921913,
-0.6870927698
],
"D": [
0.487043115,
0.9918859666000001
],
"E": [
-0.4182523174,
2.4885038494
]
},
"... |
1obj_2rel_2extra_gen0027 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a rectangle with vertices A, B, C, D. There is a line segment AC. There is a line segment BD. There is a line segment EF. G is the centroid of the rectangle. Line AC is perpendicular to line BD. Further, length of line AC is equal to length ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
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
... | {
"rectangle1": "rectangle(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, rectangle1)",
"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": [
0.779104718,
6.8025798666
],
"B": [
1.710331165,
6.3908997767999995
],
"C": [
1.2986510682999999,
5.4596733214
],
"D": [
0.3674246127,
5.8713534106
],
"E": [
-9.5797978489,
-3.1458674707
],
"F"... |
1obj_2rel_2extra_gen0029 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a triangle with points A, B, C. 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 parallel to line CF. Further,... | 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"])
triangle_ABC = 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 = sce... | {
"triangle_ABC": "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)"
} | [
"is_altitude(line_AD, triangle_ABC, A)",
"parallel(line_BE, line_CF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"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": [
-0.6386669512,
-3.4665484541
],
"B": [
1.7055923356,
-0.1335770359
],
"C": [
-8.6994518578,
2.2030380948
],
"D": [
0.18641552420000002,
0.2075779922
],
"E": [
2.6044826370000003,
-1.7685424361000002
... |
1obj_2rel_2extra_gen0030 | Diagram description: The diagram contains points A, B, C, D, M, N. There is an isosceles trapezoid ABCD. There are line segments AC, BD, and MN. Points A, M and B are collinear. Line AC is perpendicular to line BD. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, M, N = scene.add.points(["A", "B", "C", "D", "M", "N"])
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_MN = scene.add.line_segment(M, N)
### relation... | {
"trapezoid_ABCD": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_MN": "line_segment(M, N)"
} | [
"collinear(A, M, B)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"M",
"N"
] | [] | {
"points": {
"A": [
0.7413493883000001,
1.1134475013
],
"B": [
1.2424551192,
-0.0340510111
],
"C": [
1.0488394774,
1.897691224
],
"D": [
2.0266988433,
-0.34154111130000003
],
"M": [
1.1606711,
0.1532289238
],
"N":... |
1obj_2rel_2extra_gen0032 | Diagram description: The diagram contains points A, B, C, D, E, F. There is an obtuse 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 an altitude of triangle ABC from vertex B. Line AD is congruent to 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.obtuse_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
sce... | {
"triangleABC": "obtuse_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)",
"congruent(line_AD, line_BE)"
] | [
"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')), 120)"
] | {
"points": {
"A": [
-4.4341426071,
-4.5565573778
],
"B": [
2.1682571315,
2.3037055107
],
"C": [
9.9718809531,
0.37211448820000004
],
"D": [
-2.4529237474,
3.4475628263
],
"E": [
-0.8416199032,
-5.3730000019
],
"F"... |
1obj_2rel_2extra_gen0034 | Diagram description: The diagram contains points A, B, C, H. There is a right triangle with vertices A, B, C. There is a line segment BH. There is a line segment AC. There is a line segment AB. Line BH is an altitude of triangle ABC from vertex B. Angle ABH is acute. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, H = scene.add.points(["A", "B", "C", "H"])
triangleABC = scene.add.right_triangle(A, B, C)
lineBH = scene.add.line_segment(B, H)
lineAC = scene.add.line_segment(A, C)
lineAB = scene.add.line_segment(A, B)
### relationships
scene.relate.is_altitud... | {
"triangleABC": "right_triangle(A, B, C)",
"lineBH": "line_segment(B, H)",
"lineAC": "line_segment(A, C)",
"lineAB": "line_segment(A, B)"
} | [
"is_altitude(lineBH, triangleABC, B)",
"acute_angle(A, B, H)"
] | [
"A",
"B",
"C",
"H"
] | [] | {
"points": {
"A": [
4.6085409288,
0.4920507992
],
"B": [
3.7405488221,
1.1950899848
],
"C": [
4.2703839305,
1.8492394243999999
],
"H": [
4.3928749089,
1.3576234957
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0035 | 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. Points A, E, and C are collinear. Line segment AC is perpendicular to line segment 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)"
} | [
"collinear(A, E, C)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.1726332898,
5.5089342036
],
"B": [
-3.8736845046,
7.0504824919
],
"C": [
-5.4152327929,
3.3494312757999998
],
"D": [
-1.7141815770000002,
1.8078829871000002
],
"E": [
-1.7900742179,
4.8426867816
... |
1obj_2rel_2extra_gen0038 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a major arc BC with center A. There is a line segment DE. There is a line segment CF. The extensions of line segment DE and line segment CF intersect at point G. Point F lies on the major arc BC with center A. | 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.line_extensions_intersect_at... | {
"major_arc1": "major_arc(A, B, C)",
"line_DE": "line_segment(D, E)",
"line_CF": "line_segment(C, F)"
} | [
"line_extensions_intersect_at(line_DE, line_CF, G)",
"point_lies_on(F, major_arc1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-0.9995397267,
-1.3920064403999999
],
"B": [
-0.2647987839,
-3.6270346720999997
],
"C": [
0.9752780110000001,
-2.6707911563
],
"D": [
3.5610604283000002,
2.3035923372
],
"E": [
3.1893315561,
1.85090885... |
1obj_2rel_2extra_gen0040 | Diagram description: The diagram contains points A, B, C, D, E. There is an obtuse triangle ABC with vertices A, B, C. There is a line segment AD. There is a line segment BE. Line AD is an altitude of triangle ABC from vertex A. Line AD and line BE intersect at point D. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
triangleABC = scene.add.obtuse_triangle(A, B, C)
line_altitude = scene.add.line_segment(A, D)
line_perpendicular = scene.add.line_segment(B, E)
### relationships
scene.relate.is_altitude(line_alt... | {
"triangleABC": "obtuse_triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_perpendicular": "line_segment(B, E)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"lines_intersect_at(line_altitude, line_perpendicular, D)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
0.5220201329,
1.7448063057
],
"B": [
1.4431176716,
-0.0733711215
],
"C": [
-6.4538353909,
-8.4915816654
],
"D": [
1.919201959,
0.4341382589
],
"E": [
4.0027833211,
2.6552514444
]
},
"circles": ... |
1obj_2rel_2extra_gen0041 | Diagram description: The diagram contains points A, B, C, D. There is an isosceles trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line BD. The trapezoid ABCD is congruent to itself. The trapezoid ABCD is a mirror image of itself across line BD. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D = scene.add.points(["A", "B", "C", "D"])
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_m = scene.add.line(B, D)
### relationships
scene.relate.congruent... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_m": "line(B, D)"
} | [
"congruent(trapezoid1, trapezoid1)",
"mirror_across_line(trapezoid1, trapezoid1, line_m)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
-2.6166831961,
2.6967122806
],
"B": [
-9.6482939324,
9.0954098629
],
"C": [
2.9684031008,
-2.3800329569
],
"D": [
10,
-8.778717702
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0043 | Diagram description: The diagram contains points O, A, B, P. There is a major arc with center O, start point A, end point B. There is a line segment OP. There is a line segment OA. The line OP is a rotation of line OA around point O by 90 degrees. Point P lies on the major arc. Further, length of line OA is equal to le... | from pygeox import GeoScene
scene = GeoScene()
### objects
O, A, B, P = scene.add.points(["O", "A", "B", "P"])
semicircle1 = scene.add.major_arc(O, A, B)
line_OP = scene.add.line_segment(O, P)
line_OA = scene.add.line_segment(O, A)
### relationships
scene.relate.rotation_around_point(line_OA, line_OP, O, 90)
scen... | {
"semicircle1": "major_arc(O, A, B)",
"line_OP": "line_segment(O, P)",
"line_OA": "line_segment(O, A)"
} | [
"rotation_around_point(line_OA, line_OP, O, 90)",
"point_lies_on(P, semicircle1)"
] | [
"O",
"A",
"B",
"P"
] | [
"scene.constraint.eq(scene.get_object('line_OA').length, scene.get_object('line_OP').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('O'), scene.get_object('P')), 90)"
] | {
"points": {
"O": [
-2.9305395809,
-4.0686703639
],
"A": [
-5.2666124079,
-1.2535487504
],
"B": [
0.6448892445000001,
-4.8422688748
],
"P": [
-0.11541796730000001,
-1.7325975362000001
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0045 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a parallelogram ABCD. There is a line segment AC. There is a line segment BD. There is a line segment EF. The parallelogram ABCD is similar to itself. Line segment AC is perpendicular to line segment BD. | 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)"
} | [
"similar(parallelogram1, parallelogram1)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
10,
10
],
"B": [
-10,
10
],
"C": [
-10,
-10
],
"D": [
10,
-10
],
"E": [
1.4043378938,
-7.7724802666
],
"F": [
-0.8809982156,
3.3372776598
]
},
"circles": {}
} |
1obj_2rel_2extra_gen0048 | Diagram description: The diagram contains points A, B, C, D, E. There is a major arc with center A, start point B, end point C. There is a line segment AD. There is a line segment BE. There is a line segment CD. Line AD intersects line BE at D. Point D lies on the major arc. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
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_CD = scene.add.line_segment(C, D)
### relationships
scene.relate.line... | {
"semicircle1": "major_arc(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CD": "line_segment(C, D)"
} | [
"lines_intersect_at(line_AD, line_BE, D)",
"point_lies_on(D, semicircle1)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
0.9207802149000001,
-0.2997657193
],
"B": [
1.1716982081,
0.5369711512
],
"C": [
1.5199970028,
-0.9353974238
],
"D": [
1.7743521708,
-0.4855164791
],
"E": [
1.8785471429,
-0.6622979640000001
]
},... |
1obj_2rel_2extra_gen0049 | Diagram description: The diagram contains points A, B, C, D, E. There is a kite with points A, B, C, D. There is a line segment AC. There is a line segment BD. There is a line segment BE. Line AC is perpendicular to line BD. Line BE is the angle bisector of angle ABD. Further, the length of line AC is equal to the leng... | 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)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_angle_bisector = scene.add.line_segment(B, E)
### relationships
scene.relate.... | {
"kite1": "kite(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_angle_bisector": "line_segment(B, E)"
} | [
"perpendicular(line_AC, line_BD)",
"angle_bisector(A, B, D, line_angle_bisector)"
] | [
"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('B'), scene.get_object('D')), 45)"
] | {
"points": {
"A": [
5.1595473273,
-5.4982267132
],
"B": [
-7.9952780128,
-5.3036719125000005
],
"C": [
-7.8007232196,
7.8511534408
],
"D": [
5.3541021759,
7.6565986677
],
"E": [
6.5399631409,
0.4667018391
]
},
"ci... |
1obj_2rel_2extra_gen0052 | Diagram description: The diagram contains points A, B, O, P, Q. There is a major arc with center O from A to B. There is a line segment PQ. There is a line segment AB. Line PQ intersects line AB at O. Point P lies on the major arc from A to B centered at O. Further, the radius of the major arc is 3.0. Further, the angl... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, O, P, Q = scene.add.points(["A", "B", "O", "P", "Q"])
semicircle1 = scene.add.major_arc(O, A, B)
line_perp = scene.add.line_segment(P, Q)
line_base = scene.add.line_segment(A, B)
### relationships
scene.relate.lines_intersect_at(line_perp, line_base... | {
"semicircle1": "major_arc(O, A, B)",
"line_perp": "line_segment(P, Q)",
"line_base": "line_segment(A, B)"
} | [
"lines_intersect_at(line_perp, line_base, O)",
"point_lies_on(P, semicircle1)"
] | [
"A",
"B",
"O",
"P",
"Q"
] | [
"scene.constraint.eq(scene.get_object('semicircle1').radius, 3.0)",
"scene.constraint.eq(scene.angle(scene.get_object('P'), scene.get_object('O'), scene.get_object('A')), 90)"
] | {
"points": {
"A": [
0.0547064773,
0.056472932600000005
],
"B": [
-5.583886873,
-1.994444971
],
"O": [
-2.7645901833,
-0.9689860431
],
"P": [
-1.7391312011000002,
-3.7882827151000003
],
"Q": [
-3.5930091636,
1.3085881153
... |
1obj_2rel_2extra_gen0053 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a kite with points 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 perpendicular to line BD. Line BD is parallel to line EF. | 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)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-7.177973658,
-3.3046535063
],
"B": [
-1.000365155,
4.5808002023
],
"C": [
-4.2676893396,
-4.8885091543
],
"D": [
-0.9046571195,
4.7566606567
],
"E": [
-7.2173034081,
-6.5729232866
],
"F": [
... |
1obj_2rel_2extra_gen0054 | Diagram description: The diagram contains points A, B, C, D, E, F, G.
There is an acute triangle ABC.
There is a line segment AD.
There is a line segment EF.
Line AD is an altitude of triangle ABC from vertex A.
The extensions of line AD and line EF intersect 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"])
triangleABC = scene.add.acute_triangle(A, B, C)
line_altitude_from_A = scene.add.line_segment(A, D)
line_perpendicular_bisector = scene.add.line_segment(E, F)
### relationships
sc... | {
"triangleABC": "acute_triangle(A, B, C)",
"line_altitude_from_A": "line_segment(A, D)",
"line_perpendicular_bisector": "line_segment(E, F)"
} | [
"is_altitude(line_altitude_from_A, triangleABC, A)",
"line_extensions_intersect_at(line_altitude_from_A, line_perpendicular_bisector, G)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-3.1771130146,
-2.3656549784
],
"B": [
5.7080745788,
3.5659294193
],
"C": [
9.0140154073,
8.015020248
],
"D": [
-0.2922758487,
-4.5092617244
],
"E": [
3.3698787704,
1.2852646125
],
"F": [
... |
1obj_2rel_2extra_gen0055 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a parallelogram 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. Further, length of line AC is equal to length of line BD and angle AEB is 90... | 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)"
} | [
"point_lies_on(E, line_AC)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"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": [
5.2489982195,
-7.1657497972
],
"B": [
5.7543663049,
7.248758807
],
"C": [
-8.6601422979,
7.7541268557
],
"D": [
-9.1655103966,
-6.660381761
],
"E": [
-1.7055720025,
0.294188486
],
"F": [
... |
1obj_2rel_2extra_gen0056 | Diagram description: The diagram contains points A, B, C, D, E. There is a triangle ABC. There is a line segment AD. There is a line segment DE. Line AD is an altitude of triangle ABC from vertex A. Line AD 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"])
triangleABC = scene.add.triangle(A, B, C)
line_altitude = scene.add.line_segment(A, D)
line_perpendicular = scene.add.line_segment(D, E)
### relationships
scene.relate.is_altitude(line_altitude, ... | {
"triangleABC": "Triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_perpendicular": "line_segment(D, E)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"perpendicular(line_altitude, line_perpendicular)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
-1.5343769103,
-0.3493698764
],
"B": [
6.9704654477,
-3.1615544442
],
"C": [
-5.6092272503,
-1.3116800024
],
"D": [
-1.759142786,
-1.8778443078
],
"E": [
-2.5096999124,
-1.7674730622000001
]
},
... |
1obj_2rel_2extra_gen0057 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a right trapezoid ABCD with AB parallel to CD and right angles at A and D. There are line segments AC, BD, and EF. Points A, E, and F are collinear. Lines AC and BD intersect at point G. Further, the length of line AC is equal to the length ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
trapezoidABCD = scene.add.right_trapezoid(A, B, C, D)
lineAC = scene.add.line_segment(A, C)
lineBD = scene.add.line_segment(B, D)
lineEF = scene.add.line_segment(E, F)
### relation... | {
"trapezoidABCD": "right_trapezoid(A, B, C, D)",
"lineAC": "line_segment(A, C)",
"lineBD": "line_segment(B, D)",
"lineEF": "line_segment(E, F)"
} | [
"collinear(A, E, F)",
"lines_intersect_at(lineAC, lineBD, G)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('lineAC').length, scene.get_object('lineBD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('G'), scene.get_object('B')), 90)"
] | {
"points": {
"A": [
0.5514263316,
0.8255626663000001
],
"B": [
0.0895879366,
-1.4327106629
],
"C": [
-2.1686849917,
-0.9708719933000001
],
"D": [
-1.7068467411000001,
1.2874008426999999
],
"E": [
0.20913137980000002,
0.28... |
1obj_2rel_2extra_gen0060 | Diagram description: The diagram contains points A, B, C, D, E. There is a triangle with vertices A, B, C. There are line segments AD, BE, and BC. AD is an altitude of triangle ABC from vertex A. AD and BE intersect at point A. Further, the length of line BC is equal to the length of line BE and angle ABD is a right an... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
triangleABC = scene.add.triangle(A, B, C)
line_altitude = scene.add.line_segment(A, D)
line_perpendicular = scene.add.line_segment(B, E)
line_base = scene.add.line_segment(B, C)
### relationships
... | {
"triangleABC": "triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_perpendicular": "line_segment(B, E)",
"line_base": "line_segment(B, C)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"lines_intersect_at(line_altitude, line_perpendicular, A)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_base').length, scene.get_object('line_perpendicular').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('D')), 90)"
] | {
"points": {
"A": [
4.4780806007,
-0.5711553746
],
"B": [
-9.9996869044,
8.600111178
],
"C": [
5.5015441583,
-0.9666369695
],
"D": [
4.5856260308,
-0.40138434970000003
],
"E": [
5.3883410295,
-1.1477754414
]
},
"c... |
1obj_2rel_2extra_gen0061 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a circle with center A. There is a line segment BC. There is a line segment DE. There is a line FG. Line BC intersects line DE at point H. Line BC is a chord of the circle. | 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"])
circle1 = scene.add.circle(A)
line1 = scene.add.line_segment(B, C)
line2 = scene.add.line_segment(D, E)
line3 = scene.add.line(F, G)
### relationships
scene.relate.lines_i... | {
"circle1": "circle(A)",
"line1": "line_segment(B, C)",
"line2": "line_segment(D, E)",
"line3": "line(F, G)"
} | [
"lines_intersect_at(line1, line2, H)",
"is_chord(line1, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
-1.3578057482,
-0.77808938
],
"B": [
-1.4592290667,
1.5206181226000002
],
"C": [
0.2642602509,
-2.4100344593000003
],
"D": [
-3.0447474902,
-1.9168789916
],
"E": [
-0.5716334375000001,
0.9984270667
... |
1obj_2rel_2extra_gen0064 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. 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 is an altitude of triangle ABC from vertex A. The extensions of line AD and line BE inter... | 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.equilateral_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)
lineG... | {
"triangleABC": "equilateral_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_altitude(lineAD, triangleABC, A)",
"line_extensions_intersect_at(lineAD, lineBE, F)",
"is_centroid(G, triangleABC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
1.7596249814,
4.3055139468
],
"B": [
-0.4148059103,
-2.9157842332
],
"C": [
-5.5814181526,
2.5779771866
],
"D": [
-2.9981119899,
-0.168903604
],
"E": [
-3.1944874108,
1.5471630702999999
],
"F":... |
1obj_2rel_2extra_gen0066 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is an obtuse triangle ABC with vertices A, B, C. There are line segments AD and EF. Line AD is an altitude of triangle ABC from vertex A. Point G is the centroid 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"])
triangleABC = scene.add.obtuse_triangle(A, B, C)
line_altitude_from_A = scene.add.line_segment(A, D)
line_perpendicular_bisector = scene.add.line_segment(E, F)
### relationships
s... | {
"triangleABC": "obtuse_triangle(A, B, C)",
"line_altitude_from_A": "line_segment(A, D)",
"line_perpendicular_bisector": "line_segment(E, F)"
} | [
"is_altitude(line_altitude_from_A, triangleABC, A)",
"is_centroid(G, triangleABC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-3.892280566,
2.1580609165
],
"B": [
4.4179808488,
-6.241084681
],
"C": [
-2.7144034488,
6.0429906856
],
"D": [
-1.3244134819,
3.6490168347000003
],
"E": [
-7.1725537102,
1.1037206811
],
"F": [... |
1obj_2rel_2extra_gen0067 | Diagram description: The diagram contains points A, B, C, D, O. There is an isosceles trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line CD. Line AC and line BD intersect at point O. Line CD is perpendicular to line AC. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, O = scene.add.points(["A", "B", "C", "D", "O"])
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_m = scene.add.line(C, D)
### relationships
scene.relate.l... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_m": "line(C, D)"
} | [
"lines_intersect_at(line_AC, line_BD, O)",
"perpendicular(line_m, line_AC)"
] | [
"A",
"B",
"C",
"D",
"O"
] | [] | {
"points": {
"A": [
-3.7681436608,
2.8591848183
],
"B": [
-2.7638581364,
4.128724458
],
"C": [
-2.2550246149,
1.6622127648
],
"D": [
-3.2593100866,
0.3926731107
],
"O": [
-3.0115841118,
2.2606988485
]
},
"circles"... |
1obj_2rel_2extra_gen0068 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is an acute 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 an altitude of triangle ABC from verte... | 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.acute_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 = sc... | {
"triangleABC": "acute_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_altitude(lineAD, triangleABC, A)",
"is_altitude(lineBE, triangleABC, B)",
"is_orthocenter(F, triangleABC)",
"mirror_across_line(lineAD, lineBE, lineGH)",
"congruent(lineAD, lineBE)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
4.9829981359,
-6.1546231085
],
"B": [
4.0827773732,
2.7016882286
],
"C": [
-1.1823755421,
-2.3074085437000003
],
"D": [
0.1326508817,
-1.056335134
],
"E": [
0.3574902739,
-3.2682901318
],
"F": ... |
1obj_2rel_2extra_gen0073 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a right triangle with vertices A, B, C. There is a line segment BD. There is a line segment CE. There is a line segment AF. Line BD is congruent to line CE. Line BD is an altitude of triangle ABC from vertex B. Further, length of line BD equals... | 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.right_triangle(A, B, C)
lineBD = scene.add.line_segment(B, D)
lineCE = scene.add.line_segment(C, E)
lineAF = scene.add.line_segment(A, F)
### relationships
scene.r... | {
"triangleABC": "right_triangle(A, B, C)",
"lineBD": "line_segment(B, D)",
"lineCE": "line_segment(C, E)",
"lineAF": "line_segment(A, F)"
} | [
"congruent(lineBD, lineCE)",
"is_altitude(lineBD, triangleABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('lineBD').length, scene.get_object('lineCE').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
0.9834981943000001,
-1.1293401673
],
"B": [
-1.8803338002,
-2.5508549621
],
"C": [
-2.8523570015,
-0.5925839966
],
"D": [
-1.6302403626,
-0.7635963796
],
"E": [
-4.5043276742,
-1.3191050579999999
]... |
1obj_2rel_2extra_gen0074 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a triangle ABC. There is a line segment AD. There is a line segment BE. There is a line BD. There is a line AE. Line AD is an altitude of triangle ABC from A. Line BE is a median of triangle ABC from B. Line BD and line AE intersect at point F. | 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_altitude = scene.add.line_segment(A, D)
line_median = scene.add.line_segment(B, E)
line_extension1 = scene.add.line(B, D)
line_extension2 = sc... | {
"triangleABC": "triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_median": "line_segment(B, E)",
"line_extension1": "line(B, D)",
"line_extension2": "line(A, E)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"is_median(line_median, triangleABC, B)",
"line_extensions_intersect_at(line_extension1, line_extension2, F)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
2.6412548366,
-6.3234683419
],
"B": [
2.8813619040000003,
-5.8450363136
],
"C": [
-4.9816116526,
3.2000899066
],
"D": [
3.0150103746,
-5.9985660505
],
"E": [
-1.1701897965,
-1.5617352493999999
],
... |
1obj_2rel_2extra_gen0077 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a parallelogram 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. | 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)"
} | [
"point_lies_on(E, line_AC)",
"perpendicular(line_AC, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-1.6541782591,
2.8617032118
],
"B": [
1.7918332855,
1.6218319943
],
"C": [
1.2540905301,
-2.0007511867
],
"D": [
-2.1919210122,
-0.7608799729
],
"E": [
-0.5795324653,
1.0649586412
],
"F": [
... |
1obj_2rel_2extra_gen0078 | Diagram description: The diagram contains points A, B, C, D, E. There is an isosceles trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line BC. A, D, and C are collinear. Line AC intersects line BD at E. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
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_m = scene.add.line(B, C)
### relationships
scene.relate.c... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_m": "line(B, C)"
} | [
"collinear(A, D, C)",
"lines_intersect_at(line_AC, line_BD, E)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
-8.7659824214,
8.7774858854
],
"B": [
-8.6215535051,
8.6338268526
],
"C": [
9.0839197843,
-9.5298931957
],
"D": [
8.9417196749,
-9.3840607931
],
"E": [
8.801983935700001,
-9.2407204151
]
},
"ci... |
1obj_2rel_2extra_gen0080 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is an obtuse triangle ABC. There is a line segment AD. There is a line segment BE. There is a line segment CF. Line AD intersects line BE at G. Line AD is an altitude of triangle ABC from vertex A. Line BE is an altitude of triangle ABC from ve... | 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.obtuse_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)
### relationsh... | {
"triangleABC": "obtuse_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"lines_intersect_at(line_AD, line_BE, G)",
"is_altitude(line_AD, triangleABC, A)",
"is_altitude(line_BE, triangleABC, B)",
"is_altitude(line_CF, triangleABC, C)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
1.3036899685,
0.5101539689
],
"B": [
5.5600749183,
0.1993367604
],
"C": [
1.5610516459000001,
-6.8462798311
],
"D": [
4.6563898684,
-1.3928062431
],
"E": [
1.3197538161,
0.050990672
],
"F": [
... |
1obj_2rel_2extra_gen0081 | Diagram description: The diagram contains points A, B, C, D, E, F, G. 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. Point G is the midpoint of line AC. Line AC is perpendicular to line BD. Further, the length of line AC is equal to the l... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
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
... | {
"rectangle1": "rectangle(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"is_midpoint(G, line_AC)",
"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.get_object('line_AC').slope, -1 * scene.get_object('line_BD').slope)"
] | {
"points": {
"A": [
-0.22982713100000002,
-0.2035700717
],
"B": [
-0.2298271436,
-0.9382734486000001
],
"C": [
-0.9645308753,
-0.9382735034
],
"D": [
-0.9645308661,
-0.20357012700000002
],
"E": [
-9.1603996208,
9.22165823... |
1obj_3rel_3extra_gen0003 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a triangle ABC. There is a triangle DEF. There is a line segment AD. There is a line segment BE. There is a line segment CF. Triangle ABC is similar to triangle DEF. Line AD is an altitude of triangle ABC from vertex A. Line BE is an altitude o... | 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.triangle(A, B, C)
triangle_DEF = scene.add.triangle(D, E, F)
line_AD = scene.add.line_segment(A, D)
line_BE = scene.add.line_segment(B, E)
line_CF = scene.add.line_... | {
"triangle_ABC": "triangle(A, B, C)",
"triangle_DEF": "triangle(D, E, F)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"similar(triangle_ABC, triangle_DEF)",
"is_altitude(line_AD, triangle_ABC, A)",
"is_altitude(line_BE, triangle_ABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.1920202553,
2.6170921332
],
"B": [
0.299881253,
1.9796931534
],
"C": [
0.4584092644,
6.7518428272
],
"D": [
0.320485521,
2.6000705797
],
"E": [
-0.2779751073,
2.0706017862
],
"F": [
4.... |
1obj_3rel_3extra_gen0011 | Diagram description: The diagram contains points A, B, C, D, E. There is a trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line segment AD. There is a line segment BC. There is a line segment CD. There is a line segment AB. Angle BAD is a right angle. Line AC is perpendicular to line ... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
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_AD = scene.add.line_segment(A, D)
line_BC = scene.add.line_... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)",
"line_CD": "line_segment(C, D)",
"line_AB": "line_segment(A, B)"
} | [
"right_angle(B, A, D)",
"perpendicular(line_AC, line_BD)",
"is_midpoint(E, line_AB)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_BC').length)",
"scene.constraint.leq(scene.get_object('line_AB').slope, 0)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-5.9399606849,
-3.5574396869
],
"B": [
6.3696256583,
-3.784253198
],
"C": [
6.5964392048,
8.5253331334
],
"D": [
-5.7131472152,
8.7521467011
],
"E": [
0.21483296600000001,
-3.6708463517
]
},
"c... |
1obj_3rel_3extra_gen0016 | 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 is a diameter of the circle with center A. Line BD is perpendicular to line AC. The extensions of lines BD and AC intersect at point A. | 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.is_diameter(line_BD, circle1)
scene.relate.perpendicular(line_BD... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"line_extensions_intersect_at(line_BD, line_AC, A)"
] | [
"A",
"B",
"C",
"D"
] | [] | {
"points": {
"A": [
0.1259773949,
1.0244163184
],
"B": [
1.2472113756,
-0.7275135515000001
],
"C": [
2.2557782763,
2.3874874996
],
"D": [
-0.9952565838,
2.776346187
]
},
"circles": {
"A": 2.0800057441
}
} |
1obj_3rel_3extra_gen0018 | 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. BD is a diameter of the circle. BD is perpendicular to line AC. The extension of line EF intersects the circle at points B and D. | 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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"line_extension_intersects_circle_at(line_EF, circle1, B, D)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
0.40957608170000004,
1.1133880178
],
"B": [
0.33697612990000003,
1.3373487638000001
],
"C": [
-1.438719546,
0.514238533
],
"D": [
0.4821757916,
0.8894272732
],
"E": [
1.634866232,
-2.6664720321
],
... |
1obj_3rel_3extra_gen0019 | Diagram description: The diagram contains points A, B, C, D, E. There is a right trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line segment AD. There is a line segment DC. Line segment AC intersects line segment BD at point E. Line segment AD is perpendicular to line segment DC. Ang... | 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)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_AD = scene.add.line_segment(A, D)
line_DC = scene.add.line_segm... | {
"trapezoid1": "right_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AD": "line_segment(A, D)",
"line_DC": "line_segment(D, C)"
} | [
"lines_intersect_at(line_AC, line_BD, E)",
"perpendicular(line_AD, line_DC)",
"right_angle(A, D, C)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_DC').length)",
"scene.constraint.leq(scene.get_object('line_AC').length, 2 * scene.get_object('line_AD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('D'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
4.5393798082,
-1.26420149
],
"B": [
1.9744083883,
-1.1784413642
],
"C": [
0.74960196,
2.7877660986
],
"D": [
4.6704746596,
2.6566712495
],
"E": [
3.0406278094,
0.3382393013
]
},
"circles": {}
} |
1obj_3rel_3extra_gen0020 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is an obtuse triangle with vertices A, B, C. There is a line segment AD. There is a line segment BE. There is a line segment CF. There is a line segment GH. H is the orthocenter of triangle ABC. Line AD is an altitude of triangle ABC from ve... | 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.obtuse_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... | {
"triangleABC": "obtuse_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)"
} | [
"is_orthocenter(H, triangleABC)",
"is_altitude(line_AD, triangleABC, A)",
"is_altitude(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, 20)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 120)"
] | {
"points": {
"A": [
-2.1550663831,
0.123279863
],
"B": [
-1.8817812048,
0.415448329
],
"C": [
7.4458038732,
-1.7529718678
],
"D": [
-2.0772864055,
0.4584183048
],
"E": [
-1.9473056678,
0.0802433397
],
"F": [
... |
1obj_3rel_3extra_gen0021 | Diagram description: The diagram contains points A, B, C, D, E, F. There is an isosceles triangle ABC with AB = BC. There is a line segment AD. There is a line segment BE. There is a line segment CF. There is a line segment BC. Line AD is a median of triangle ABC from vertex A. Line AD is perpendicular to line BC. Poin... | 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)
line_BC = scene.add.... | {
"triangleABC": "isosceles_triangle(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)",
"line_BC": "line_segment(B, C)"
} | [
"is_median(line_AD, triangleABC, A)",
"perpendicular(line_AD, line_BC)",
"is_orthocenter(E, triangleABC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.8956305262,
2.6635598095
],
"B": [
2.5558104244,
-0.32137724030000003
],
"C": [
-1.7549413914,
-1.8179442232
],
"D": [
0.40043448130000003,
-1.0696607402
],
"E": [
-0.0315871269,
0.1747461353
],... |
1obj_3rel_3extra_gen0024 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There are line segments BD, AC, and EF. Line BD is a diameter of the circle. Line BD is perpendicular to line AC. Line AC and line EF intersect at point A. | 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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"lines_intersect_at(line_AC, line_EF, A)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.5485227237,
-1.0346894954
],
"B": [
-0.0845876376,
-1.2987750743
],
"C": [
-1.5519083836,
-2.7973974814
],
"D": [
-1.0124577541,
-0.7706038687000001
],
"E": [
0.3348508691,
-0.5269812939
],
... |
1obj_3rel_3extra_gen0030 | 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 a diameter of the circle. Line BD is perpendicular to line AC. Angle EAF is acute. Further, the length of line AC is equal to... | 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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"acute_angle(E, A, F)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length / 2)",
"scene.constraint.leq(scene.get_object('line_EF').length, scene.get_object('circle1').diameter)",
"scene.constraint.eq(scene.angle(scene.get_object('E'), scene.get_object('A'), scene.get_object('F')), 30)"
] | {
"points": {
"A": [
1.5176638668,
0.15554127410000002
],
"B": [
-0.3172328795,
-0.9508798399
],
"C": [
2.6240850093,
-1.6793555143
],
"D": [
3.3525606262,
1.2619623912
],
"E": [
-0.0451553674,
-2.6414089041
],
"F"... |
1obj_3rel_3extra_gen0032 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There are line segments BD, AC, and EF. Line BD is a diameter of the circle. Line EF is a chord of the circle. Line BD intersects line AC at point A. | 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.lines_int... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"lines_intersect_at(line_BD, line_AC, A)",
"is_diameter(line_BD, circle1)",
"is_chord(line_EF, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
1.2163832529,
1.4482261931
],
"B": [
1.3065218409,
-0.3426391542
],
"C": [
4.8128911248,
2.3922965655
],
"D": [
1.1262446734,
3.2390915547
],
"E": [
2.4291322412,
0.1274069093
],
"F": [
0... |
1obj_3rel_3extra_gen0033 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a trapezoid ABCD. There are line segments AC, BD, EF. The trapezoid is similar to itself. Line AC is perpendicular to line BD. Point F is the midpoint of line BD. | 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)
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... | {
"trapezoid1": "trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_EF": "line_segment(E, F)"
} | [
"similar(trapezoid1, trapezoid1)",
"perpendicular(line_AC, line_BD)",
"is_midpoint(F, line_BD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.3501714083,
1.1245899666
],
"B": [
1.8570443254,
-0.9497362743000001
],
"C": [
0.5873216275,
1.2875603595
],
"D": [
1.6401160585999999,
0.2981513596
],
"E": [
-5.0659064712,
7.0850735119
],
... |
1obj_3rel_3extra_gen0035 | Diagram description: The diagram contains points A, B, C, D, E. There is a trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line segment AD. There is a line segment BC. The trapezoid ABCD is similar to itself. Line AC is perpendicular to line BD. Point E is the midpoint of line AD. Fur... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
trapezoid1 = scene.add.trapezoid(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_AD = scene.add.line_segment(A, D)
line_BC = scene.add.line_segment(B,... | {
"trapezoid1": "trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)"
} | [
"similar(trapezoid1, trapezoid1)",
"perpendicular(line_AC, line_BD)",
"is_midpoint(E, line_AD)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_BC').length)",
"scene.constraint.leq(scene.get_object('line_AC').length, 2 * scene.get_object('line_AD').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('D'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-7.8592932028,
-5.681808319
],
"B": [
-7.852173876,
9.9992373534
],
"C": [
7.832420655,
9.9992088226
],
"D": [
7.8252981323,
-5.688928873
],
"E": [
-0.016997159,
-5.6853687086
]
},
"circles": {... |
1obj_3rel_3extra_gen0036 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a triangle ABC. There is a line AD. There is a line BE. There is a line CF. AD is an altitude of triangle ABC from vertex A. BE is a median of triangle ABC from vertex B. AD and BE intersect at point G. Further, the length of line AD is equa... | 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)
line_altitude = scene.add.line_segment(A, D)
line_median = scene.add.line_segment(B, E)
line_perpendicular = scene.add.line_segment(C, F)
... | {
"triangleABC": "triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_median": "line_segment(B, E)",
"line_perpendicular": "line_segment(C, F)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"is_median(line_median, triangleABC, B)",
"lines_intersect_at(line_altitude, line_median, G)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('line_altitude').length, scene.get_object('line_median').length)",
"scene.constraint.leq(scene.get_object('line_perpendicular').length, 3.0)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('D'), scene.get_object('B')), 90)"
] | {
"points": {
"A": [
2.3009798974,
-2.4015492968
],
"B": [
-4.0064353151,
-3.0711846915
],
"C": [
-1.3975784644,
1.9872705798
],
"D": [
-2.4084240325,
0.027287018700000002
],
"E": [
0.45170076600000003,
-0.2071393961
]... |
1obj_3rel_3extra_gen0037 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There are line segments BD, AC, and EF. Line BD is a diameter of the circle. Line BD is perpendicular to line AC. Line AC is parallel to line EF. | 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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"parallel(line_AC, line_EF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
0.8643293947,
-4.4681541476
],
"B": [
0.1485845108,
-4.7188866943
],
"C": [
0.3675119683,
-3.0499316857
],
"D": [
1.5800742844,
-4.2174216131
],
"E": [
-6.1665127841,
4.2700071881
],
"F": [
... |
1obj_3rel_3extra_gen0041 | Diagram description: The diagram contains points A, B, C, D, E. There is a rhomboid ABCD. There are line segments AC, BD, and BE. Line AC is perpendicular to line BD. Line BE is the bisector of angle ABD. Point E lies on line AC. Further, the length of line AC is equal to twice the length of line BD. Further, the lengt... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
rhomboid1 = scene.add.rhomboid(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_angle_bisector = scene.add.line_segment(B, E)
### relationships
scene... | {
"rhomboid1": "rhomboid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_angle_bisector": "line_segment(B, E)"
} | [
"perpendicular(line_AC, line_BD)",
"angle_bisector(A, B, D, line_angle_bisector)",
"point_lies_on(E, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, 2 * scene.get_object('line_BD').length)",
"scene.constraint.leq(scene.get_object('line_angle_bisector').length, scene.get_object('line_AC').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('D')), 60... | {
"points": {
"A": [
0.7381139955,
-0.3517383651
],
"B": [
0.4194180374,
-0.1594158268
],
"C": [
0.0690414855,
-0.3128852793
],
"D": [
0.4129105839,
-0.4953695289
],
"E": [
0.5171688777,
-0.3365616953
]
},
"circles... |
1obj_3rel_3extra_gen0042 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a triangle with points 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. Line BE is a median of triangle ABC from vertex B. Line AD and line BE ... | 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)
line_altitude = scene.add.line_segment(A, D)
line_median = scene.add.line_segment(B, E)
line_perpendicular = scene.add.line_segment(C, F)
... | {
"triangleABC": "triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_median": "line_segment(B, E)",
"line_perpendicular": "line_segment(C, F)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"is_median(line_median, triangleABC, B)",
"lines_intersect_at(line_altitude, line_median, G)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
1.1637009937,
1.1920933494
],
"B": [
-0.4260121408,
-0.7276755111000001
],
"C": [
8.9094366488,
-3.6154132318
],
"D": [
0.482889785,
-1.0088263998
],
"E": [
5.0365689216,
-1.2116599117
],
"F": ... |
1obj_3rel_3extra_gen0048 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There are line segments BD, AC, and EF. Line BD is a diameter of the circle. Line BD is perpendicular to line AC. Points E, F, and A are collinear. | 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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"collinear(E, F, A)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.7324695742,
3.2583023442
],
"B": [
-2.0828230611,
4.8589050399
],
"C": [
0.0671929519,
3.9329401707000002
],
"D": [
0.6178839408,
1.6576996871
],
"E": [
2.1947042342,
-2.8452075682
],
"F": [... |
1obj_3rel_3extra_gen0052 | Diagram description: The diagram contains points A, B, C, D, E. 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 CD. Line AD is perpendicular to line BE. Point D lies on the major arc. Point E is the midpoint of line CD. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
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_CD = scene.add.line_segment(C, D)
### relationships
scene.relate.perp... | {
"semicircle1": "major_arc(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CD": "line_segment(C, D)"
} | [
"perpendicular(line_AD, line_BE)",
"point_lies_on(D, semicircle1)",
"is_midpoint(E, line_CD)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
1.2820531674,
-3.4203475764
],
"B": [
0.16160448700000002,
-4.0524949134
],
"C": [
1.1538915086000001,
-2.140273322
],
"D": [
0.0505701629,
-3.0482385658
],
"E": [
0.6022308342,
-2.5942559353
]
}... |
1obj_3rel_3extra_gen0054 | 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 FG. Line AD is an altitude of triangle ABC from vertex A. Line BE is a median of triangle ABC from vertex B. Point H is the orthocenter of tri... | 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_altitude = scene.add.line_segment(A, D)
line_median = scene.add.line_segment(B, E)
line_perp_bisector = scene.add.line_segment... | {
"triangleABC": "triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_median": "line_segment(B, E)",
"line_perp_bisector": "line_segment(F, G)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"is_median(line_median, triangleABC, B)",
"is_orthocenter(H, triangleABC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
-6.3367129719,
-7.4734137781
],
"B": [
3.8830203770000002,
-5.5472878096
],
"C": [
-4.2519486843,
6.586541882
],
"D": [
1.6047785708,
-2.1491435964
],
"E": [
-5.2943307947000005,
-0.4434359999
],
... |
1obj_3rel_3extra_gen0055 | 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 a diameter of the circle. Line BD is perpendicular to line AC. Line BD is congruent to line EF. | 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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"congruent(line_BD, line_EF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-1.8539636312,
2.1508662307
],
"B": [
-1.5688692728,
2.5154866873
],
"C": [
-2.8004176399,
2.8908924664
],
"D": [
-2.1390579687,
1.7862458044
],
"E": [
-0.44283171200000004,
5.8971231185
],
"F"... |
1obj_3rel_3extra_gen0057 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is an acute triangle with vertices A, B, C. There is a line segment AD. There is a line segment BE. There is a line segment FG. AD is an altitude of triangle ABC from vertex A. BE is a median of triangle ABC from vertex B. AD is perpendicular t... | 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.acute_triangle(A, B, C)
line_altitude = scene.add.line_segment(A, D)
line_median = scene.add.line_segment(B, E)
line_perp_bisector = scene.add.line_segment(F... | {
"triangleABC": "acute_triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_median": "line_segment(B, E)",
"line_perp_bisector": "line_segment(F, G)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"is_median(line_median, triangleABC, B)",
"perpendicular(line_altitude, line_median)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-3.6256902256,
-0.7452555308000001
],
"B": [
9.3542557881,
8.234075539100001
],
"C": [
-7.2319557613,
-3.553535124
],
"D": [
-3.5107317072,
-0.9089196299000001
],
"E": [
-5.4288234742,
-2.149400616
... |
1obj_3rel_3extra_gen0060 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is an obtuse triangle ABC. There is a line segment AD. There is a line segment EF. There is a line segment BC. There is a line BC. There is a line DE. Line AD is an altitude of triangle ABC from vertex A. Line EF is the perpendicular bisector o... | 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.obtuse_triangle(A, B, C)
line_altitude_from_A = scene.add.line_segment(A, D)
line_perpendicular_bisector = scene.add.line_segment(E, F)
line_BC = scene.add.l... | {
"triangleABC": "obtuse_triangle(A, B, C)",
"line_altitude_from_A": "line_segment(A, D)",
"line_perpendicular_bisector": "line_segment(E, F)",
"line_BC": "line_segment(B, C)",
"line_extension1": "line(B, C)",
"line_extension2": "line(D, E)"
} | [
"is_altitude(line_altitude_from_A, triangleABC, A)",
"perpendicular_bisector_at(line_BC, line_perpendicular_bisector)",
"line_extensions_intersect_at(line_extension1, line_extension2, G)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [] | {
"points": {
"A": [
-8.0389326231,
3.873236731
],
"B": [
6.9219924919,
-5.8794725492
],
"C": [
-6.1844251732,
6.7660312199
],
"D": [
-5.7003680374,
6.2971422845
],
"E": [
6.542336296,
-5.6521160279
],
"F": [
... |
1obj_3rel_3extra_gen0061 | 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 a diameter of the circle. Line BD is perpendicular to line AC. Line AC and line EF intersect at point A. Further, the area of... | 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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"lines_intersect_at(line_AC, line_EF, A)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('circle1').area, 16 * 3.14159)",
"scene.constraint.leq(scene.get_object('line_EF').length, scene.get_object('line_AC').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('E')), 90)"
] | {
"points": {
"A": [
-0.6193202574000001,
2.1802224119
],
"B": [
1.1644568208,
5.760463411
],
"C": [
5.0674491549,
-0.6530865378
],
"D": [
-2.4030973311,
-1.4000185751
],
"E": [
2.7348922161,
0.5090591297
],
"F": [... |
1obj_3rel_3extra_gen0063 | Diagram description: The diagram contains points A, B, C, D, E. 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 DE. The line segment DE is the angle bisector of angle ADC. The line segments AC and BD are perpendicular. Point E is the midpoint of line... | 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)
line_angle_bisector = scene.add.line_segment(D, E)
### relationships
sce... | {
"rectangle1": "rectangle(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_angle_bisector": "line_segment(D, E)"
} | [
"angle_bisector(A, D, C, line_angle_bisector)",
"perpendicular(line_AC, line_BD)",
"is_midpoint(E, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.leq(scene.get_object('rectangle1').area, 20)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('D'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
2.8535550897,
1.4584072253
],
"B": [
-1.325900608,
1.6718554080999999
],
"C": [
-1.5393487899,
-2.5076003185999998
],
"D": [
2.6401069012000002,
-2.7210485042
],
"E": [
0.6571029319,
-0.5245963291
... |
1obj_3rel_3extra_gen0066 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a major arc with center A and endpoints B and C. There is a line segment DE. There is a line segment CF. There is a line segment GH. Line DE and line CF intersect at point G, and their extensions meet at G. Point D lies on the major arc. ... | 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"])
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)
line_GH = scene.add.line_segment(G, H)
### relations... | {
"major_arc1": "major_arc(A, B, C)",
"line_DE": "line_segment(D, E)",
"line_CF": "line_segment(C, F)",
"line_GH": "line_segment(G, H)"
} | [
"line_extensions_intersect_at(line_DE, line_CF, G)",
"point_lies_on(D, major_arc1)",
"point_lies_on(F, major_arc1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('line_DE').length, scene.get_object('line_CF').length)",
"scene.constraint.leq(scene.get_object('major_arc1').inscribed_angle, 90)",
"scene.constraint.eq(scene.angle(scene.get_object('D'), scene.get_object('A'), scene.get_object('F')), 60)"
] | {
"points": {
"A": [
-1.1333477149,
2.3832128696
],
"B": [
-3.112159621,
3.4671150477
],
"C": [
0.8323498379000001,
1.2753686149
],
"D": [
1.0531212297,
2.940252022
],
"E": [
-0.8238064528,
-0.0702894096
],
"F": [
... |
1obj_3rel_3extra_gen0069 | Diagram description: The diagram contains points A, B, C, D, E. There is a right trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line segment AD. There is a line segment BC. There is a line segment AB. Line AB is rotated 90 degrees counterclockwise around point A to align with line AD... | 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)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_AD = scene.add.line_segment(A, D)
line_BC = scene.add.line_segm... | {
"trapezoid1": "right_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)",
"line_AB": "line_segment(A, B)"
} | [
"rotation_around_point(line_AB, line_AD, A, 90)",
"perpendicular(line_AC, line_BD)",
"is_midpoint(E, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
-2.7437361274,
2.1924975115
],
"B": [
-2.959119602,
2.5909386415
],
"C": [
-2.5606784787,
2.8063219802
],
"D": [
-2.3452950538,
2.4078810176
],
"E": [
-2.6522073094,
2.4994097192
]
},
"circles"... |
1obj_3rel_3extra_gen0073 | Diagram description: The diagram contains points A, B, C, D, E. There is a circle with center A. There are line segments BD, AC, and ED. Line BD is a diameter of the circle. Line BD is perpendicular to line AC. Angle EDB is a right angle. | 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)
line_BD = scene.add.line_segment(B, D)
line_AC = scene.add.line_segment(A, C)
line_ED = scene.add.line_segment(E, D)
### relationships
scene.relate.is_diameter(line_... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_ED": "line_segment(E, D)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"right_angle(E, D, B)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
-3.3118922312,
-3.2252300258
],
"B": [
-2.8257786091,
-4.6168019746999995
],
"C": [
-0.5529320657,
-2.2614507858
],
"D": [
-3.7980058556,
-1.833658118
],
"E": [
-2.8201210452,
-1.4920565518
]
},
... |
1obj_3rel_3extra_gen0076 | 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 a diameter of the circle. Line BD is perpendicular to line AC. Line BD is congruent to line EF. | 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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"congruent(line_BD, line_EF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.09837722700000001,
1.1415161998
],
"B": [
-0.9025045278,
0.9388405558
],
"C": [
-0.48616343,
2.6800802671
],
"D": [
0.7057500913,
1.3441918591
],
"E": [
1.5949081183,
6.2704600402
],
"F": [
... |
1obj_3rel_3extra_gen0078 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a triangle ABC. There is a line AD. There is a line BE. There is a line CF. There is a line GH. Angle ABC is acute. Line AD is an altitude of triangle ABC from vertex A. Line BE is the mirror image of line CF across line GH. Further, the ... | 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"])
triangle_ABC = scene.add.equilateral_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)
l... | {
"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)"
} | [
"acute_angle(A, B, C)",
"is_altitude(line_AD, triangle_ABC, A)",
"mirror_across_line(line_BE, line_CF, line_GH)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [
"scene.constraint.eq(scene.get_object('triangle_ABC').circumradius, 2.0)",
"scene.constraint.leq(scene.get_object('line_BE').length, scene.get_object('line_CF').length)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 60)"
] | {
"points": {
"A": [
-3.3861980437,
-0.42061790600000004
],
"B": [
0.0298679827,
-0.9955034046000001
],
"C": [
-1.1803000509000001,
2.2503405097
],
"D": [
-0.5752171824,
0.6274176228
],
"E": [
-0.9523579938000001,
8.770421... |
1obj_3rel_3extra_gen0082 | 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 a diameter of the circle. Line BD is perpendicular to line AC. Point E 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)
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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"point_lies_on(E, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
0.4985103581,
0.1995684868
],
"B": [
0.34328166190000003,
0.34659329850000004
],
"C": [
2.1175895655,
1.9089898822
],
"D": [
0.6537388195,
0.0525436347
],
"E": [
0.7059851336,
0.2512070996
],
"... |
1obj_3rel_3extra_gen0084 | Diagram description: The diagram contains points A, B, C, D, M, N. There is an isosceles trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line segment MN. M is the midpoint of line AC. line AC is perpendicular to line BD. line MN is parallel to line AC. Further, length of line AC is eq... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, M, N = scene.add.points(["A", "B", "C", "D", "M", "N"])
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_MN = scene.add.line_segment(M, N)
### relationship... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_MN": "line_segment(M, N)"
} | [
"is_midpoint(M, line_AC)",
"perpendicular(line_AC, line_BD)",
"parallel(line_MN, line_AC)"
] | [
"A",
"B",
"C",
"D",
"M",
"N"
] | [
"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('M'), scene.get_object('B')), 90)"
] | {
"points": {
"A": [
0.5159749034000001,
1.1585269735
],
"B": [
2.7143586055,
0.1737048242
],
"C": [
1.7295357173,
-2.024676362
],
"D": [
-0.4688446827,
-1.0398554669
],
"M": [
1.122755948,
-0.43307607670000003
],
... |
1obj_3rel_3extra_gen0087 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is a major arc with center A from B to C. There are line segments DE, CF, and AG. The extensions of line DE and line CF intersect at point G. Point D lies on the major arc with center A from B to C. Point F lies on the major arc with center A f... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, G = scene.add.points(["A", "B", "C", "D", "E", "F", "G"])
arc1 = scene.add.major_arc(A, B, C)
line_DE = scene.add.line_segment(D, E)
line_CF = scene.add.line_segment(C, F)
line_AG = scene.add.line_segment(A, G)
### relationships
scene.re... | {
"arc1": "major_arc(A, B, C)",
"line_DE": "line_segment(D, E)",
"line_CF": "line_segment(C, F)",
"line_AG": "line_segment(A, G)"
} | [
"line_extensions_intersect_at(line_DE, line_CF, G)",
"point_lies_on(D, arc1)",
"point_lies_on(F, arc1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('line_AG').length, scene.get_object('line_DE').length)",
"scene.constraint.leq(scene.get_object('line_CF').length, scene.get_object('line_AG').length)",
"scene.constraint.eq(scene.angle(scene.get_object('D'), scene.get_object('G'), scene.get_object('F')), 90)"
] | {
"points": {
"A": [
-1.235563008,
0.8697489579000001
],
"B": [
-3.4264470598,
2.1693624097
],
"C": [
1.1420249341,
-0.044603962000000004
],
"D": [
-2.6398230017,
2.9950783806
],
"E": [
0.3248605725,
2.2483934007
],
... |
1obj_3rel_3extra_gen0093 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There are line segments BD, AC, and EF. Line BD is a diameter of the circle. Point B lies on the circle. Line BD is perpendicular to line AC. Further, length of line AC is equal to half the length of line BD. Further, le... | 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.point_lie... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"point_lies_on(B, circle1)",
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length / 2)",
"scene.constraint.leq(scene.get_object('line_EF').length, scene.get_object('line_AC').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
-1.0520906232,
2.0514032097
],
"B": [
1.0269351173,
-1.3027295947
],
"C": [
-4.4062234721,
-0.0276225584
],
"D": [
-3.1311163599,
5.4055360163
],
"E": [
0.0536975206,
-4.1076257252
],
"F": [
... |
1obj_3rel_3extra_gen0096 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a major arc with center A and endpoints B and C. There is a line segment DE. There is a line segment CF. There is a line segment GH. Point D lies on the major arc with center A and endpoints B and C. Point F lies on the major arc with cen... | 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"])
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)
line_GH = scene.add.line_segment(G, H)
### relations... | {
"major_arc1": "major_arc(A, B, C)",
"line_DE": "line_segment(D, E)",
"line_CF": "line_segment(C, F)",
"line_GH": "line_segment(G, H)"
} | [
"line_extensions_intersect_at(line_DE, line_CF, G)",
"point_lies_on(D, major_arc1)",
"point_lies_on(F, major_arc1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
1.1853029017,
-0.5724215782000001
],
"B": [
2.0206091373,
-0.5818584170000001
],
"C": [
1.2464858684,
-1.4055375433
],
"D": [
1.4656062917,
-1.3593495015000001
],
"E": [
6.7062190091,
3.6448204617
... |
1obj_3rel_3extra_gen0097 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a triangle with vertices A, B, C. There is a line segment AD. There is a line segment EF. There is a line segment BG. Line AD is an altitude of triangle ABC from vertex A. Point H is the orthocenter of triangle ABC. Line BG is a median of... | 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_altitude_from_A = scene.add.line_segment(A, D)
line_perpendicular_bisector = scene.add.line_segment(E, F)
line_median_from_B =... | {
"triangleABC": "triangle(A, B, C)",
"line_altitude_from_A": "line_segment(A, D)",
"line_perpendicular_bisector": "line_segment(E, F)",
"line_median_from_B": "line_segment(B, G)"
} | [
"is_altitude(line_altitude_from_A, triangleABC, A)",
"is_orthocenter(H, triangleABC)",
"is_median(line_median_from_B, triangleABC, B)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
-4.6692720979,
7.3587999899
],
"B": [
9.0930637778,
6.5818500413
],
"C": [
-1.5426110169,
-9.8044184633
],
"D": [
5.3686034191,
0.8436144179
],
"E": [
-2.2864825959,
-2.571094783
],
"F": [
... |
1obj_3rel_3extra_gen0100 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There are line segments BD, AC, EF. line BD is a chord of the circle. line BD is perpendicular to line AC. point E lies on the circle. Further, the area of the circle is 16π. Further, the length of line BD is less than o... | 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.is_chord(... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_chord(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"point_lies_on(E, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('circle1').area, 16 * 3.14159)",
"scene.constraint.leq(scene.get_object('line_BD').length, scene.get_object('line_AC').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
0.3980049943,
-0.9815660180000001
],
"B": [
3.5237179580999998,
-3.4775437771
],
"C": [
-5.2278824203,
-8.0268648776
],
"D": [
-2.7277079683,
1.5144117337
],
"E": [
0.8891619746,
2.9881633492
],
... |
1obj_3rel_3extra_gen0102 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is an isosceles triangle ABC with vertices A, B, C. There is a line segment AD. There is a line segment BE. There is a line segment CF. There is a line segment GH. H is the orthocenter of triangle ABC. AD is an altitude of triangle ABC from ... | 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.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)
line... | {
"triangleABC": "isosceles_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)"
} | [
"is_orthocenter(H, triangleABC)",
"is_altitude(line_AD, triangleABC, A)",
"perpendicular(line_BE, line_CF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
3.0823773653,
2.0759362615
],
"B": [
2.1862103089,
-0.5191209727
],
"C": [
1.399112281,
2.1110718352
],
"D": [
1.5471148711,
1.6165014853000002
],
"E": [
0.9349647701,
1.2064176015
],
"F": [
... |
1obj_3rel_3extra_gen0103 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a minor arc BC with center A. 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. Point D lies on arc BC. Point E is the midpoint of line AD. | 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)
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.relate.per... | {
"arc1": "minor_arc(A, B, C)",
"line_AD": "line_segment(A, D)",
"line_BE": "line_segment(B, E)",
"line_CF": "line_segment(C, F)"
} | [
"perpendicular(line_AD, line_BE)",
"point_lies_on(D, arc1)",
"is_midpoint(E, line_AD)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
3.3236290329,
-1.8635164218
],
"B": [
3.7104141879,
-1.7514263131
],
"C": [
2.9273287947,
-1.9350221724
],
"D": [
3.4199488424,
-1.4725056424
],
"E": [
3.3717889723,
-1.6680109644
],
"F": [
... |
1obj_3rel_3extra_gen0104 | Diagram description: The diagram contains points A, B, C, D, E, F, H. There is an obtuse 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 an altitude of triangle ABC from vertex B. Point H is the orthocente... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E, F, H = scene.add.points(["A", "B", "C", "D", "E", "F", "H"])
triangleABC = scene.add.obtuse_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)
### relationsh... | {
"triangleABC": "obtuse_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)",
"is_altitude(line_BE, triangleABC, B)",
"is_orthocenter(H, triangleABC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"H"
] | [
"scene.constraint.eq(scene.get_object('line_AD').length, scene.get_object('line_BE').length)",
"scene.constraint.leq(scene.get_object('triangleABC').area, 20.0)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('C')), 120)"
] | {
"points": {
"A": [
-3.214634044,
1.4398415346
],
"B": [
-2.8142090787000003,
1.4321778936
],
"C": [
2.7006923867,
-8.5565954901
],
"D": [
-2.9128113446,
1.6064920461
],
"E": [
-3.109409862,
1.2580281453
],
"F": [... |
1obj_3rel_3extra_gen0106 | Diagram description: The diagram contains points A, B, C, D, E. There is an isosceles trapezoid ABCD. There is a line segment AC. There is a line segment BD. There is a line segment AD. There is a line segment BC. Angle ADC is obtuse. Line AC is perpendicular to line BD. Point E is the midpoint of line AC. Further, the... | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
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_AD = scene.add.line_segment(A, D)
line_BC = scene.add.line_... | {
"trapezoid1": "isosceles_trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_AD": "line_segment(A, D)",
"line_BC": "line_segment(B, C)"
} | [
"obtuse_angle(A, D, C)",
"perpendicular(line_AC, line_BD)",
"is_midpoint(E, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length)",
"scene.constraint.leq(scene.get_object('trapezoid1').area, 20.0)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('D'), scene.get_object('C')), 120)"
] | {
"points": {
"A": [
0.8087009568,
3.6143224197
],
"B": [
-2.1566138237,
-1.7799608574999999
],
"C": [
2.3486052264,
-1.6854511892000001
],
"D": [
3.1431592257,
-0.2400566988
],
"E": [
1.5786542811,
0.9644359855
]
},... |
1obj_3rel_3extra_gen0108 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H. There is a major arc with center A and endpoints B and C. There is a line segment DE. There is a line segment CF. There is a line segment GH. Line DE intersects line CF at point C. Point D lies on the major arc. Line DE is perpendicular to line GH... | 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"])
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)
line_GH = scene.add.line_segment(G, H)
### relations... | {
"major_arc1": "major_arc(A, B, C)",
"line_DE": "line_segment(D, E)",
"line_CF": "line_segment(C, F)",
"line_GH": "line_segment(G, H)"
} | [
"lines_intersect_at(line_DE, line_CF, C)",
"point_lies_on(D, major_arc1)",
"perpendicular(line_DE, line_GH)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H"
] | [] | {
"points": {
"A": [
1.0384452185,
0.5165376220000001
],
"B": [
0.768183248,
0.7324828346000001
],
"C": [
1.2502064384,
0.24298492330000002
],
"D": [
1.3666781721,
0.4072811685
],
"E": [
0.4261663283,
-0.9194146666
],
... |
1obj_3rel_3extra_gen0110 | Diagram description: The diagram contains points A, B, C, D, E. 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 AC. Line AD is an altitude of triangle ABC from vertex A. Line BE is a median of triangle ABC from vertex B. Point E lies on line AC. | from pygeox import GeoScene
scene = GeoScene()
### objects
A, B, C, D, E = scene.add.points(["A", "B", "C", "D", "E"])
triangleABC = scene.add.triangle(A, B, C)
line_altitude = scene.add.line_segment(A, D)
line_median = scene.add.line_segment(B, E)
line_AC = scene.add.line_segment(A, C)
### relationships
scene.re... | {
"triangleABC": "triangle(A, B, C)",
"line_altitude": "line_segment(A, D)",
"line_median": "line_segment(B, E)",
"line_AC": "line_segment(A, C)"
} | [
"is_altitude(line_altitude, triangleABC, A)",
"is_median(line_median, triangleABC, B)",
"point_lies_on(E, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E"
] | [] | {
"points": {
"A": [
0.9809562907,
-2.8970794437
],
"B": [
10,
7.8300649489000005
],
"C": [
1.1711678185,
-2.3689425849
],
"D": [
0.8283443205000001,
-2.7649699777
],
"E": [
1.076062052,
-2.6330110203
]
},
"circles... |
1obj_3rel_3extra_gen0113 | Diagram description: The diagram contains points A, B, C, D, E, F, G. There is an acute triangle ABC. There is a line segment AD. There is a line segment EF. There is a line segment BG. There is a line segment BC. The line AD is an altitude of triangle ABC from vertex A. The line EF 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"])
triangleABC = scene.add.acute_triangle(A, B, C)
line_altitude_from_A = scene.add.line_segment(A, D)
line_perpendicular_bisector = scene.add.line_segment(E, F)
line_median_from_B = s... | {
"triangleABC": "acute_triangle(A, B, C)",
"line_altitude_from_A": "line_segment(A, D)",
"line_perpendicular_bisector": "line_segment(E, F)",
"line_median_from_B": "line_segment(B, G)",
"line_BC": "line_segment(B, C)"
} | [
"is_altitude(line_altitude_from_A, triangleABC, A)",
"perpendicular_bisector_at(line_BC, line_perpendicular_bisector)",
"collinear(A, D, E)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G"
] | [
"scene.constraint.eq(scene.get_object('line_altitude_from_A').length, scene.get_object('line_median_from_B').length)",
"scene.constraint.leq(scene.get_object('triangleABC').area, 12.0)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 60)"
] | {
"points": {
"A": [
-1.928833636,
-2.4018421402
],
"B": [
3.228106458,
-1.5871358371
],
"C": [
-0.3508099132,
1.7042369806000002
],
"D": [
0.8401080967000001,
0.6090019307
],
"E": [
1.3118188315000001,
1.1219225894
],... |
1obj_3rel_3extra_gen0115 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a trapezoid ABCD. There are line segments AC, BD, and CE. Line CE bisects the angle ACB. Line AC and line BD intersect at point F. Line CE is perpendicular to 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.trapezoid(A, B, C, D)
line_AC = scene.add.line_segment(A, C)
line_BD = scene.add.line_segment(B, D)
line_angle_bisector = scene.add.line_segment(C, E)
### relationsh... | {
"trapezoid1": "trapezoid(A, B, C, D)",
"line_AC": "line_segment(A, C)",
"line_BD": "line_segment(B, D)",
"line_angle_bisector": "line_segment(C, E)"
} | [
"angle_bisector(A, C, B, line_angle_bisector)",
"lines_intersect_at(line_AC, line_BD, F)",
"perpendicular(line_angle_bisector, line_AC)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
2.8754515309,
6.9623745434
],
"B": [
2.8063638971,
6.6999419075
],
"C": [
-0.25608072400000004,
-4.9656668312
],
"D": [
1.7978014137,
2.8327717814
],
"E": [
2.6726534697,
-5.7345627583
],
"F": ... |
1obj_3rel_3extra_gen0116 | 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 a diameter of the circle. Line BD is perpendicular to line AC. Line AC is parallel to line EF. 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"])
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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"parallel(line_AC, line_EF)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_AC').length, scene.get_object('line_BD').length / 2)",
"scene.constraint.leq(scene.get_object('line_EF').length, scene.get_object('line_AC').length)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 90)"
] | {
"points": {
"A": [
0.4216390317,
0.5037472698000001
],
"B": [
2.371650877,
3.393805047
],
"C": [
-2.4684189783,
2.4537592699
],
"D": [
-1.5283728072,
-2.3863104674
],
"E": [
-4.9643126104,
-4.0467662012
],
"F": [... |
1obj_3rel_3extra_gen0117 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a circle with center A. There are line segments BD, AC, and EF. Line BD is a diameter of the circle. Line BD is perpendicular to line AC. Points E, F, and A are collinear. | 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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"collinear(E, F, A)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
1.686072932,
2.0932061392
],
"B": [
1.8783146166,
2.2578069276
],
"C": [
2.1236976759,
1.5820922327
],
"D": [
1.49383121,
1.9286054803
],
"E": [
-0.5574478702,
2.5543767519
],
"F": [
0.68... |
1obj_3rel_3extra_gen0118 | Diagram description: The diagram contains points A, B, C, D, E, F, G, H, I. 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 AG. There is a line segment BH. There is a line segment CI. There is a line BC. Line AD is an altitude from ver... | 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"])
triangleABC = scene.add.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)
lineAG = ... | {
"triangleABC": "triangle(A, B, C)",
"lineAD": "line_segment(A, D)",
"lineBE": "line_segment(B, E)",
"lineCF": "line_segment(C, F)",
"lineAG": "line_segment(A, G)",
"lineBH": "line_segment(B, H)",
"lineCI": "line_segment(C, I)",
"line_L": "line(B, C)"
} | [
"is_altitude(lineAD, triangleABC, A)",
"is_altitude(lineBE, triangleABC, B)",
"angle_bisector(C, A, B, lineAG)"
] | [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I"
] | [
"scene.constraint.eq(scene.get_object('lineAD').length, scene.get_object('lineBE').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": [
-1.1792954502,
-2.524257505
],
"B": [
-0.4599592027,
1.2314636017
],
"C": [
2.4329225932,
-1.2693604139999999
],
"D": [
0.9864826723000001,
-0.0189486095
],
"E": [
0.6268142335,
-1.8968095152000002
... |
1obj_3rel_3extra_gen0121 | Diagram description: The diagram contains points A, B, C, D, E, F. There is a scalene triangle ABC. There are line segments AD, BE, and DF. Line AD is an altitude of triangle ABC from vertex A. Line BE is a median of triangle ABC from vertex B. Angle BAC is acute. Further, length of line AD is equal to length of line B... | 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_altitude_from_A = scene.add.line_segment(A, D)
line_median_from_B = scene.add.line_segment(B, E)
line_perpendicular_bisector = scene.a... | {
"triangleABC": "scalene_triangle(A, B, C)",
"line_altitude_from_A": "line_segment(A, D)",
"line_median_from_B": "line_segment(B, E)",
"line_perpendicular_bisector": "line(D, F)"
} | [
"is_altitude(line_altitude_from_A, triangleABC, A)",
"is_median(line_median_from_B, triangleABC, B)",
"acute_angle(B, A, C)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [
"scene.constraint.eq(scene.get_object('line_altitude_from_A').length, scene.get_object('line_median_from_B').length)",
"scene.constraint.leq(scene.get_object('line_perpendicular_bisector').slope, 0)",
"scene.constraint.eq(scene.angle(scene.get_object('B'), scene.get_object('A'), scene.get_object('C')), 60)"
] | {
"points": {
"A": [
1.7110382882000001,
0.2337094069
],
"B": [
3.7011087552,
4.3677852724
],
"C": [
6.2852893084,
0.5772213903
],
"D": [
4.9938981679,
2.4717434826
],
"E": [
3.9981611826,
0.4056120666
],
"F": [
... |
1obj_3rel_3extra_gen0122 | 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 a diameter of the circle. Line BD is perpendicular to line AC. Line EF is a chord of 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)
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.is_diamet... | {
"circle1": "circle(A)",
"line_BD": "line_segment(B, D)",
"line_AC": "line_segment(A, C)",
"line_EF": "line_segment(E, F)"
} | [
"is_diameter(line_BD, circle1)",
"perpendicular(line_BD, line_AC)",
"is_chord(line_EF, circle1)"
] | [
"A",
"B",
"C",
"D",
"E",
"F"
] | [] | {
"points": {
"A": [
-0.5422754124,
0.0566475831
],
"B": [
-0.4732974495,
-0.32555019620000003
],
"C": [
1.9378707384,
0.5042571643
],
"D": [
-0.6112532911,
0.4388453096
],
"E": [
-0.2594814746,
0.3228439412
],
"F"... |
1obj_3rel_3extra_gen0124 | Diagram description: The diagram contains points A, B, C, D, E, F. There is an acute triangle ABC. 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. Line BE is an altitude of triangle ABC. Line AD is perpendicular to line BE. 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.acute_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
scen... | {
"triangleABC": "acute_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_altitude(line_BE, triangleABC, B)",
"perpendicular(line_AD, line_BE)"
] | [
"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, 12.0)",
"scene.constraint.eq(scene.angle(scene.get_object('A'), scene.get_object('B'), scene.get_object('E')), 90)"
] | {
"points": {
"A": [
0.37949728800000004,
1.8409802828
],
"B": [
-6.1613835808,
-3.8186151726
],
"C": [
6.5426370925,
7.4135248295
],
"D": [
0.192982697,
1.7951772273
],
"E": [
-6.0367495718,
-3.9626565476
],
"F": ... |
PyGeoX
Datasets for training and evaluating language models on geometric constraint solving — reading a natural-language description of a diagram and producing the point coordinates / circle radii that satisfy the stated constraints — plus a supervised set for generating PyGeoX scene code.
Subsets
| Config | Rows | Task |
|---|---|---|
gcs-sft |
15,738 | SFT — solve geometry (NL → coordinates), merged master with per-variant reward labels |
codegen-sft |
46,977 | SFT — NL diagram description → PyGeoX code |
gcs-rl |
46,977 | RL — prompts for geometry constraint solving |
bench |
300 | Evaluation benchmark (self-contained) |
wild |
200 | Evaluation — real-world school-geometry questions |
from datasets import load_dataset
ds = load_dataset("rafaelcabral96/PyGeoX", "gcs-rl")
How this data is meant to be used. Several subsets contain free-form nested objects (e.g.
Objs,possible_solution) whose keys vary per example. The reward / evaluation harness downloads the raw.jsonlfiles and parses them line-by-line withjson— that always works. The Hugging Face viewer may not fully render the nested fields.
Reward ground truth (PyGeoX-GCS-RL-Code.zip)
The problem definitions used to score RL and benchmark outputs are shipped as
data/PyGeoX-GCS-RL-Code.zip. The source_file field of each gcs-rl row points into
this folder. After downloading the repo, extract it inside data/ so the relative
paths resolve:
cd data && unzip PyGeoX-GCS-RL-Code.zip # -> data/PyGeoX-GCS-RL-Code/<id>.json
All source_file paths are written relative to the repo root
(data/PyGeoX-GCS-RL-Code/<name>.json), so they are invariant to where the repo lives.
Subset details
gcs-sft — geometry-solving SFT (merged master)
One deduplicated file keyed by (problem, completion). Each row's splits map records, per
training variant (sar, sar_sd, mse, mse_sd, sparse, plus the full base),
whether that variant includes it and with what reward/weight. Reconstruct any variant:
rows = [r for r in ds if r["splits"]["mse_sd"]["in"]]
weights = [r["splits"]["mse_sd"].get("weight", 1.0) for r in rows]
codegen-sft — NL → PyGeoX code
messages = (user: diagram description + "Please generate PyGeoX code…", assistant:
python … block), plus problem_id, source_file, difficulty.
gcs-rl — RL prompts
messages (system + user), source_file (→ reward ground truth), difficulty
(easy/medium/hard for 1/2/3 primary objects).
bench — evaluation benchmark (self-contained)
Each record carries everything needed to score a model inline:
unique_id, nl_description, pygeox_code, Objs, Rels, Points, extra_rel, possible_solution.
Rebuild the scene directly from a record (no file needed) and score predicted coordinates:
from pygeox.synthetic.llm_client import create_scene_from_json
scene = create_scene_from_json(domain=10, json_data=record, generate_objective_function=True)
reward, details = scene.reward.reward_function(pred_points, pred_circles)
wild — real-world school geometry
200 questions from MathVerse, ZhongKaoGeo, and MathVista (id, question, source, source_id). Ground truth is executable PyGeoX full_code, shipped in
data/PyGeoX-Wild-Code.zip (one problem_<id>.json per question, keyed 1:1 by id,
each with full_code + possible_solution). Extract inside data/:
cd data && unzip PyGeoX-Wild-Code.zip # -> data/PyGeoX-Wild-Code/problem_<id>.json
Citation
@software{pygeox_datasets,
title = {PyGeoX: Datasets for Geometric Constraint Solving},
author = {Rafael Cabral},
year = {2026},
url = {https://huggingface.co/datasets/rafaelcabral96/PyGeoX}
}
License
MIT
- Downloads last month
- 19