edu-analytic-geometry

Original：🇨🇳 Chinese

Translated

3 scriptsChecked / no sensitive code detected

Turn an analytic geometry problem into a self-contained interactive teaching webpage: left column with problem statement + dynamic console (a variable parameter slider driving real-time recalculation of geometric quantities + theoretical range/fixed value indication), middle column with step-by-step explanations using KaTeX, right column with 2D Canvas dynamic geometry drawing board (ellipse/hyperbola/parabola/circle + moving lines/moving points + vectors + annotations + brush doodling). Supports three entry points—given text problems, random problem generation, and solving problems after uploading and recognizing problem images. Covers problem types such as finding standard equations, chord lengths, vector dot product ranges/fixed values, triangle area maxima/minima, fixed points, fixed values (product of slopes), loci, and eccentricities. Uses a unified method of "setting parametric line x=my+c + simultaneous equations + Vieta's formulas + substitution/constant separation", driven by sympy for precise calculations (answers, coordinates, step values, and theoretical ranges of the interactive engine are consistent from the same source). Other agents can also call this skill to generate such webpages. It parallels edu-solid-geometry in form but uses Canvas-2D + KaTeX (instead of Three.js). Trigger words: 解析几何, 圆锥曲线, 椭圆, 双曲线, 抛物线, 直线与圆锥曲线, 焦点弦, 弦长, 数量积取值范围, 向量数量积, 定点问题, 定值问题, 斜率之积, 三角形面积最值, 轨迹方程, 离心率, 解这道解析几何题, 随机出一道圆锥曲线题, 这张图里的解析几何题; analytic geometry, conic sections, ellipse, hyperbola, parabola, chord length, dot product range, fixed point, fixed value, locus, eccentricity, interactive analytic geometry solution page.

2installs

Sourcewy51ai/edulab

Added on2026-08-23

NPX Install

npx skill4agent add wy51ai/edulab edu-analytic-geometry

SKILL.md Content (Chinese)

View Translation Comparison →

Analytic Geometry Problem Solving → Interactive Webpage

What This Skill Produces

A single-page HTML file that can be directly opened in a browser (three-column layout):

Left Column: Problem statement + dynamic console — a variable parameter slider (such as line inclination angle θ / moving point parameter t) drives real-time recalculation of geometric quantities (intersection coordinates, slopes, dot products, chord lengths, areas…), along with a "theoretical range bar" or "fixed value indicator".
Middle Column: Step-by-step explanations (formulas rendered with KaTeX), which can be collapsed with one click to make space for the drawing board.
Right Column: 2D Canvas dynamic geometry drawing board (conic sections + moving lines/moving points + vectors + point annotations + grid coordinate axes), with an overlay brush doodling toolbar.

It has the same form as the target template

/Users/wuyi/code/code2026/6/template/code_artifact.html

Dependencies (Important)

The calculation core

lib/analytic_kernel.py

depends on sympy. Before running the script, confirm you have an interpreter that can import sympy:

python3 -c "import sympy"

(local environment uses

/opt/homebrew/bin/python3.11

, sympy 1.14).

When libraries are missing: If an import error occurs (sympy or any subsequent library), first ask the user for permission to install, then install it (

python3 -m pip install <library name>

) or switch to an interpreter that already has the library installed; do not install without asking. The term

python3

below refers to this dependency-compatible interpreter.

Workflow

Step 1: Obtain problem spec (unify three entry points)

Organize the problem into a structured spec (curve type and parameters, known points/conditions, target type and object, language).

Text problems: Extract directly.
Images: Extract via visual reading, and echo the recognized problem to the user for confirmation (problem statement/curve/parameters/target/language) before proceeding.
Random problem generation: Select curve + problem type, generate random parameters → solve with kernel, use
```
analytic_kernel.is_clean(...)
```
to check if the answer is neat, re-select parameters if not.

Output language follows prompt language: English prompts → English webpage, Chinese prompts → Chinese webpage. Record
language
in the spec.

Step 2: Perform precise calculations with kernel (do not calculate manually)

Follow the solution recipe in

references/conventions.md

, call

