MathPlotAI Logo MathPlotAI

Comparing Fractions to Benchmarks with Upper/Lower Sum Ideas

Comparing Fractions to Benchmarks with Upper/Lower Sum Ideas
Loading the math board and drawing, please wait…
2021-01-12 22:08
PolygonCalculusInequalityGraphing
This example visualizes how fractions can be compared against a chosen benchmark (threshold) by constructing upper and lower sum–style accumulations over an interval. It highlights the idea that subdividing the domain into equal-width bins lets you form different “bounds” that can be visually compared to a reference level. Key math concepts include fraction comparison, upper/lower sums (Riemann-sum intuition), interval partitioning, and how conditional logic can determine which graphical parts represent the comparison outcome. Construction in GeoGebra centers on geometry-building commands: Polygon is used to draw the benchmark-related bin regions (e.g., polyBinA and related polygons), Segment connects defining points, Circle provides auxiliary markers, If controls conditional branches for display/selection based on inequalities, and RotateText improves annotation readability. The model also employs multiple point and dimension objects (e.g., bin offsets, bin width/height, bin corner points like BinAPt/BinBPt/BinCPt, and index/height parameters such as binA_1, d1c1_1…d1c1_8) to assemble the final comparison figure. Suitable for secondary students and early university learners studying fraction magnitude, discrete approximations, and the geometric intuition behind integration and Riemann sums; it can also support probability & statistics discussions when binning or distribution-like shapes (e.g., Poisson-related contexts) are emphasized.

