MathPlotAI Logo MathPlotAI

Sieve of Eratosthenes (Prime Number Visualization)

Sieve of Eratosthenes (Prime Number Visualization)
Loading the math board and drawing, please wait…
2020-06-25 18:15
PolygonFunctionSequenceSlider AnimationGraphing
① This example dynamically demonstrates the Sieve of Eratosthenes, a classic algorithm for finding all prime numbers up to a given limit, by visually marking composite numbers in a grid. ② Core mathematical concepts include prime and composite numbers, divisibility, and the sieve algorithm itself; it also involves sequence generation and conditional logic. ③ Construction highlights: using GeoGebra commands such as Sequence to generate the number list, If for prime/composite condition checks, and Polygon to highlight marked cells; objects include A0, dy, dx, L1, mode, text1–text26, which control grid dimensions, labels, and filtering states. ④ Suitable for middle school number theory introduction, algorithm visualization in computer science, or discrete mathematics courses to illustrate prime distribution and the efficiency of the sieve method.

GeoGebra Commands & Parameters

  1. Sequence(Segment[(i, 0), (i, 10)], i, 0, 10) → L1
  2. Sequence(Segment[(i, -5), (i, 10)], i, 0, 7) → L5
  3. If(mode ≟ 2, A1 + (0, -1), A1 + (6, 0)) → A7
  4. If(mode ≟ 1, A1 + (7, 0), If[mode ≟ 2, A1 + (1, -1), A1 + (0, -1)]) → A8
  5. If(mode ≟ 1, A1 + (8, 0), If[mode ≟ 2, A1 + (2, -1), A1 + (1, -1)]) → A9
  6. If(mode ≟ 1, A1 + (9, 0), If[mode ≟ 2, A1 + (3, -1), A1 + (2, -1)]) → A10
  7. Sequence(Segment[(0, i), (7, i)], i, -5, 10) → L6
  8. Sequence(Segment[(0, i), (6, i)], i, -7, 10) → L3
  9. Sequence(Segment[(i, -7), (i, 10)], i, 0, 6) → L4
  10. If(mode ≟ 1, A1 + (0, -1), If[mode ≟ 2, A1 + (4, -1), A1 + (3, -1)]) → A11
  11. If(mode ≟ 1, A1 + (1, -1), If[mode ≟ 2, A1 + (5, -1), A1 + (4, -1)]) → A12
  12. If(mode ≟ 1, A1 + (2, -1), If[mode ≟ 2, A1 + (0, -2), A1 + (5, -1)]) → A13
  13. If(mode ≟ 1, A1 + (3, -1), If[mode ≟ 2, A1 + (1, -2), A1 + (6, -1)]) → A14
  14. If(mode ≟ 1, A1 + (4, -1), If[mode ≟ 2, A1 + (2, -2), A1 + (0, -2)]) → A15
  15. If(mode ≟ 1, A1 + (5, -1), If[mode ≟ 2, A1 + (3, -2), A1 + (1, -2)]) → A16
  16. If(mode ≟ 1, A1 + (6, -1), If[mode ≟ 2, A1 + (4, -2), A1 + (2, -2)]) → A17
  17. If(mode ≟ 1, A1 + (7, -1), If[mode ≟ 2, A1 + (5, -2), A1 + (3, -2)]) → A18
  18. If(mode ≟ 1, A1 + (8, -1), If[mode ≟ 2, A1 + (0, -3), A1 + (4, -2)]) → A19
  19. If(mode ≟ 1, A1 + (9, -1), If[mode ≟ 2, A1 + (1, -3), A1 + (5, -2)]) → A20
  20. If(mode ≟ 1, A1 + (0, -2), If[mode ≟ 2, A1 + (2, -3), A1 + (6, -2)]) → A21
  21. If(mode ≟ 1, A1 + (1, -2), If[mode ≟ 2, A1 + (3, -3), A1 + (0, -3)]) → A22
  22. If(mode ≟ 1, A1 + (2, -2), If[mode ≟ 2, A1 + (4, -3), A1 + (1, -3)]) → A23
  23. If(mode ≟ 1, A1 + (3, -2), If[mode ≟ 2, A1 + (5, -3), A1 + (2, -3)]) → A24
  24. If(mode ≟ 1, A1 + (4, -2), If[mode ≟ 2, A1 + (0, -4), A1 + (3, -3)]) → A25
  25. If(mode ≟ 1, A1 + (5, -2), If[mode ≟ 2, A1 + (1, -4), A1 + (4, -3)]) → A26
  26. If(mode ≟ 1, A1 + (6, -2), If[mode ≟ 2, A1 + (2, -4), A1 + (5, -3)]) → A27
  27. If(mode ≟ 1, A1 + (7, -2), If[mode ≟ 2, A1 + (3, -4), A1 + (6, -3)]) → A28
  28. If(mode ≟ 1, A1 + (8, -2), If[mode ≟ 2, A1 + (4, -4), A1 + (0, -4)]) → A29
  29. If(mode ≟ 1, A1 + (9, -2), If[mode ≟ 2, A1 + (5, -4), A1 + (1, -4)]) → A30
  30. If(mode ≟ 1, A1 + (0, -3), If[mode ≟ 2, A1 + (0, -5), A1 + (2, -4)]) → A31
  31. If(mode ≟ 1, A1 + (1, -3), If[mode ≟ 2, A1 + (1, -5), A1 + (3, -4)]) → A32
  32. If(mode ≟ 1, A1 + (2, -3), If[mode ≟ 2, A1 + (2, -5), A1 + (4, -4)]) → A33
  33. If(mode ≟ 1, A1 + (3, -3), If[mode ≟ 2, A1 + (3, -5), A1 + (5, -4)]) → A34
  34. If(mode ≟ 1, A1 + (4, -3), If[mode ≟ 2, A1 + (4, -5), A1 + (6, -4)]) → A35
  35. If(mode ≟ 1, A1 + (5, -3), If[mode ≟ 2, A1 + (5, -5), A1 + (0, -5)]) → A36
  36. If(mode ≟ 1, A1 + (6, -3), If[mode ≟ 2, A1 + (0, -6), A1 + (1, -5)]) → A37
  37. If(mode ≟ 1, A1 + (7, -3), If[mode ≟ 2, A1 + (1, -6), A1 + (2, -5)]) → A38
  38. If(mode ≟ 1, A1 + (8, -3), If[mode ≟ 2, A1 + (2, -6), A1 + (3, -5)]) → A39
  39. If(mode ≟ 1, A1 + (9, -3), If[mode ≟ 2, A1 + (3, -6), A1 + (4, -5)]) → A40
  40. If(mode ≟ 1, A1 + (0, -4), If[mode ≟ 2, A1 + (4, -6), A1 + (5, -5)]) → A41
  41. If(mode ≟ 1, A1 + (1, -4), If[mode ≟ 2, A1 + (5, -6), A1 + (6, -5)]) → A42
  42. If(mode ≟ 1, A1 + (2, -4), If[mode ≟ 2, A1 + (0, -7), A1 + (0, -6)]) → A43
  43. If(mode ≟ 1, A1 + (3, -4), If[mode ≟ 2, A1 + (1, -7), A1 + (1, -6)]) → A44
  44. If(mode ≟ 1, A1 + (4, -4), If[mode ≟ 2, A1 + (2, -7), A1 + (2, -6)]) → A45
  45. If(mode ≟ 1, A1 + (5, -4), If[mode ≟ 2, A1 + (3, -7), A1 + (3, -6)]) → A46
  46. If(mode ≟ 1, A1 + (6, -4), If[mode ≟ 2, A1 + (4, -7), A1 + (4, -6)]) → A47
  47. If(mode ≟ 1, A1 + (7, -4), If[mode ≟ 2, A1 + (5, -7), A1 + (5, -6)]) → A48
  48. If(mode ≟ 1, A1 + (8, -4), If[mode ≟ 2, A1 + (0, -8), A1 + (6, -6)]) → A49
  49. If(mode ≟ 1, A1 + (9, -4), If[mode ≟ 2, A1 + (1, -8), A1 + (0, -7)]) → A50
  50. If(mode ≟ 1, A1 + (0, -5), If[mode ≟ 2, A1 + (2, -8), A1 + (1, -7)]) → A51
  51. If(mode ≟ 1, A1 + (1, -5), If[mode ≟ 2, A1 + (3, -8), A1 + (2, -7)]) → A52
  52. If(mode ≟ 1, A1 + (2, -5), If[mode ≟ 2, A1 + (4, -8), A1 + (3, -7)]) → A53
  53. If(mode ≟ 1, A1 + (3, -5), If[mode ≟ 2, A1 + (5, -8), A1 + (4, -7)]) → A54
  54. If(mode ≟ 1, A1 + (4, -5), If[mode ≟ 2, A1 + (0, -9), A1 + (5, -7)]) → A55
  55. If(mode ≟ 1, A1 + (5, -5), If[mode ≟ 2, A1 + (1, -9), A1 + (6, -7)]) → A56
  56. If(mode ≟ 1, A1 + (6, -5), If[mode ≟ 2, A1 + (2, -9), A1 + (0, -8)]) → A57
  57. If(mode ≟ 1, A1 + (7, -5), If[mode ≟ 2, A1 + (3, -9), A1 + (1, -8)]) → A58
  58. If(mode ≟ 1, A1 + (8, -5), If[mode ≟ 2, A1 + (4, -9), A1 + (2, -8)]) → A59
  59. If(mode ≟ 1, A1 + (9, -5), If[mode ≟ 2, A1 + (5, -9), A1 + (3, -8)]) → A60
  60. If(mode ≟ 1, A1 + (0, -6), If[mode ≟ 2, A1 + (0, -10), A1 + (4, -8)]) → A61
  61. If(mode ≟ 1, A1 + (1, -6), If[mode ≟ 2, A1 + (1, -10), A1 + (5, -8)]) → A62
  62. If(mode ≟ 1, A1 + (2, -6), If[mode ≟ 2, A1 + (2, -10), A1 + (6, -8)]) → A63
  63. If(mode ≟ 1, A1 + (3, -6), If[mode ≟ 2, A1 + (3, -10), A1 + (0, -9)]) → A64
  64. If(mode ≟ 1, A1 + (4, -6), If[mode ≟ 2, A1 + (4, -10), A1 + (1, -9)]) → A65
  65. If(mode ≟ 1, A1 + (5, -6), If[mode ≟ 2, A1 + (5, -10), A1 + (2, -9)]) → A66
  66. If(mode ≟ 1, A1 + (6, -6), If[mode ≟ 2, A1 + (0, -11), A1 + (3, -9)]) → A67
  67. If(mode ≟ 1, A1 + (7, -6), If[mode ≟ 2, A1 + (1, -11), A1 + (4, -9)]) → A68
  68. If(mode ≟ 1, A1 + (8, -6), If[mode ≟ 2, A1 + (2, -11), A1 + (5, -9)]) → A69
  69. If(mode ≟ 1, A1 + (9, -6), If[mode ≟ 2, A1 + (3, -11), A1 + (6, -9)]) → A70
  70. If(mode ≟ 1, A1 + (0, -7), If[mode ≟ 2, A1 + (4, -11), A1 + (0, -10)]) → A71
  71. If(mode ≟ 1, A1 + (1, -7), If[mode ≟ 2, A1 + (5, -11), A1 + (1, -10)]) → A72
  72. If(mode ≟ 1, A1 + (2, -7), If[mode ≟ 2, A1 + (0, -12), A1 + (2, -10)]) → A73
  73. If(mode ≟ 1, A1 + (3, -7), If[mode ≟ 2, A1 + (1, -12), A1 + (3, -10)]) → A74
  74. If(mode ≟ 1, A1 + (4, -7), If[mode ≟ 2, A1 + (2, -12), A1 + (4, -10)]) → A75
  75. If(mode ≟ 1, A1 + (5, -7), If[mode ≟ 2, A1 + (3, -12), A1 + (5, -10)]) → A76
  76. If(mode ≟ 1, A1 + (6, -7), If[mode ≟ 2, A1 + (4, -12), A1 + (6, -10)]) → A77
  77. If(mode ≟ 1, A1 + (7, -7), If[mode ≟ 2, A1 + (5, -12), A1 + (0, -11)]) → A78
  78. If(mode ≟ 1, A1 + (8, -7), If[mode ≟ 2, A1 + (0, -13), A1 + (1, -11)]) → A79
  79. If(mode ≟ 1, A1 + (9, -7), If[mode ≟ 2, A1 + (1, -13), A1 + (2, -11)]) → A80
  80. If(mode ≟ 1, A1 + (0, -8), If[mode ≟ 2, A1 + (2, -13), A1 + (3, -11)]) → A81
  81. If(mode ≟ 1, A1 + (1, -8), If[mode ≟ 2, A1 + (3, -13), A1 + (4, -11)]) → A82
  82. If(mode ≟ 1, A1 + (2, -8), If[mode ≟ 2, A1 + (4, -13), A1 + (5, -11)]) → A83
  83. If(mode ≟ 1, A1 + (3, -8), If[mode ≟ 2, A1 + (5, -13), A1 + (6, -11)]) → A84
  84. If(mode ≟ 1, A1 + (4, -8), If[mode ≟ 2, A1 + (0, -14), A1 + (0, -12)]) → A85
  85. If(mode ≟ 1, A1 + (5, -8), If[mode ≟ 2, A1 + (1, -14), A1 + (1, -12)]) → A86
  86. If(mode ≟ 1, A1 + (6, -8), If[mode ≟ 2, A1 + (2, -14), A1 + (2, -12)]) → A87
  87. If(mode ≟ 1, A1 + (7, -8), If[mode ≟ 2, A1 + (3, -14), A1 + (3, -12)]) → A88
  88. If(mode ≟ 1, A1 + (8, -8), If[mode ≟ 2, A1 + (4, -14), A1 + (4, -12)]) → A89
  89. If(mode ≟ 1, A1 + (9, -8), If[mode ≟ 2, A1 + (5, -14), A1 + (5, -12)]) → A90
  90. If(mode ≟ 1, A1 + (0, -9), If[mode ≟ 2, A1 + (0, -15), A1 + (6, -12)]) → A91
  91. If(mode ≟ 1, A1 + (1, -9), If[mode ≟ 2, A1 + (1, -15), A1 + (0, -13)]) → A92
  92. If(mode ≟ 1, A1 + (2, -9), If[mode ≟ 2, A1 + (2, -15), A1 + (1, -13)]) → A93
  93. If(mode ≟ 1, A1 + (3, -9), If[mode ≟ 2, A1 + (3, -15), A1 + (2, -13)]) → A94
  94. If(mode ≟ 1, A1 + (4, -9), If[mode ≟ 2, A1 + (4, -15), A1 + (3, -13)]) → A95
  95. If(mode ≟ 1, A1 + (5, -9), If[mode ≟ 2, A1 + (5, -15), A1 + (4, -13)]) → A96
  96. If(mode ≟ 1, A1 + (6, -9), If[mode ≟ 2, A1 + (0, -16), A1 + (5, -13)]) → A97
  97. If(mode ≟ 1, A1 + (7, -9), If[mode ≟ 2, A1 + (1, -16), A1 + (6, -13)]) → A98
  98. If(mode ≟ 1, A1 + (8, -9), If[mode ≟ 2, A1 + (2, -16), A1 + (0, -14)]) → A99
  99. If(mode ≟ 1, A1 + (9, -9), If[mode ≟ 2, A1 + (3, -16), A1 + (1, -14)]) → A100
  100. Polygon({A0, A0 + (1, 0), A0 + (1, 1), A0 + (0, 1)}) → B1
  101. Polygon({A11 - (dx, dy), A11 + (1, 0) - (dx, dy), A11 + (1, 1) - (dx, dy), A11 + (0, 1) - (dx, dy)}) → B11
  102. Polygon({A0 + (1, 0), A0 + (2, 0), A0 + (2, 1), A0 + (1, 1)}) → B2
  103. Polygon({A3 - (dx + 0.2, dy), A3 + (1 - 0.2, 0) - (dx, dy), A3 + (1 - 0.2, 1) - (dx, dy), A3 + (0, 1) - (dx + 0.2, dy)}) → B3
  104. Polygon({A4 - (dx + 0.2, dy), A4 + (1 - 0.2, 0) - (dx, dy), A4 + (1 - 0.2, 1) - (dx, dy), A4 + (0, 1) - (dx + 0.2, dy)}) → B4
  105. Polygon({A12 - (dx, dy), A12 + (1, 0) - (dx, dy), A12 + (1, 1) - (dx, dy), A12 + (0, 1) - (dx, dy)}) → B12
  106. Polygon({A13 - (dx, dy), A13 + (1, 0) - (dx, dy), A13 + (1, 1) - (dx, dy), A13 + (0, 1) - (dx, dy)}) → B13
  107. Polygon({A14 - (dx, dy), A14 + (1, 0) - (dx, dy), A14 + (1, 1) - (dx, dy), A14 + (0, 1) - (dx, dy)}) → B14
  108. Polygon({A15 - (dx, dy), A15 + (1, 0) - (dx, dy), A15 + (1, 1) - (dx, dy), A15 + (0, 1) - (dx, dy)}) → B15
  109. Polygon({A16 - (dx, dy), A16 + (1, 0) - (dx, dy), A16 + (1, 1) - (dx, dy), A16 + (0, 1) - (dx, dy)}) → B16
  110. Polygon({A17 - (dx, dy), A17 + (1, 0) - (dx, dy), A17 + (1, 1) - (dx, dy), A17 + (0, 1) - (dx, dy)}) → B17
  111. Polygon({A18 - (dx, dy), A18 + (1, 0) - (dx, dy), A18 + (1, 1) - (dx, dy), A18 + (0, 1) - (dx, dy)}) → B18
  112. Polygon({A19 - (dx, dy), A19 + (1, 0) - (dx, dy), A19 + (1, 1) - (dx, dy), A19 + (0, 1) - (dx, dy)}) → B19
  113. Polygon({A20 - (dx, dy), A20 + (1, 0) - (dx, dy), A20 + (1, 1) - (dx, dy), A20 + (0, 1) - (dx, dy)}) → B20
  114. Polygon({A21 - (dx, dy), A21 + (1, 0) - (dx, dy), A21 + (1, 1) - (dx, dy), A21 + (0, 1) - (dx, dy)}) → B21
  115. Polygon({A22 - (dx, dy), A22 + (1, 0) - (dx, dy), A22 + (1, 1) - (dx, dy), A22 + (0, 1) - (dx, dy)}) → B22
  116. Polygon({A23 - (dx, dy), A23 + (1, 0) - (dx, dy), A23 + (1, 1) - (dx, dy), A23 + (0, 1) - (dx, dy)}) → B23
  117. Polygon({A24 - (dx, dy), A24 + (1, 0) - (dx, dy), A24 + (1, 1) - (dx, dy), A24 + (0, 1) - (dx, dy)}) → B24
  118. Polygon({A25 - (dx, dy), A25 + (1, 0) - (dx, dy), A25 + (1, 1) - (dx, dy), A25 + (0, 1) - (dx, dy)}) → B25
  119. Polygon({A26 - (dx, dy), A26 + (1, 0) - (dx, dy), A26 + (1, 1) - (dx, dy), A26 + (0, 1) - (dx, dy)}) → B26
  120. Polygon({A27 - (dx, dy), A27 + (1, 0) - (dx, dy), A27 + (1, 1) - (dx, dy), A27 + (0, 1) - (dx, dy)}) → B27
  121. Polygon({A28 - (dx, dy), A28 + (1, 0) - (dx, dy), A28 + (1, 1) - (dx, dy), A28 + (0, 1) - (dx, dy)}) → B28
  122. Polygon({A29 - (dx, dy), A29 + (1, 0) - (dx, dy), A29 + (1, 1) - (dx, dy), A29 + (0, 1) - (dx, dy)}) → B29
  123. Polygon({A30 - (dx, dy), A30 + (1, 0) - (dx, dy), A30 + (1, 1) - (dx, dy), A30 + (0, 1) - (dx, dy)}) → B30
  124. Polygon({A31 - (dx, dy), A31 + (1, 0) - (dx, dy), A31 + (1, 1) - (dx, dy), A31 + (0, 1) - (dx, dy)}) → B31
  125. Polygon({A32 - (dx, dy), A32 + (1, 0) - (dx, dy), A32 + (1, 1) - (dx, dy), A32 + (0, 1) - (dx, dy)}) → B32
  126. Polygon({A33 - (dx, dy), A33 + (1, 0) - (dx, dy), A33 + (1, 1) - (dx, dy), A33 + (0, 1) - (dx, dy)}) → B33
  127. Polygon({A34 - (dx, dy), A34 + (1, 0) - (dx, dy), A34 + (1, 1) - (dx, dy), A34 + (0, 1) - (dx, dy)}) → B34
  128. Polygon({A35 - (dx, dy), A35 + (1, 0) - (dx, dy), A35 + (1, 1) - (dx, dy), A35 + (0, 1) - (dx, dy)}) → B35
  129. Polygon({A36 - (dx, dy), A36 + (1, 0) - (dx, dy), A36 + (1, 1) - (dx, dy), A36 + (0, 1) - (dx, dy)}) → B36
  130. Polygon({A37 - (dx, dy), A37 + (1, 0) - (dx, dy), A37 + (1, 1) - (dx, dy), A37 + (0, 1) - (dx, dy)}) → B37
  131. Polygon({A38 - (dx, dy), A38 + (1, 0) - (dx, dy), A38 + (1, 1) - (dx, dy), A38 + (0, 1) - (dx, dy)}) → B38
  132. Polygon({A39 - (dx, dy), A39 + (1, 0) - (dx, dy), A39 + (1, 1) - (dx, dy), A39 + (0, 1) - (dx, dy)}) → B39
  133. Polygon({A40 - (dx, dy), A40 + (1, 0) - (dx, dy), A40 + (1, 1) - (dx, dy), A40 + (0, 1) - (dx, dy)}) → B40
  134. Polygon({A41 - (dx, dy), A41 + (1, 0) - (dx, dy), A41 + (1, 1) - (dx, dy), A41 + (0, 1) - (dx, dy)}) → B41
  135. Polygon({A42 - (dx, dy), A42 + (1, 0) - (dx, dy), A42 + (1, 1) - (dx, dy), A42 + (0, 1) - (dx, dy)}) → B42
  136. Polygon({A43 - (dx, dy), A43 + (1, 0) - (dx, dy), A43 + (1, 1) - (dx, dy), A43 + (0, 1) - (dx, dy)}) → B43
  137. Polygon({A44 - (dx, dy), A44 + (1, 0) - (dx, dy), A44 + (1, 1) - (dx, dy), A44 + (0, 1) - (dx, dy)}) → B44
  138. Polygon({A45 - (dx, dy), A45 + (1, 0) - (dx, dy), A45 + (1, 1) - (dx, dy), A45 + (0, 1) - (dx, dy)}) → B45
  139. Polygon({A46 - (dx, dy), A46 + (1, 0) - (dx, dy), A46 + (1, 1) - (dx, dy), A46 + (0, 1) - (dx, dy)}) → B46
  140. Polygon({A47 - (dx, dy), A47 + (1, 0) - (dx, dy), A47 + (1, 1) - (dx, dy), A47 + (0, 1) - (dx, dy)}) → B47
  141. Polygon({A48 - (dx, dy), A48 + (1, 0) - (dx, dy), A48 + (1, 1) - (dx, dy), A48 + (0, 1) - (dx, dy)}) → B48
  142. Polygon({A49 - (dx, dy), A49 + (1, 0) - (dx, dy), A49 + (1, 1) - (dx, dy), A49 + (0, 1) - (dx, dy)}) → B49
  143. Polygon({A50 - (dx, dy), A50 + (1, 0) - (dx, dy), A50 + (1, 1) - (dx, dy), A50 + (0, 1) - (dx, dy)}) → B50
  144. Polygon({A51 - (dx, dy), A51 + (1, 0) - (dx, dy), A51 + (1, 1) - (dx, dy), A51 + (0, 1) - (dx, dy)}) → B51
  145. Polygon({A52 - (dx, dy), A52 + (1, 0) - (dx, dy), A52 + (1, 1) - (dx, dy), A52 + (0, 1) - (dx, dy)}) → B52
  146. Polygon({A53 - (dx, dy), A53 + (1, 0) - (dx, dy), A53 + (1, 1) - (dx, dy), A53 + (0, 1) - (dx, dy)}) → B53
  147. Polygon({A54 - (dx, dy), A54 + (1, 0) - (dx, dy), A54 + (1, 1) - (dx, dy), A54 + (0, 1) - (dx, dy)}) → B54
  148. Polygon({A55 - (dx, dy), A55 + (1, 0) - (dx, dy), A55 + (1, 1) - (dx, dy), A55 + (0, 1) - (dx, dy)}) → B55
  149. Polygon({A56 - (dx, dy), A56 + (1, 0) - (dx, dy), A56 + (1, 1) - (dx, dy), A56 + (0, 1) - (dx, dy)}) → B56
  150. Polygon({A57 - (dx, dy), A57 + (1, 0) - (dx, dy), A57 + (1, 1) - (dx, dy), A57 + (0, 1) - (dx, dy)}) → B57
  151. Polygon({A58 - (dx, dy), A58 + (1, 0) - (dx, dy), A58 + (1, 1) - (dx, dy), A58 + (0, 1) - (dx, dy)}) → B58
  152. Polygon({A59 - (dx, dy), A59 + (1, 0) - (dx, dy), A59 + (1, 1) - (dx, dy), A59 + (0, 1) - (dx, dy)}) → B59
  153. Polygon({A60 - (dx, dy), A60 + (1, 0) - (dx, dy), A60 + (1, 1) - (dx, dy), A60 + (0, 1) - (dx, dy)}) → B60
  154. Polygon({A61 - (dx, dy), A61 + (1, 0) - (dx, dy), A61 + (1, 1) - (dx, dy), A61 + (0, 1) - (dx, dy)}) → B61
  155. Polygon({A62 - (dx, dy), A62 + (1, 0) - (dx, dy), A62 + (1, 1) - (dx, dy), A62 + (0, 1) - (dx, dy)}) → B62
  156. Polygon({A63 - (dx, dy), A63 + (1, 0) - (dx, dy), A63 + (1, 1) - (dx, dy), A63 + (0, 1) - (dx, dy)}) → B63
  157. Polygon({A64 - (dx, dy), A64 + (1, 0) - (dx, dy), A64 + (1, 1) - (dx, dy), A64 + (0, 1) - (dx, dy)}) → B64
  158. Polygon({A65 - (dx, dy), A65 + (1, 0) - (dx, dy), A65 + (1, 1) - (dx, dy), A65 + (0, 1) - (dx, dy)}) → B65
  159. Polygon({A66 - (dx, dy), A66 + (1, 0) - (dx, dy), A66 + (1, 1) - (dx, dy), A66 + (0, 1) - (dx, dy)}) → B66
  160. Polygon({A67 - (dx, dy), A67 + (1, 0) - (dx, dy), A67 + (1, 1) - (dx, dy), A67 + (0, 1) - (dx, dy)}) → B67
  161. Polygon({A68 - (dx, dy), A68 + (1, 0) - (dx, dy), A68 + (1, 1) - (dx, dy), A68 + (0, 1) - (dx, dy)}) → B68
  162. Polygon({A69 - (dx, dy), A69 + (1, 0) - (dx, dy), A69 + (1, 1) - (dx, dy), A69 + (0, 1) - (dx, dy)}) → B69
  163. Polygon({A70 - (dx, dy), A70 + (1, 0) - (dx, dy), A70 + (1, 1) - (dx, dy), A70 + (0, 1) - (dx, dy)}) → B70
  164. Polygon({A71 - (dx, dy), A71 + (1, 0) - (dx, dy), A71 + (1, 1) - (dx, dy), A71 + (0, 1) - (dx, dy)}) → B71
  165. Polygon({A72 - (dx, dy), A72 + (1, 0) - (dx, dy), A72 + (1, 1) - (dx, dy), A72 + (0, 1) - (dx, dy)}) → B72
  166. Polygon({A73 - (dx, dy), A73 + (1, 0) - (dx, dy), A73 + (1, 1) - (dx, dy), A73 + (0, 1) - (dx, dy)}) → B73
  167. Polygon({A74 - (dx, dy), A74 + (1, 0) - (dx, dy), A74 + (1, 1) - (dx, dy), A74 + (0, 1) - (dx, dy)}) → B74
  168. Polygon({A75 - (dx, dy), A75 + (1, 0) - (dx, dy), A75 + (1, 1) - (dx, dy), A75 + (0, 1) - (dx, dy)}) → B75
  169. Polygon({A76 - (dx, dy), A76 + (1, 0) - (dx, dy), A76 + (1, 1) - (dx, dy), A76 + (0, 1) - (dx, dy)}) → B76
  170. Polygon({A77 - (dx, dy), A77 + (1, 0) - (dx, dy), A77 + (1, 1) - (dx, dy), A77 + (0, 1) - (dx, dy)}) → B77
  171. Polygon({A78 - (dx, dy), A78 + (1, 0) - (dx, dy), A78 + (1, 1) - (dx, dy), A78 + (0, 1) - (dx, dy)}) → B78
  172. Polygon({A79 - (dx, dy), A79 + (1, 0) - (dx, dy), A79 + (1, 1) - (dx, dy), A79 + (0, 1) - (dx, dy)}) → B79
  173. Polygon({A80 - (dx, dy), A80 + (1, 0) - (dx, dy), A80 + (1, 1) - (dx, dy), A80 + (0, 1) - (dx, dy)}) → B80
  174. Polygon({A81 - (dx, dy), A81 + (1, 0) - (dx, dy), A81 + (1, 1) - (dx, dy), A81 + (0, 1) - (dx, dy)}) → B81
  175. Polygon({A82 - (dx, dy), A82 + (1, 0) - (dx, dy), A82 + (1, 1) - (dx, dy), A82 + (0, 1) - (dx, dy)}) → B82
  176. Polygon({A83 - (dx, dy), A83 + (1, 0) - (dx, dy), A83 + (1, 1) - (dx, dy), A83 + (0, 1) - (dx, dy)}) → B83
  177. Polygon({A84 - (dx, dy), A84 + (1, 0) - (dx, dy), A84 + (1, 1) - (dx, dy), A84 + (0, 1) - (dx, dy)}) → B84
  178. Polygon({A85 - (dx, dy), A85 + (1, 0) - (dx, dy), A85 + (1, 1) - (dx, dy), A85 + (0, 1) - (dx, dy)}) → B85
  179. Polygon({A86 - (dx, dy), A86 + (1, 0) - (dx, dy), A86 + (1, 1) - (dx, dy), A86 + (0, 1) - (dx, dy)}) → B86
  180. Polygon({A87 - (dx, dy), A87 + (1, 0) - (dx, dy), A87 + (1, 1) - (dx, dy), A87 + (0, 1) - (dx, dy)}) → B87
  181. Polygon({A88 - (dx, dy), A88 + (1, 0) - (dx, dy), A88 + (1, 1) - (dx, dy), A88 + (0, 1) - (dx, dy)}) → B88
  182. Polygon({A89 - (dx, dy), A89 + (1, 0) - (dx, dy), A89 + (1, 1) - (dx, dy), A89 + (0, 1) - (dx, dy)}) → B89
  183. Polygon({A90 - (dx, dy), A90 + (1, 0) - (dx, dy), A90 + (1, 1) - (dx, dy), A90 + (0, 1) - (dx, dy)}) → B90
  184. Polygon({A91 - (dx, dy), A91 + (1, 0) - (dx, dy), A91 + (1, 1) - (dx, dy), A91 + (0, 1) - (dx, dy)}) → B91
  185. Polygon({A92 - (dx, dy), A92 + (1, 0) - (dx, dy), A92 + (1, 1) - (dx, dy), A92 + (0, 1) - (dx, dy)}) → B92
  186. Polygon({A93 - (dx, dy), A93 + (1, 0) - (dx, dy), A93 + (1, 1) - (dx, dy), A93 + (0, 1) - (dx, dy)}) → B93
  187. Polygon({A94 - (dx, dy), A94 + (1, 0) - (dx, dy), A94 + (1, 1) - (dx, dy), A94 + (0, 1) - (dx, dy)}) → B94
  188. Polygon({A95 - (dx, dy), A95 + (1, 0) - (dx, dy), A95 + (1, 1) - (dx, dy), A95 + (0, 1) - (dx, dy)}) → B95
  189. Polygon({A96 - (dx, dy), A96 + (1, 0) - (dx, dy), A96 + (1, 1) - (dx, dy), A96 + (0, 1) - (dx, dy)}) → B96
  190. Polygon({A97 - (dx, dy), A97 + (1, 0) - (dx, dy), A97 + (1, 1) - (dx, dy), A97 + (0, 1) - (dx, dy)}) → B97
  191. Polygon({A98 - (dx, dy), A98 + (1, 0) - (dx, dy), A98 + (1, 1) - (dx, dy), A98 + (0, 1) - (dx, dy)}) → B98
  192. Polygon({A99 - (dx, dy), A99 + (1, 0) - (dx, dy), A99 + (1, 1) - (dx, dy), A99 + (0, 1) - (dx, dy)}) → B99
  193. Polygon({A100 - (dx, dy), A100 + (1, 0) - (dx, dy), A100 + (1, 1) - (dx, dy), A100 + (0, 1) - (dx, dy)}) → B100
  194. Polygon({A5 - (dx + 0.2, dy), A5 + (1 - 0.2, 0) - (dx, dy), A5 + (1 - 0.2, 1) - (dx, dy), A5 + (0, 1) - (dx + 0.2, dy)}) → B5
  195. Polygon({A6 - (dx + 0.2, dy), A6 + (1 - 0.2, 0) - (dx, dy), A6 + (1 - 0.2, 1) - (dx, dy), A6 + (0, 1) - (dx + 0.2, dy)}) → B6
  196. Polygon({A7 - (dx, dy), A7 + (1, 0) - (dx, dy), A7 + (1, 1) - (dx, dy), A7 + (0, 1) - (dx, dy)}) → B7
  197. Polygon({A8 - (dx, dy), A8 + (1, 0) - (dx, dy), A8 + (1, 1) - (dx, dy), A8 + (0, 1) - (dx, dy)}) → B8
  198. Polygon({A9 - (dx, dy), A9 + (1, 0) - (dx, dy), A9 + (1, 1) - (dx, dy), A9 + (0, 1) - (dx, dy)}) → B9
  199. Polygon({A10 - (dx, dy), A10 + (1, 0) - (dx, dy), A10 + (1, 1) - (dx, dy), A10 + (0, 1) - (dx, dy)}) → B10
  200. Sequence(Segment[(0, i), (10, i)], i, 0, 10) → L2

AI Drawing Prompt Reference

Create a grid visualization for the Sieve of Eratosthenes. The grid consists of horizontal and vertical line segments forming rectangular cells across a coordinate plane. Include a mode slider that changes the arrangement of marked points, which move in a stepwise pattern to simulate the sieving process. Each cell should have a number label. The layout should clearly show the distribution of numbers and highlight the marking sequence for prime detection.
The prompt above was compiled from the original drawing commands and is for reference only.