MathPlotAI Logo MathPlotAI

Discovering Pythagoras' Theorem by Area

Discovering Pythagoras' Theorem by Area
Loading the math board and drawing, please wait…
2015-08-09 02:28
This example demonstrates Pythagoras' theorem by finding the areas of slanted squares on a grid. Core math concepts include Pythagorean theorem, area calculation, geometric transformations, and ratios. Construction highlights the use of GeoGebra commands and objects like 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 to understand visual proofs and geometric applications 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 a grid with 20 horizontal and 20 vertical lines intersecting at points to form a 20x20 square. Inside this square, create four tilted squares in each corner and calculate their areas. Use geometric transformations and auxiliary lines to demonstrate that the sum of the areas of these tilted squares equals the combined areas of two larger squares inside the main square, thereby proving the Pythagorean theorem.
The prompt above was compiled from the original drawing commands and is for reference only.