Back to Skills

construct-geometric-figure

pjt222
Updated Yesterday
2 views
17
2
17
View on GitHub
Metaword

About

This Claude skill performs classical Euclidean ruler-and-compass constructions, generating step-by-step instructions with justifications for each geometric operation. It handles tasks like creating perpendicular/angle bisectors, parallel lines, regular polygons, and tangents from given points, segments, or angles. Developers should use it to produce verifiable construction steps, check geometric constructibility, or create educational documentation.

Quick Install

Claude Code

Recommended
Primary
npx skills add pjt222/agent-almanac -a claude-code
Plugin CommandAlternative
/plugin add https://github.com/pjt222/agent-almanac
Git CloneAlternative
git clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/construct-geometric-figure

Copy and paste this command in Claude Code to install this skill

Documentation

Construct a Geometric Figure

Produce ruler-and-compass construction for specified figure → doc every step w/ Euclidean justification + valid. result vs. original spec.

Use When

  • Given specific geometric elements (points, segments, angles) + asked to construct figure
  • Tasked w/ producing classical Euclidean construction (bisectors, perpendiculars, tangents)
  • Valid. whether figure constructible w/ straightedge + compass alone
  • Gen construction instructions for ed / docs
  • Convert geometric spec → ordered seq of primitive ops

In

  • Required: Desc of target figure (e.g., "equilateral triangle w/ side length AB")
  • Required: Given elements (points, segments, circles, angles as starting data)
  • Optional: Out format (narrative prose, numbered steps, pseudocode, SVG coords)
  • Optional: Justification detail level (terse, standard, rigorous w/ theorem citations)
  • Optional: Include impossibility analysis if not constructible

Do

Step 1: Identify Given Elements + Target Figure

Parse problem statement → extract:

  1. Given elements -- list every point, segment, angle, circle, length provided.
  2. Target figure -- state precisely what must be constructed.
  3. Constraints -- note additional conditions (congruence, parallelism, tangency, collinearity).

Express problem in standard form:

Given: Points A, B; segment AB; circle C1 centered at A with radius r.
Construct: Equilateral triangle ABC with AB as one side.
Constraints: C must lie on the same side of AB as point P (if specified).

Valid. all ref'd elements well-defined + consistent.

Clear, unambiguous restatement of construction problem w/ every given element cataloged + target figure precisely described.

If err: Problem statement ambiguous → list possible interpretations + req clarification. Given elements contradictory (e.g., triangle w/ side lengths 1, 1, 5) → state contradiction + halt.

Step 2: Verify Constructibility

Determine whether target can be constructed w/ straightedge + compass alone.

  1. Check algebraic constraints. Length constructible iff lies in field extension of rationals obtained by successive sqrt. Requires cube roots / transcendental ops → impossible.

  2. Known impossible constructions:

    • Trisecting general angle
    • Doubling cube (constructing cube root of 2)
    • Squaring circle (constructing sqrt(pi))
    • Regular n-gon when n ≠ product of power of 2 + distinct Fermat primes
  3. Known constructible ops:

    • Bisecting any angle / segment
    • Constructing perpendiculars + parallels
    • Transferring given length
    • Regular n-gons for n in {3, 4, 5, 6, 8, 10, 12, 15, 16, 17, 20, ...}
    • Any length expressible using +, -, *, /, sqrt over given lengths
  4. Doc verdict w/ justification.

Constructibility analysis:
- Target: equilateral triangle on segment AB
- Required operations: circle-circle intersection (two arcs of radius AB)
- Algebraic degree: 2 (quadratic extension)
- Verdict: CONSTRUCTIBLE

Definitive yes/no verdict on constructibility, w/ brief justification citing relevant algebraic / classical result.

If err: Constructibility uncertain → reduce problem to known constructible primitives. Provably non-constructible → doc impossibility proof + suggest closest constructible approximation or alt method (e.g., neusis construction, origami).

Step 3: Plan Construction Sequence

Decompose target figure → seq of primitive ops.

  1. Identify primitives needed. Every ruler-and-compass reduces to these atomic ops:

    • Draw line through two points
    • Draw circle w/ given center + radius (center + point on circumference)
    • Mark intersection of two lines
    • Mark intersection(s) of line + circle
    • Mark intersection(s) of two circles
  2. Order ops. Each op must ref only points already existing (given or prev constructed). Build dep graph:

Step 1: Draw circle C1 centered at A through B.       [uses: A, B]
Step 2: Draw circle C2 centered at B through A.       [uses: A, B]
Step 3: Mark intersections of C1 and C2 as P, Q.      [uses: C1, C2]
Step 4: Draw line through P and Q.                     [uses: P, Q]
  1. Minimize step count. Look for opportunities to combine ops or reuse prev constructed elements.

  2. Annotate each step w/ geometric purpose (e.g., "This constructs perpendicular bisector of AB").

Ordered list of primitive ops where each step depends only on prev est'd elements, covering all parts of target.

If err: Decomp stalls → ID which part of figure can't be reached from current set of constructed points. Revisit Step 2 to confirm constructibility, or introduce auxiliary constructions (helper circles, midpoints, reflections) to bridge gap.

Step 4: Execute Construction Steps w/ Justification

Write each construction step in full, providing Euclidean justification.

Each primitive op → doc:

  1. Op: what is drawn / marked.
  2. Ins: which existing elements used.
  3. Justification: which Euclidean proposition / theorem / property guarantees op produces claimed result.
  4. Out: what new elements created.

Format each step consistent:

