MathPlotAI Logo MathPlotAI

Discovering Pythagoras' Theorem via Slanted Square Areas on Grid

Discovering Pythagoras' Theorem via Slanted Square Areas on Grid
Loading the math board and drawing, please wait…
2013-05-16 14:31
PolygonFunctionCoordinate GeometryGeometric Construction
This example demonstrates the discovery of Pythagoras' theorem by calculating the areas of slanted squares on a grid. It involves core math concepts like area, geometry, Pythagorean theorem, squares, polynomial functions, line segments, random variables, perimeter, and numbers. The construction utilizes GeoGebra commands such as Sequence, Union, Point, If, Translate, OrthogonalLine, Segment, Midpoint, Intersect, Ray, Circle, PointIn, Polygon, Defined, Mirror, Textfield, Vector, and Angle. Suitable for middle school and above, it provides an intuitive understanding of the theorem.

GeoGebra Commands & Parameters

  1. Sequence((i, 0), i, 0, 20) → L0
  2. Sequence((i, 1), i, 0, 20) → L1
  3. Sequence((i, 2), i, 0, 20) → L2
  4. Sequence((i, 3), i, 0, 20) → L3
  5. Sequence((i, 4), i, 0, 20) → L4
  6. Sequence((i, 5), i, 0, 20) → L5
  7. Sequence((i, 6), i, 0, 20) → L6
  8. Sequence((i, 7), i, 0, 20) → L7
  9. Sequence((i, 8), i, 0, 20) → L8
  10. Sequence((i, 9), i, 0, 20) → L9
  11. Sequence((i, 10), i, 0, 20) → L10
  12. Sequence((i, 11), i, 0, 20) → L11
  13. Sequence((i, 12), i, 0, 20) → L12
  14. Sequence((i, 13), i, 0, 20) → L13
  15. Sequence((i, 14), i, 0, 20) → L14
  16. Sequence((i, 15), i, 0, 20) → L15
  17. Sequence((i, 16), i, 0, 20) → L16
  18. Sequence((i, 17), i, 0, 20) → L17
  19. Sequence((i, 18), i, 0, 20) → L18
  20. Sequence((i, 19), i, 0, 20) → L19
  21. Sequence((i, 20), i, 0, 20) → L20
  22. Union(L1, Union[L2, Union[L3, Union[L4, Union[L5, Union[L6, Union[L7, Union[L8, Union[L9, Union[L10, Union[L11, Union[L12, Union[L13, Union[L14, Union[L15, Union[L16, Union[L17, Union[L18, Union[L19, Union[L20, L0]]]]]]]]]]]]]]]]]]]) → L'
  23. Point(L') → B'
  24. Point(L') → A'
  25. If(a' * b' ≥ 0, a, b) → x1
  26. If(a' * b' ≥ 0, b, a) → y1
  27. Translate(Midpoint[A, B], Vector[(0, 0), (0, 1)]) → J
  28. OrthogonalLine(J, yAxis) → c
  29. Segment(B, A) → d
  30. Midpoint(A, B) → I
  31. OrthogonalLine(I, d) → e
  32. Intersect(c, e) → K
  33. Ray(I, K) → f
  34. Circle(I, A) → g
  35. Intersect(g, f, 1) → O
  36. PointIn(Polygon[E, (x(E), y(E) + x1), (x(E) - y1, y(E) + x1), (x(E) - y1, y(E))]) → P
  37. Polygon(P, (x(P), y(P) + y1), (x(P) - x1, y(P))) → poly2, j, p, k
  38. Translate(poly2, z') → poly2_1
  39. PointIn(Polygon[F, (x(F) - x1, y(F)), (x(F) - x1, y(F) - y1), (x(F), y(F) - y1)]) → Q
  40. Polygon(Q, (x(Q) - y1, y(Q)), (x(Q), y(Q) - x1)) → poly1, h, q, i
  41. Translate(poly1, z') → poly1_1
  42. Defined(IntersectRegion[poly1_1, poly2_1]) → overlapPQ
  43. PointIn(Polygon[G, (x(G), y(G) - x1), (x(G) + y1, y(G) - x1), (x(G) + y1, y(G))]) → R
  44. Polygon(R, (x(R), y(R) - y1), (x(R) + x1, y(R))) → poly3, l, r_1, m
  45. Translate(poly3, z') → poly3_1
  46. Defined(IntersectRegion[poly3_1, poly1_1]) → overlapQR
  47. Defined(IntersectRegion[poly3_1, poly2_1]) → overlapPR
  48. PointIn(Polygon[H, (x(H) + x1, y(H)), (x(H) + x1, y(H) + y1), (x(H), y(H) + y1)]) → S
  49. Polygon(S, (x(S) + y1, y(S)), (x(S), y(S) + x1)) → poly4, n, s, r
  50. Translate(poly4, z') → poly4_1
  51. Defined(IntersectRegion[poly4_1, poly3_1]) → overlapRS
  52. Defined(IntersectRegion[poly4_1, poly1_1]) → overlapQS
  53. Defined(IntersectRegion[poly4_1, poly2_1]) → overlapPS
  54. Mirror((x(A), y(A)), O) → C
  55. Mirror((x(B), y(B)), O) → D
  56. Polygon(E, F, G, H) → poly5, e_1, f_1, g_1, h_1
  57. Polygon(A, B, C, D) → poly6, t, a_1, b_1, c_1
  58. Segment((x(R), y(R)), (x(R), y(R) + x1)) → d1
  59. Segment((x(Q), y(Q)), (x(Q) + x1, y(Q))) → d2
  60. Segment((x(P), y(P)), (x(P), y(P) - x1)) → d3
  61. Segment((x(S), y(S)), (x(S) - x1, y(S))) → d4
  62. Segment((x(Q), y(Q)), (x(Q) - a - b, y(Q))) → d5
  63. Segment((x(S), y(S)), (x(S) + a + b, y(S))) → d6
  64. Segment((x(R), y(R)), (x(R), y(R) - a - b)) → d7
  65. Segment((x(P), y(P)), (x(P), y(P) + a + b)) → d8
  66. Sequence(Segment[(i, y(E)), (i, y(F))], i, x(H), x(E)) → list1
  67. Sequence(Segment[(x(H), j), (x(E), j)], j, y(E), y(F)) → list2
  68. Textfield(Ar) → inputBox1
  69. Midpoint(A, E) → L
  70. Midpoint(B, E) → M
  71. Midpoint(A, H) → N
  72. Midpoint(B, H) → T
  73. Midpoint(A', B') → I'
  74. Circle(I', A') → g'
  75. Segment(B', A') → d'
  76. OrthogonalLine(I', d') → e'
  77. Translate(Midpoint[A', B'], Vector[(0, 0), (0, 1)]) → J'
  78. OrthogonalLine(J', yAxis) → c'
  79. Intersect(c', e') → K'
  80. Ray(I', K') → f'
  81. Intersect(g', f', 1) → O'
  82. Sequence(Segment[(i, y(E')), (i, y(F'))], i, x(H'), x(E')) → list3
  83. Sequence(Segment[(x(H'), j), (x(E'), j)], j, y(E'), y(F')) → list4
  84. Mirror((x(A'), y(A')), O') → C'
  85. Mirror((x(B'), y(B')), O') → D'
  86. Polygon(E', (x(E'), y(E') + y1), (x(E') - x1, y(E'))) → poly1', d_1, e'_1, i_1
  87. Polygon(F', (x(F') - y1, y(F')), (x(F'), y(F') - x1)) → poly2', j_1, f'_1, k_1
  88. Polygon(G', (x(G'), y(G') - y1), (x(G') + x1, y(G'))) → poly3', l_1, g'_1, m_1
  89. Polygon(H', (x(H') + y1, y(H')), (x(H'), y(H') + x1)) → poly4', n_1, h', p_1
  90. Polygon(A', B', C', D') → poly6', a'_1, b'_1, c'_1, d'_1
  91. Vector(A', E') → u
  92. Vector(E', A') → v
  93. Vector(B', E') → w
  94. Vector(E', B') → z
  95. Midpoint(e'_1) → C_1
  96. Midpoint(f'_1) → D_1
  97. Midpoint(g'_1) → E_1
  98. Midpoint(h') → F_1
  99. Midpoint(p) → G_1
  100. Midpoint(q) → H_1
  101. Midpoint(r_1) → I_1
  102. Midpoint(s) → J_1
  103. Segment(E, F) → q_1
  104. Segment(F, G) → s_1
  105. Segment(G, H) → t_1
  106. Segment(H, E) → a_2
  107. Angle((x(E') - x1, y(E')), E', (x(E'), y(E') + y1)) → α
  108. Angle((x(P) - x1, y(P)), P, (x(P), y(P) + y1)) → α'
  109. Angle((x(F') - y1, y(F')), F', (x(F'), y(F') - x1)) → β
  110. Angle((x(Q) - y1, y(Q)), Q, (x(Q), y(Q) - x1)) → β'
  111. Angle((x(G'), y(G') - y1), G', (x(G') + x1, y(G'))) → γ
  112. Angle((x(R), y(R) - y1), R, (x(R) + x1, y(R))) → γ'
  113. Angle((x(S), y(S) + x1), S, (x(S) + y1, y(S))) → δ'
  114. Angle((x(H'), y(H') + x1), H', (x(H') + y1, y(H'))) → δ
  115. If(show1 ∨ show9 ∨ show6, Midpoint[F, (x(F) - a, y(F) - a)], If[show10 ∨ show4 ∨ show8, Midpoint[G, (x(G) + a, y(G) - a)], If[show3 ∨ show5 ∨ show11, Midpoint[H, (x(H) + a, y(H) + a)], If[show2 ∨ show12 ∨ show7, Midpoint[E, (x(E) - a, y(E) + a)]]]]) → K_1
  116. If(show5 ∨ show12 ∨ show1, Midpoint[G, (x(G) + b, y(G) - b)], If[show2 ∨ show11 ∨ show8, Midpoint[F, (x(F) - b, y(F) - b)], If[show3 ∨ show10 ∨ show6, Midpoint[E, (x(E) - b, y(E) + b)], If[show9 ∨ show4 ∨ show7, Midpoint[H, (x(H) + b, y(H) + b)]]]]) → K_2
  117. Midpoint(E', G') → L_1
  118. Midpoint(E, G) → M_1

AI Drawing Prompt Reference

Draw multiple parallel lines on a grid and select points from these lines to form several squares. Calculate the areas of these squares to demonstrate the Pythagorean theorem. Start by drawing a right-angled triangle and constructing squares on each of its sides. Calculate the area of each square. Then, translate the triangle along the grid lines and observe the relationship between the translated squares and the original ones, ultimately demonstrating the validity of the Pythagorean theorem through the graphics.
The prompt above was compiled from the original drawing commands and is for reference only.