lib/analytic_kernel.py

and

lib/conics.py

```
conics.ellipse/hyperbola/parabola/circle(...)
```
to get curve objects (precise a,b,c, foci, vertices, directrices, asymptotes,
```
eq_latex
```
, and
```
board
```
dict for front-end engine).
```
chord_setup(conic, through)
```
to set up simultaneous parametric line
```
x=my+c
```
and obtain quadratic equation in y + Vieta quantities (precise).

Target quantities:

dot_product_expr

chord_len_sq_expr

triangle_area_expr

slope_product_central

…

Value ranges:
```
range_over_m(expr, horizontal_valid=?)
```
— includes open/closed endpoint determination (key correctness point, see below).
Fixed values:
```
is_constant_in_m(expr)
```
.

Self-check the kernel via command line:

bash

python3 lib/analytic_kernel.py      # Built-in assertion self-check for flagship problems

⚠️ Endpoint open/closed = correctness critical point: For chords passing through foci, horizontal lines (x-axis, θ=0) and vertical lines (θ=90) are valid lines, and their endpoints should be included. Example: For an ellipse MA·MB problem, the x-axis gives −3 and the vertical line gives 7/4, so the answer is the closed interval
[-3, 7/4]
(many teaching materials incorrectly write it as the open interval
(-3, 7/4]
).
range_over_m
has already made this determination, and the answer is consistent with the interactive tool — drag the slider to 0° to read −3. The "axis direction" of a parabola's focal chord is a degenerate line (intersects at only one point), and its limit endpoints are not included (
horizontal_valid=False
or restrict param range).

Step 3: Assemble data and inject into template

📍 Output Location & Unique Product (Most Important): The only deliverable to the user is a single
.html
file, written to the current working directory (
Path.cwd()
) (unless the user explicitly specifies a path). Do not leave any other files in the cwd — build scripts (
.py
),
__pycache__
, self-check screenshots (
.png
), temporary files are not deliverables; place them in
/tmp
or delete them after use. Never write into the skill's own directory (
skills/edu-analytic-geometry/output/
is for internal skill samples).

Write the "assemble data + inject template" build script to a temporary directory (e.g.,

/tmp/ag_build.py

), make it only write the
.html
file to cwd; the script constructs

lesson

steps

board

data (schema see

references/problem-schema.md

), calls

generate.render_html(data, out)

to inject into

template/board.html

, delete the script immediately after running:

python

# Build script placed in /tmp (not cwd): /tmp/ag_build.py
import sys; sys.dont_write_bytecode = True            # Do not generate __pycache__
sys.path.insert(0, "<skill directory>/scripts")
import generate
from pathlib import Path
data = {"lesson": {...}, "steps": [...], "board": {...}}
out = Path.cwd() / "solution-<problem brief>.html"   # Unique product, located in user's current directory
generate.render_html(data, out)

bash

python3 -B /tmp/ag_build.py && rm -f /tmp/ag_build.py   # -B does not write bytecode; delete temporary script after running, only .html remains in cwd

Numerical values in
```
steps[*].content
```
directly reference kernel results (use
```
K.tex(...)
```
to output LaTeX), the model is only responsible for organizing explanatory text (in the target language).
```
board
```
is constructed using the curve's
```
board
```
dict from kernel, precise point coordinates,
```
param
```
,
```
derived
```
sequences,
```
readouts
```
,
```
rangeBar
```
(range problems)/
```
constant
```
(fixed value problems)/
```
answerBand
```
(shape parameter problems, such as eccentricity ranges).
Shape parameter problems (slider = eccentricity e, etc.): When the natural dynamic quantity is the curve's own shape rather than moving lines/moving points, set the slider to this parameter, write the curve's
```
a/b/c
```
, foci, moving point coordinates as expression strings with
@param
(the engine redraws the curve/foci/asymptotes every frame), match with
```
status
```
reading to display inequality status, and
```
answerBand
```
to highlight the answer interval on the parameter axis. See conventions "Shape Parameter Problems".
Copyable templates: The 6
```
build_*
```
functions in
```
scripts/generate.py
```
cover various interaction paradigms:
```
ellipse_dot_range
```
(range bar),
```
ellipse_chord_range
```
,
```
ellipse_area_max
```
,
```
ellipse_slopeprod_const
```
(fixed value · central symmetry),
```
parabola_dot_const
```
(fixed value · parabola),
```
hyperbola_ecc_range
```
(shape parameter: slider = e, curve redraws accordingly +
```
status
```
+
```
answerBand
```
).