Step 3: Mark intersections of C1 and C2 as P and Q.
  - Operation: Circle-circle intersection
  - Inputs: C1 (center A, radius AB), C2 (center B, radius BA)
  - Justification: Two circles with equal radii whose centers are separated
    by less than the sum of their radii intersect in exactly two points,
    symmetric about the line of centers (Euclid I.1).
  - Output: Points P and Q, where AP = BP = AB (equilateral property).

Continue until target fully constructed. Complex figures → group related steps into phases (e.g., "Phase 1: Construct auxiliary perpendicular bisector", "Phase 2: Locate incenter").

Complete seq of justified construction steps that, executed in order, produce target. Every new point, line, circle accounted for.

If err: Can't provide justification for step → step may be invalid. Valid. geometric claim independently. Common errs: assuming two circles intersect when they don't (check distance between centers vs. sum/diff of radii), or assuming point lies on line w/o proof.

Step 5: Verify Construction Meets Specification

Confirm constructed figure satisfies all original reqs.

  1. Check each constraint from Step 1 vs. constructed figure:

    • Congruence: verify equal lengths / angles via construction.
    • Parallelism/perpendicularity: confirm via construction method (e.g., perpendicular bisector guarantees 90 deg).
    • Incidence: verify req'd points lie on req'd lines / circles.
  2. Count degrees of freedom. Constructed figure should have exactly number of free params implied by spec. Extra dof → spec under-determined. None + construction fails → spec over-determined / contradictory.

  3. Test w/ specific coords (optional but rec'd for complex constructions):

Verification with coordinates:
Let A = (0, 0), B = (1, 0).
C1: x^2 + y^2 = 1
C2: (x-1)^2 + y^2 = 1
Intersection: x = 1/2, y = sqrt(3)/2
Triangle ABC: sides AB = BC = CA = 1. VERIFIED.
  1. Doc verification result w/ clear pass/fail each constraint.

Every constraint from original spec verified, construction confirmed correct. Coord check (when done) matches geometric argument.

If err: Constraint fails → trace back through construction → find erroneous step. Common causes: incorrect intersection choice (wrong branch of circle-line intersection), sign err in coord verification, or missing auxiliary construction.

Check

  • Problem restated in standard Given/Construct/Constraints form
  • Constructibility analysis w/ clear verdict + justification
  • Every construction step uses only prev est'd elements
  • Every step includes op, ins, justification, out
  • Justification cites relevant geometric principle (Euclid, theorem name, property)
  • Target fully constructed (no missing components)
  • All original constraints verified vs. completed construction
  • No step relies on measurement, approximation, or non-constructible ops
  • Step count reasonable for figure complexity

Traps

  • Assume intersection exists: Two circles only intersect if distance between centers between |r1 - r2| + r1 + r2. Always valid. this before marking intersection points. Forgetting → constructions work on paper but fail geometrically.

  • Wrong intersection branch: Circle-circle + line-circle intersections yield two points. Construction must specify which to use (e.g., "intersection on same side of AB as point P"). Ambiguous intersection choices → two valid but diff figures.

  • Conflate construction w/ measurement: Ruler-and-compass doesn't allow measuring lengths / angles. Can't "measure segment AB, mark off same length." Use compass to transfer radius by drawing circle centered at new point through old endpoint.

  • Skip constructibility check: Attempting to trisect general angle or construct regular heptagon wastes effort. Always valid. constructibility before beginning construction seq.

  • Over-complicated seqs: Many constructions have elegant short solutions. Construction exceeds 15 primitive steps for standard figure → look for simpler approach. Classic sources (Euclid, Hartshorne) often provide minimal constructions.

  • Implicit auxiliary elements: Failing to doc helper constructions (e.g., "extend line AB to point D") makes seq impossible to follow. Every element used must be explicit constructed.

  • solve-trigonometric-problem - trig analysis often motivates / verifies constructions
  • prove-geometric-theorem - constructions frequently appear as steps in geometric proofs
  • create-skill - follow when packaging new construction as reusable skill

GitHub Repository

pjt222/agent-almanac
Path: i18n/caveman-ultra/skills/construct-geometric-figure
0
agentsagentskillsai-assisted-developmentclaude-codeskillsteams

Related Skills

content-collections

Meta

This skill provides a production-tested setup for Content Collections, a TypeScript-first tool that transforms Markdown/MDX files into type-safe data collections with Zod validation. Use it when building blogs, documentation sites, or content-heavy Vite + React applications to ensure type safety and automatic content validation. It covers everything from Vite plugin configuration and MDX compilation to deployment optimization and schema validation.

View skill

polymarket

Meta

This skill enables developers to build applications with the Polymarket prediction markets platform, including API integration for trading and market data. It also provides real-time data streaming via WebSocket to monitor live trades and market activity. Use it for implementing trading strategies or creating tools that process live market updates.

View skill

creating-opencode-plugins

Meta

This skill helps developers create OpenCode plugins that hook into 25+ event types like commands, files, and LSP operations. It provides the plugin structure, event API specifications, and implementation patterns for JavaScript/TypeScript modules. Use it when you need to intercept, monitor, or extend the OpenCode AI assistant's lifecycle with custom event-driven logic.

View skill

sglang

Meta

SGLang is a high-performance LLM serving framework that specializes in fast, structured generation for JSON, regex, and agentic workflows using its RadixAttention prefix caching. It delivers significantly faster inference, especially for tasks with repeated prefixes, making it ideal for complex, structured outputs and multi-turn conversations. Choose SGLang over alternatives like vLLM when you need constrained decoding or are building applications with extensive prefix sharing.

View skill