GeoGebra Commands & Parameters

  1. Polygon(BinAPt, BinAPt + (binWidth, 0), BinAPt + (binWidth, binHeight), BinAPt + (0, binHeight)) → polyBinA, binA_1, binA_2, binA_3, binA
  2. Polygon(C1, C1 + (0.7, 0), C1 + (0.8, 0.1), C1 + (0.8, 1.85), C1 + (0.7, 1.95), C1 + (-0.7, 1.95), C1 + (-0.8, 1.85), C1 + (-0.8, 0.1), C1 + (-0.7, 0)) → polyD1C1, d1c1_7, d1c1_8, d1c1, d1c1_1, d1c1_2, d1c1_3, d1c1_4, d1c1_5, d1c1_6
  3. Polygon(C2, C2 + (0.7, 0), C2 + (0.8, 0.1), C2 + (0.8, 1.85), C2 + (0.7, 1.95), C2 + (-0.7, 1.95), C2 + (-0.8, 1.85), C2 + (-0.8, 0.1), C2 + (-0.7, 0)) → polyD1C2, d1c2_1, d1c2_2, d1c2_4, d1c2_5, d1c2_3, d1c2_6, d1c2_7, d1c2_8, d1c2
  4. Polygon(BinBPt, BinBPt + (binWidth, 0), BinBPt + (binWidth, binHeight), BinBPt + (0, binHeight)) → polyBinB, binB_1, binB_2, binB_3, binB
  5. Polygon(BinCPt, BinCPt + (binWidth, 0), BinCPt + (binWidth, binHeight), BinCPt + (0, binHeight)) → polyBinC, binC_1, binC_2, binC_3, binC
  6. Polygon(C3, C3 + (0.7, 0), C3 + (0.8, 0.1), C3 + (0.8, 1.85), C3 + (0.7, 1.95), C3 + (-0.7, 1.95), C3 + (-0.8, 1.85), C3 + (-0.8, 0.1), C3 + (-0.7, 0)) → polyD1C3, d1c3_1, d1c3_2, d1c3_3, d1c3_4, d1c3_5, d1c3_6, d1c3_7, d1c3_8, d1c3
  7. Polygon(C4, C4 + (0.7, 0), C4 + (0.8, 0.1), C4 + (0.8, 1.85), C4 + (0.7, 1.95), C4 + (-0.7, 1.95), C4 + (-0.8, 1.85), C4 + (-0.8, 0.1), C4 + (-0.7, 0)) → polyD1C4, d1c4_1, d1c4_2, d1c4_3, d1c4_4, d1c4_5, d1c4_6, d1c4_7, d1c4_8, d1c4
  8. Polygon(C5, C5 + (0.7, 0), C5 + (0.8, 0.1), C5 + (0.8, 1.85), C5 + (0.7, 1.95), C5 + (-0.7, 1.95), C5 + (-0.8, 1.85), C5 + (-0.8, 0.1), C5 + (-0.7, 0)) → polyD1C5, d1c5_1, d1c5_2, d1c5_3, d1c5_4, d1c5_5, d1c5_6, d1c5_7, d1c5_8, d1c5
  9. Polygon(C6, C6 + (0.7, 0), C6 + (0.8, 0.1), C6 + (0.8, 1.85), C6 + (0.7, 1.95), C6 + (-0.7, 1.95), C6 + (-0.8, 1.85), C6 + (-0.8, 0.1), C6 + (-0.7, 0)) → polyD1C6, d1c6_3, d1c6_4, d1c6_5, d1c6_6, d1c6_2, d1c6_1, d1c6_7, d1c6_8, d1c6_9
  10. Polygon(C7, C7 + (0.7, 0), C7 + (0.8, 0.1), C7 + (0.8, 1.85), C7 + (0.7, 1.95), C7 + (-0.7, 1.95), C7 + (-0.8, 1.85), C7 + (-0.8, 0.1), C7 + (-0.7, 0)) → polyD1C7, d1c7_1, d1c7_2, d1c7_3, d1c7_4, d1c7_5, d1c7_6, d1c7_7, d1c7_8, d1c7
  11. Polygon(C8, C8 + (0.7, 0), C8 + (0.8, 0.1), C8 + (0.8, 1.85), C8 + (0.7, 1.95), C8 + (-0.7, 1.95), C8 + (-0.8, 1.85), C8 + (-0.8, 0.1), C8 + (-0.7, 0)) → polyD1C8, d1c8_1, d1c8_2, d1c8_3, d1c8_4, d1c8_5, d1c8_6, d1c8_7, d1c8_8, d1c8
  12. Polygon(C9, C9 + (0.7, 0), C9 + (0.8, 0.1), C9 + (0.8, 1.85), C9 + (0.7, 1.95), C9 + (-0.7, 1.95), C9 + (-0.8, 1.85), C9 + (-0.8, 0.1), C9 + (-0.7, 0)) → polyD1C9, d1c9_1, d1c9_2, d1c9_3, d1c9_4, d1c9_5, d1c9_6, d1c9_7, d1c9_8, d1c9
  13. Polygon(C10, C10 + (0.7, 0), C10 + (0.8, 0.1), C10 + (0.8, 1.85), C10 + (0.7, 1.95), C10 + (-0.7, 1.95), C10 + (-0.8, 1.85), C10 + (-0.8, 0.1), C10 + (-0.7, 0)) → polyD1C10, d1c10_1, d1c10_2, d1c10_3, d1c10_4, d1c10_5, d1c10_6, d1c10_7, d1c10_8, d1c10
  14. Polygon(C11, C11 + (0.7, 0), C11 + (0.8, 0.1), C11 + (0.8, 1.85), C11 + (0.7, 1.95), C11 + (-0.7, 1.95), C11 + (-0.8, 1.85), C11 + (-0.8, 0.1), C11 + (-0.7, 0)) → polyD1C11, d1c11_1, d1c11_2, d1c11_3, d1c11_4, d1c11_5, d1c11_6, d1c11_7, d1c11_8, d1c11
  15. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 1) → C1numMaster
  16. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 1) → C1denomMaster
  17. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 2) → C2numMaster
  18. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 3) → C3numMaster
  19. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 4) → C4numMaster
  20. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 5) → C5numMaster
  21. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 6) → C6numMaster
  22. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 7) → C7numMaster
  23. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 8) → C8numMaster
  24. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 9) → C9numMaster
  25. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 10) → C10numMaster
  26. Element(If[deck ≟ 1, deck1num, If[deck ≟ 2, deck2num, deck3num]], 11) → C11numMaster
  27. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 2) → C2denomMaster
  28. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 3) → C3denomMaster
  29. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 4) → C4denomMaster
  30. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 5) → C5denomMaster
  31. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 6) → C6denomMaster
  32. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 7) → C7denomMaster
  33. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 8) → C8denomMaster
  34. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 9) → C9denomMaster
  35. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 10) → C10denomMaster
  36. Element(If[deck ≟ 1, deck1denom, If[deck ≟ 2, deck2denom, deck3denom]], 11) → C11denomMaster
  37. If(x(C1) ≥ x(BinAPt) ∧ x(C1) < x(BinAPt) + binWidth + binOffsetH ∧ y(C1) < y(BinAPt) + binHeight + binOffsetV ∧ y(C1) > y(BinAPt), 1, If[x(C1) ≥ x(BinBPt) ∧ x(C1) < x(BinBPt) + binWidth + binOffsetH ∧ y(C1) < y(BinBPt) + binHeight + binOffsetV ∧ y(C1) > y(BinBPt), 2, If[x(C1) ≥ x(BinCPt) ∧ x(C1) < x(BinCPt) + binWidth + binOffsetH ∧ y(C1) < y(BinCPt) + binHeight + binOffsetV ∧ y(C1) > y(BinCPt), 3, 0]]) → binC1
  38. If(x(C2) ≥ x(BinAPt) ∧ x(C2) < x(BinAPt) + binWidth + binOffsetH ∧ y(C2) < y(BinAPt) + binHeight + binOffsetV ∧ y(C2) > y(BinAPt), 1, If[x(C2) ≥ x(BinBPt) ∧ x(C2) < x(BinBPt) + binWidth + binOffsetH ∧ y(C2) < y(BinBPt) + binHeight + binOffsetV ∧ y(C2) > y(BinBPt), 2, If[x(C2) ≥ x(BinCPt) ∧ x(C2) < x(BinCPt) + binWidth + binOffsetH ∧ y(C2) < y(BinCPt) + binHeight + binOffsetV ∧ y(C2) > y(BinCPt), 3, 0]]) → binC2
  39. If(x(C3) ≥ x(BinAPt) ∧ x(C3) < x(BinAPt) + binWidth + binOffsetH ∧ y(C3) < y(BinAPt) + binHeight + binOffsetV ∧ y(C3) > y(BinAPt), 1, If[x(C3) ≥ x(BinBPt) ∧ x(C3) < x(BinBPt) + binWidth + binOffsetH ∧ y(C3) < y(BinBPt) + binHeight + binOffsetV ∧ y(C3) > y(BinBPt), 2, If[x(C3) ≥ x(BinCPt) ∧ x(C3) < x(BinCPt) + binWidth + binOffsetH ∧ y(C3) < y(BinCPt) + binHeight + binOffsetV ∧ y(C3) > y(BinCPt), 3, 0]]) → binC3
  40. If(x(C4) ≥ x(BinAPt) ∧ x(C4) < x(BinAPt) + binWidth + binOffsetH ∧ y(C4) < y(BinAPt) + binHeight + binOffsetV ∧ y(C4) > y(BinAPt), 1, If[x(C4) ≥ x(BinBPt) ∧ x(C4) < x(BinBPt) + binWidth + binOffsetH ∧ y(C4) < y(BinBPt) + binHeight + binOffsetV ∧ y(C4) > y(BinBPt), 2, If[x(C4) ≥ x(BinCPt) ∧ x(C4) < x(BinCPt) + binWidth + binOffsetH ∧ y(C4) < y(BinCPt) + binHeight + binOffsetV ∧ y(C4) > y(BinCPt), 3, 0]]) → binC4
  41. If(x(C5) ≥ x(BinAPt) ∧ x(C5) < x(BinAPt) + binWidth + binOffsetH ∧ y(C5) < y(BinAPt) + binHeight + binOffsetV ∧ y(C5) > y(BinAPt), 1, If[x(C5) ≥ x(BinBPt) ∧ x(C5) < x(BinBPt) + binWidth + binOffsetH ∧ y(C5) < y(BinBPt) + binHeight + binOffsetV ∧ y(C5) > y(BinBPt), 2, If[x(C5) ≥ x(BinCPt) ∧ x(C5) < x(BinCPt) + binWidth + binOffsetH ∧ y(C5) < y(BinCPt) + binHeight + binOffsetV ∧ y(C5) > y(BinCPt), 3, 0]]) → binC5
  42. If(x(C6) ≥ x(BinAPt) ∧ x(C6) < x(BinAPt) + binWidth + binOffsetH ∧ y(C6) < y(BinAPt) + binHeight + binOffsetV ∧ y(C6) > y(BinAPt), 1, If[x(C6) ≥ x(BinBPt) ∧ x(C6) < x(BinBPt) + binWidth + binOffsetH ∧ y(C6) < y(BinBPt) + binHeight + binOffsetV ∧ y(C6) > y(BinBPt), 2, If[x(C6) ≥ x(BinCPt) ∧ x(C6) < x(BinCPt) + binWidth + binOffsetH ∧ y(C6) < y(BinCPt) + binHeight + binOffsetV ∧ y(C6) > y(BinCPt), 3, 0]]) → binC6
  43. If(x(C7) ≥ x(BinAPt) ∧ x(C7) < x(BinAPt) + binWidth + binOffsetH ∧ y(C7) < y(BinAPt) + binHeight + binOffsetV ∧ y(C7) > y(BinAPt), 1, If[x(C7) ≥ x(BinBPt) ∧ x(C7) < x(BinBPt) + binWidth + binOffsetH ∧ y(C7) < y(BinBPt) + binHeight + binOffsetV ∧ y(C7) > y(BinBPt), 2, If[x(C7) ≥ x(BinCPt) ∧ x(C7) < x(BinCPt) + binWidth + binOffsetH ∧ y(C7) < y(BinCPt) + binHeight + binOffsetV ∧ y(C7) > y(BinCPt), 3, 0]]) → binC7
  44. If(x(C8) ≥ x(BinAPt) ∧ x(C8) < x(BinAPt) + binWidth + binOffsetH ∧ y(C8) < y(BinAPt) + binHeight + binOffsetV ∧ y(C8) > y(BinAPt), 1, If[x(C8) ≥ x(BinBPt) ∧ x(C8) < x(BinBPt) + binWidth + binOffsetH ∧ y(C8) < y(BinBPt) + binHeight + binOffsetV ∧ y(C8) > y(BinBPt), 2, If[x(C8) ≥ x(BinCPt) ∧ x(C8) < x(BinCPt) + binWidth + binOffsetH ∧ y(C8) < y(BinCPt) + binHeight + binOffsetV ∧ y(C8) > y(BinCPt), 3, 0]]) → binC8
  45. If(x(C9) ≥ x(BinAPt) ∧ x(C9) < x(BinAPt) + binWidth + binOffsetH ∧ y(C9) < y(BinAPt) + binHeight + binOffsetV ∧ y(C9) > y(BinAPt), 1, If[x(C9) ≥ x(BinBPt) ∧ x(C9) < x(BinBPt) + binWidth + binOffsetH ∧ y(C9) < y(BinBPt) + binHeight + binOffsetV ∧ y(C9) > y(BinBPt), 2, If[x(C9) ≥ x(BinCPt) ∧ x(C9) < x(BinCPt) + binWidth + binOffsetH ∧ y(C9) < y(BinCPt) + binHeight + binOffsetV ∧ y(C9) > y(BinCPt), 3, 0]]) → binC9
  46. If(x(C10) ≥ x(BinAPt) ∧ x(C10) < x(BinAPt) + binWidth + binOffsetH ∧ y(C10) < y(BinAPt) + binHeight + binOffsetV ∧ y(C10) > y(BinAPt), 1, If[x(C10) ≥ x(BinBPt) ∧ x(C10) < x(BinBPt) + binWidth + binOffsetH ∧ y(C10) < y(BinBPt) + binHeight + binOffsetV ∧ y(C10) > y(BinBPt), 2, If[x(C10) ≥ x(BinCPt) ∧ x(C10) < x(BinCPt) + binWidth + binOffsetH ∧ y(C10) < y(BinCPt) + binHeight + binOffsetV ∧ y(C10) > y(BinCPt), 3, 0]]) → binC10
  47. If(x(C11) ≥ x(BinAPt) ∧ x(C11) < x(BinAPt) + binWidth + binOffsetH ∧ y(C11) < y(BinAPt) + binHeight + binOffsetV ∧ y(C11) > y(BinAPt), 1, If[x(C11) ≥ x(BinBPt) ∧ x(C11) < x(BinBPt) + binWidth + binOffsetH ∧ y(C11) < y(BinBPt) + binHeight + binOffsetV ∧ y(C11) > y(BinBPt), 2, If[x(C11) ≥ x(BinCPt) ∧ x(C11) < x(BinCPt) + binWidth + binOffsetH ∧ y(C11) < y(BinCPt) + binHeight + binOffsetV ∧ y(C11) > y(BinCPt), 3, 0]]) → binC11
  48. If(deck ≟ 1, correctPlaceDeck1, If[deck ≟ 2, correctPlaceDeck2, correctPlaceDeck3]) → correctPlaceDeckMaster
  49. If(Element[correctPlaceDeck1All, 1] ≟ correctBinA ∧ Element[correctPlaceDeck1All, 2] ≟ correctBinB ∧ Element[correctPlaceDeck1All, 3] ≟ correctBinC, true, false) → correctDeck1
  50. If(Element[correctPlaceDeck2All, 1] ≟ correctBinA ∧ Element[correctPlaceDeck2All, 2] ≟ correctBinB ∧ Element[correctPlaceDeck2All, 3] ≟ correctBinC, true, false) → correctDeck2
  51. If(Element[correctPlaceDeck3All, 1] ≟ correctBinA ∧ Element[correctPlaceDeck3All, 2] ≟ correctBinB ∧ Element[correctPlaceDeck3All, 3] ≟ correctBinC, true, false) → correctDeck3
  52. Polygon(C1, C1 + (0.7, 0), C1 + (0.8, 0.1), C1 + (0.8, 1.85), C1 + (0.7, 1.95), C1 + (-0.7, 1.95), C1 + (-0.8, 1.85), C1 + (-0.8, 0.1), C1 + (-0.7, 0)) → polyHintC1, d, e, f, g, h, i, j, k, l
  53. Polygon(C2, C2 + (0.7, 0), C2 + (0.8, 0.1), C2 + (0.8, 1.85), C2 + (0.7, 1.95), C2 + (-0.7, 1.95), C2 + (-0.8, 1.85), C2 + (-0.8, 0.1), C2 + (-0.7, 0)) → polyHintC2, m, n, p, q, r, s, t, a_1, b_1
  54. Polygon(C3, C3 + (0.7, 0), C3 + (0.8, 0.1), C3 + (0.8, 1.85), C3 + (0.7, 1.95), C3 + (-0.7, 1.95), C3 + (-0.8, 1.85), C3 + (-0.8, 0.1), C3 + (-0.7, 0)) → polyHintC3, c_1, d_1, e_1, f_1, g_1, h_1, i_1, j_1, k_1
  55. Polygon(C4, C4 + (0.7, 0), C4 + (0.8, 0.1), C4 + (0.8, 1.85), C4 + (0.7, 1.95), C4 + (-0.7, 1.95), C4 + (-0.8, 1.85), C4 + (-0.8, 0.1), C4 + (-0.7, 0)) → polyHintC4, l_1, m_1, n_1, p_1, q_1, r_1, s_1, t_1, a_2
  56. Polygon(C5, C5 + (0.7, 0), C5 + (0.8, 0.1), C5 + (0.8, 1.85), C5 + (0.7, 1.95), C5 + (-0.7, 1.95), C5 + (-0.8, 1.85), C5 + (-0.8, 0.1), C5 + (-0.7, 0)) → polyHintC5, b_2, c_2, d_2, e_2, f_2, g_2, h_2, i_2, j_2
  57. Polygon(C6, C6 + (0.7, 0), C6 + (0.8, 0.1), C6 + (0.8, 1.85), C6 + (0.7, 1.95), C6 + (-0.7, 1.95), C6 + (-0.8, 1.85), C6 + (-0.8, 0.1), C6 + (-0.7, 0)) → polyHintC6, k_2, l_2, m_2, n_2, p_2, q_2, r_2, s_2, t_2
  58. Polygon(C7, C7 + (0.7, 0), C7 + (0.8, 0.1), C7 + (0.8, 1.85), C7 + (0.7, 1.95), C7 + (-0.7, 1.95), C7 + (-0.8, 1.85), C7 + (-0.8, 0.1), C7 + (-0.7, 0)) → polyHintC7, a_3, b_3, c_3, d_3, e_3, f_3, g_3, h_3, i_3
  59. Polygon(C8, C8 + (0.7, 0), C8 + (0.8, 0.1), C8 + (0.8, 1.85), C8 + (0.7, 1.95), C8 + (-0.7, 1.95), C8 + (-0.8, 1.85), C8 + (-0.8, 0.1), C8 + (-0.7, 0)) → polyHintC8, j_3, k_3, l_3, m_3, n_3, p_3, q_3, r_3, s_3
  60. Polygon(C9, C9 + (0.7, 0), C9 + (0.8, 0.1), C9 + (0.8, 1.85), C9 + (0.7, 1.95), C9 + (-0.7, 1.95), C9 + (-0.8, 1.85), C9 + (-0.8, 0.1), C9 + (-0.7, 0)) → polyHintC9, t_3, a_4, b_4, c_4, d_4, e_4, f_4, g_4, h_4
  61. Polygon(C10, C10 + (0.7, 0), C10 + (0.8, 0.1), C10 + (0.8, 1.85), C10 + (0.7, 1.95), C10 + (-0.7, 1.95), C10 + (-0.8, 1.85), C10 + (-0.8, 0.1), C10 + (-0.7, 0)) → polyHintC10, i_4, j_4, k_4, l_4, m_4, n_4, p_4, q_4, r_4
  62. Polygon(C11, C11 + (0.7, 0), C11 + (0.8, 0.1), C11 + (0.8, 1.85), C11 + (0.7, 1.95), C11 + (-0.7, 1.95), C11 + (-0.8, 1.85), C11 + (-0.8, 0.1), C11 + (-0.7, 0)) → polyHintC11, s_4, t_4, a_5, b_5, c_5, d_5, e_5, f_5, g_5
  63. If(countBinA + countBinB + countBinC ≟ 11 ∧ correctBinA + correctBinB + correctBinC ≟ 11 ∧ correctBinA ≟ countBinA ∧ correctBinB ≟ countBinB ∧ correctBinC ≟ countBinC, true, false) → correctAll
  64. Polygon(DeckPt, DeckPt + (0.7, 0), DeckPt + (0.8, 0.1), DeckPt + (0.8, 1.85), DeckPt + (0.7, 1.95), DeckPt + (-0.7, 1.95), DeckPt + (-0.8, 1.85), DeckPt + (-0.8, 0.1), DeckPt + (-0.7, 0)) → deckFlipPoly, deckFlipPolySeg_1, deckFlipPolySeg_2, deckFlipPolySeg_3, deckFlipPolySeg_4, deckFlipPolySeg_5, deckFlipPolySeg_6, deckFlipPolySeg_7, deckFlipPolySeg_8, deckFlipPolySeg
  65. RotateText("hidden card", 52°) → overlapWarn1
  66. RotateText("hidden card", 52°) → overlapWarn2
  67. RotateText("hidden card", 52°) → overlapWarn3
  68. RotateText("hidden card", 52°) → overlapWarn4
  69. RotateText("hidden card", 52°) → overlapWarn5
  70. RotateText("hidden card", 52°) → overlapWarn6
  71. RotateText("hidden card", 52°) → overlapWarn7
  72. RotateText("hidden card", 52°) → overlapWarn8
  73. RotateText("hidden card", 52°) → overlapWarn9
  74. RotateText("hidden card", 52°) → overlapWarn10
  75. If(C1numMaster / C1denomMaster ≤ 1, Circle[C1 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C1 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C1hintCircle
  76. Circle(C1 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C1hintCircle1
  77. If(C10numMaster / C10denomMaster ≤ 1, Circle[C10 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C10 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C10hintCircle
  78. If(C11numMaster / C11denomMaster ≤ 1, Circle[C11 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C11 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C11hintCircle
  79. If(C2numMaster / C2denomMaster ≤ 1, Circle[C2 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C2 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C2hintCircle
  80. If(C3numMaster / C3denomMaster ≤ 1, Circle[C3 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C3 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C3hintCircle
  81. If(C4numMaster / C4denomMaster ≤ 1, Circle[C4 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C4 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C4hintCircle
  82. If(C5numMaster / C5denomMaster ≤ 1, Circle[C5 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C5 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C5hintCircle
  83. If(C6numMaster / C6denomMaster ≤ 1, Circle[C6 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C6 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C6hintCircle
  84. If(C7numMaster / C7denomMaster ≤ 1, Circle[C7 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C7 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C7hintCircle
  85. If(C8numMaster / C8denomMaster ≤ 1, Circle[C8 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C8 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C8hintCircle
  86. If(C9numMaster / C9denomMaster ≤ 1, Circle[C9 + (hintOffsetH, hintOffsetV), hintRadius], Circle[C9 + (hintOffsetH, hintOffsetV + hintOffsetV2), hintRadius]) → C9hintCircle
  87. Circle(C11 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C11hintCircle1
  88. Circle(C10 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C10hintCircle1
  89. Circle(C9 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C9hintCircle1
  90. Circle(C8 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C8hintCircle1
  91. Circle(C7 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C7hintCircle1
  92. Circle(C6 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C6hintCircle1
  93. Circle(C4 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C4hintCircle1
  94. Circle(C3 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C3hintCircle1
  95. Circle(C2 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C2hintCircle1
  96. If(C1numMaster / C1denomMaster ≤ 1, Sequence[Segment[Rotate[C1 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C1denomMaster)°), C1 + (hintOffsetH, hintOffsetV)], C1 + (hintOffsetH, hintOffsetV)], i, 0, C1denomMaster - 1], Sequence[Segment[Rotate[C1 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C1denomMaster)°), C1 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C1 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C1denomMaster - 1]) → C1hintDiv
  97. If(C2numMaster / C2denomMaster ≤ 1, Sequence[Segment[Rotate[C2 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C2denomMaster)°), C2 + (hintOffsetH, hintOffsetV)], C2 + (hintOffsetH, hintOffsetV)], i, 0, C2denomMaster - 1], Sequence[Segment[Rotate[C2 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C2denomMaster)°), C2 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C2 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C2denomMaster - 1]) → C2hintDiv
  98. If(C3numMaster / C3denomMaster ≤ 1, Sequence[Segment[Rotate[C3 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C3denomMaster)°), C3 + (hintOffsetH, hintOffsetV)], C3 + (hintOffsetH, hintOffsetV)], i, 0, C3denomMaster - 1], Sequence[Segment[Rotate[C3 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C3denomMaster)°), C3 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C3 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C3denomMaster - 1]) → C3hintDiv
  99. If(C4numMaster / C4denomMaster ≤ 1, Sequence[Segment[Rotate[C4 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C4denomMaster)°), C4 + (hintOffsetH, hintOffsetV)], C4 + (hintOffsetH, hintOffsetV)], i, 0, C4denomMaster - 1], Sequence[Segment[Rotate[C4 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C4denomMaster)°), C4 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C4 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C4denomMaster - 1]) → C4hintDiv
  100. If(C5numMaster / C5denomMaster ≤ 1, Sequence[Segment[Rotate[C5 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C5denomMaster)°), C5 + (hintOffsetH, hintOffsetV)], C5 + (hintOffsetH, hintOffsetV)], i, 0, C5denomMaster - 1], Sequence[Segment[Rotate[C5 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C5denomMaster)°), C5 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C5 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C5denomMaster - 1]) → C5hintDiv
  101. If(C6numMaster / C6denomMaster ≤ 1, Sequence[Segment[Rotate[C6 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C6denomMaster)°), C6 + (hintOffsetH, hintOffsetV)], C6 + (hintOffsetH, hintOffsetV)], i, 0, C6denomMaster - 1], Sequence[Segment[Rotate[C6 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C6denomMaster)°), C6 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C6 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C6denomMaster - 1]) → C6hintDiv
  102. If(C7numMaster / C7denomMaster ≤ 1, Sequence[Segment[Rotate[C7 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C7denomMaster)°), C7 + (hintOffsetH, hintOffsetV)], C7 + (hintOffsetH, hintOffsetV)], i, 0, C7denomMaster - 1], Sequence[Segment[Rotate[C7 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C7denomMaster)°), C7 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C7 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C7denomMaster - 1]) → C7hintDiv
  103. If(C8numMaster / C8denomMaster ≤ 1, Sequence[Segment[Rotate[C8 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C8denomMaster)°), C8 + (hintOffsetH, hintOffsetV)], C8 + (hintOffsetH, hintOffsetV)], i, 0, C8denomMaster - 1], Sequence[Segment[Rotate[C8 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C8denomMaster)°), C8 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C8 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C8denomMaster - 1]) → C8hintDiv
  104. If(C9numMaster / C9denomMaster ≤ 1, Sequence[Segment[Rotate[C9 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C9denomMaster)°), C9 + (hintOffsetH, hintOffsetV)], C9 + (hintOffsetH, hintOffsetV)], i, 0, C9denomMaster - 1], Sequence[Segment[Rotate[C9 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C9denomMaster)°), C9 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C9 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C9denomMaster - 1]) → C9hintDiv
  105. If(C10numMaster / C10denomMaster ≤ 1, Sequence[Segment[Rotate[C10 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C10denomMaster)°), C10 + (hintOffsetH, hintOffsetV)], C10 + (hintOffsetH, hintOffsetV)], i, 0, C10denomMaster - 1], Sequence[Segment[Rotate[C10 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C10denomMaster)°), C10 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C10 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C10denomMaster - 1]) → C10hintDiv
  106. If(C11numMaster / C11denomMaster ≤ 1, Sequence[Segment[Rotate[C11 + (hintOffsetH + hintRadius, hintOffsetV), (360 * (i / C11denomMaster)°), C11 + (hintOffsetH, hintOffsetV)], C11 + (hintOffsetH, hintOffsetV)], i, 0, C11denomMaster - 1], Sequence[Segment[Rotate[C11 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (360 * (i / C11denomMaster)°), C11 + (hintOffsetH, hintOffsetV + hintOffsetV2)], C11 + (hintOffsetH, hintOffsetV + hintOffsetV2)], i, 0, C11denomMaster - 1]) → C11hintDiv
  107. If(C1numMaster / C1denomMaster ≤ 1, CircleSector[C1 + (hintOffsetH, hintOffsetV), C1 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C1 + (hintOffsetH + hintRadius, hintOffsetV), (C1numMaster * (360 / C1denomMaster)°), C1 + (hintOffsetH, hintOffsetV)]], CircleSector[C1 + (hintOffsetH, hintOffsetV + hintOffsetV2), C1 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C1 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C1numMaster * (360 / C1denomMaster)°), C1 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C1hintSector
  108. If(C2numMaster / C2denomMaster ≤ 1, CircleSector[C2 + (hintOffsetH, hintOffsetV), C2 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C2 + (hintOffsetH + hintRadius, hintOffsetV), (C2numMaster * (360 / C2denomMaster)°), C2 + (hintOffsetH, hintOffsetV)]], CircleSector[C2 + (hintOffsetH, hintOffsetV + hintOffsetV2), C2 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C2 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C2numMaster * (360 / C2denomMaster)°), C2 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C2hintSector
  109. If(C3numMaster / C3denomMaster ≤ 1, CircleSector[C3 + (hintOffsetH, hintOffsetV), C3 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C3 + (hintOffsetH + hintRadius, hintOffsetV), (C3numMaster * (360 / C3denomMaster)°), C3 + (hintOffsetH, hintOffsetV)]], CircleSector[C3 + (hintOffsetH, hintOffsetV + hintOffsetV2), C3 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C3 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C3numMaster * (360 / C3denomMaster)°), C3 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C3hintSector
  110. If(C4numMaster / C4denomMaster ≤ 1, CircleSector[C4 + (hintOffsetH, hintOffsetV), C4 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C4 + (hintOffsetH + hintRadius, hintOffsetV), (C4numMaster * (360 / C4denomMaster)°), C4 + (hintOffsetH, hintOffsetV)]], CircleSector[C4 + (hintOffsetH, hintOffsetV + hintOffsetV2), C4 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C4 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C4numMaster * (360 / C4denomMaster)°), C4 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C4hintSector
  111. If(C5numMaster / C5denomMaster ≤ 1, CircleSector[C5 + (hintOffsetH, hintOffsetV), C5 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C5 + (hintOffsetH + hintRadius, hintOffsetV), (C5numMaster * (360 / C5denomMaster)°), C5 + (hintOffsetH, hintOffsetV)]], CircleSector[C5 + (hintOffsetH, hintOffsetV + hintOffsetV2), C5 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C5 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C5numMaster * (360 / C5denomMaster)°), C5 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C5hintSector
  112. If(C6numMaster / C6denomMaster ≤ 1, CircleSector[C6 + (hintOffsetH, hintOffsetV), C6 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C6 + (hintOffsetH + hintRadius, hintOffsetV), (C6numMaster * (360 / C6denomMaster)°), C6 + (hintOffsetH, hintOffsetV)]], CircleSector[C6 + (hintOffsetH, hintOffsetV + hintOffsetV2), C6 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C6 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C6numMaster * (360 / C6denomMaster)°), C6 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C6hintSector
  113. If(C7numMaster / C7denomMaster ≤ 1, CircleSector[C7 + (hintOffsetH, hintOffsetV), C7 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C7 + (hintOffsetH + hintRadius, hintOffsetV), (C7numMaster * (360 / C7denomMaster)°), C7 + (hintOffsetH, hintOffsetV)]], CircleSector[C7 + (hintOffsetH, hintOffsetV + hintOffsetV2), C7 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C7 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C7numMaster * (360 / C7denomMaster)°), C7 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C7hintSector
  114. If(C8numMaster / C8denomMaster ≤ 1, CircleSector[C8 + (hintOffsetH, hintOffsetV), C8 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C8 + (hintOffsetH + hintRadius, hintOffsetV), (C8numMaster * (360 / C8denomMaster)°), C8 + (hintOffsetH, hintOffsetV)]], CircleSector[C8 + (hintOffsetH, hintOffsetV + hintOffsetV2), C8 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C8 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C8numMaster * (360 / C8denomMaster)°), C8 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C8hintSector
  115. If(C9numMaster / C9denomMaster ≤ 1, CircleSector[C9 + (hintOffsetH, hintOffsetV), C9 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C9 + (hintOffsetH + hintRadius, hintOffsetV), (C9numMaster * (360 / C9denomMaster)°), C9 + (hintOffsetH, hintOffsetV)]], CircleSector[C9 + (hintOffsetH, hintOffsetV + hintOffsetV2), C9 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C9 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C9numMaster * (360 / C9denomMaster)°), C9 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C9hintSector
  116. If(C10numMaster / C10denomMaster ≤ 1, CircleSector[C10 + (hintOffsetH, hintOffsetV), C10 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C10 + (hintOffsetH + hintRadius, hintOffsetV), (C10numMaster * (360 / C10denomMaster)°), C10 + (hintOffsetH, hintOffsetV)]], CircleSector[C10 + (hintOffsetH, hintOffsetV + hintOffsetV2), C10 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C10 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C10numMaster * (360 / C10denomMaster)°), C10 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C10hintSector
  117. If(C11numMaster / C11denomMaster ≤ 1, CircleSector[C11 + (hintOffsetH, hintOffsetV), C11 + (hintOffsetH + hintRadius, hintOffsetV), Rotate[C11 + (hintOffsetH + hintRadius, hintOffsetV), (C11numMaster * (360 / C11denomMaster)°), C11 + (hintOffsetH, hintOffsetV)]], CircleSector[C11 + (hintOffsetH, hintOffsetV + hintOffsetV2), C11 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), Rotate[C11 + (hintOffsetH + hintRadius, hintOffsetV + hintOffsetV2), (C11numMaster * (360 / C11denomMaster)°), C11 + (hintOffsetH, hintOffsetV + hintOffsetV2)]]) → C11hintSector
  118. If(ckPrior, -0.75, -0.2) → labelOffsetH
  119. Circle(C5 + (hintOffsetH, hintOffsetV - hintOffsetV2), hintRadius) → C5hintCircle1
  120. If(Element[ckOverlap, 1] ∨ Element[ckOverlap, 2] ∨ Element[ckOverlap, 3] ∨ Element[ckOverlap, 4] ∨ Element[ckOverlap, 5] ∨ Element[ckOverlap, 6] ∨ Element[ckOverlap, 7] ∨ Element[ckOverlap, 8] ∨ Element[ckOverlap, 9] ∨ Element[ckOverlap, 10], true, false) → anyOverlap
  121. Segment(A, B) → adeckHideRtSeg
  122. Segment(B, C) → adeckHideBottomSeg
  123. Segment(C + (0, -0.05), B + (0, -0.05)) → adeckHideBottom2Seg
  124. Segment(A + (0.1, 0), B + (0.1, 0)) → adeckHideRt2Seg

AI Drawing Prompt Reference

Create a visual for comparing fractions to a benchmark. Place three rectangular benchmark regions on the plane, each as an equal-width and equal-height rectangle with horizontal and vertical offsets. Scatter multiple circular point markers near the regions, each surrounded by a polygon outline with many vertices forming a flower-like or gear-like shape. These points and polygons are assigned to different benchmark regions based on their positions via conditional logic. Include auxiliary segments and text labels to show comparison outcomes. The layout emphasizes partitioning, comparison, and upper/lower bound ideas.
The prompt above was compiled from the original drawing commands and is for reference only.