Dataset Viewer
Auto-converted to Parquet Duplicate
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": ...
End of preview. Expand in Data Studio

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 .jsonl files and parses them line-by-line with json — 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