Generate registered problems directly (

-B

does not write bytecode; default writes to skill output if no path is passed, must change to

.html

in cwd when delivering to users):

bash

python3 -B scripts/generate.py list                      # List problem types
python3 -B scripts/generate.py ellipse_dot_range ./sol.html
python3 -B scripts/generate.py all ./out_dir             # All problem types

Step 4: Self-check (Correctness Plan)

Kernel answer == answer card
```
lesson.answer
```
== final step display value == JS standard bit/segment scan recalculation value, all four are consistent (
```
assert
```
has been added in
```
build_*
```
).
```
rangeBar
```
endpoints come from kernel's
```
range_over_m
```
;
```
constant
```
value comes from kernel's fixed value.
Start a local static server (serving the directory where the output file is located, i.e., cwd) to preview and check: no console errors, KaTeX renders normally, slider recalculates in real-time correctly, range bar/fixed value/fixed point/locus behavior is correct, brush and panel collapse are usable. (When developing in the skill repository, use
```
ag-preview
```
in
```
.claude/launch.json
```
, port 4601; when running elsewhere, start a temporary static server for cwd.)
Self-check screenshots are for your own viewing only: The preview tool returns images directly, do not save
.png
to cwd; the local static server is read-only, no files are generated. Delete any temporary files generated during self-check (build scripts
```
.py
```
, screenshots
```
.png
```
,
```
__pycache__
```
, etc.) before delivery.

⚠️ Must close any ports/services you opened: Stop the server immediately after preview, never leave port-occupying processes running.
Opened by preview tool:
preview_stop
(pass serverId).
Directly started
http.server
: Use
kill
after use, or
lsof -nP -iTCP:<port> -sTCP:LISTEN
to confirm release.
Confirm ports are released before notifying the user. Not closing ports = incomplete self-check.

Step 5: Delivery

The finished product is written to the user's current working directory (cwd), named like

solution-<problem brief>.html

. Inform the user of the path, which can be directly opened in a browser. Before delivery, confirm: (1) The finished product is in cwd, not in the skill directory; (2) No local services/ports opened during this preview are left running; (3) Only this single
.html
file is newly added in cwd — no

.py

.png

__pycache__

/ temporary files (check with

git status

ls

, delete if any).

Expansion

Add problem types: Add target quantity functions (written as expressions of m) in
```
analytic_kernel.py
```
+ reuse
```
range_over_m
```
/
```
is_constant_in_m
```
; add a
```
build_*
```
function in
```
generate.py
```
, select an interaction paradigm (range bar / fixed value / fixed point / locus trace / shape parameter answerBand). See the recipe table in
```
references/conventions.md
```
.
Add curves:
```
conics.py
```
already has ellipse/hyperbola/parabola/circle; the front-end
```
board.html
```
engine already supports rendering of four types, asymptotes, and directrix directions. Just add new curves in both places.
Add interactive constructions: The
```
buildScene
```
switch in
```
board.html
```
is a construction library (
```
line_through_angle
```
,
```
intersect_line_conic
```
,
```
point_on_conic
```
,
```
point_reflect
```
,
```
tangent_at
```
,
```
foot_perp
```
…), expand as needed and register in the schema document.

edu-analytic-geometry

NPX Install

Tags

SKILL.md Content (Chinese)

Analytic Geometry Problem Solving → Interactive Webpage

What This Skill Produces

Dependencies (Important)

Workflow

Step 1: Obtain problem spec (unify three entry points)

Step 2: Perform precise calculations with kernel (do not calculate manually)

Step 3: Assemble data and inject into template

Step 4: Self-check (Correctness Plan)

Step 5: Delivery

Expansion

Directory