FluxGeo User Guide

1. FluxGeo Syntax and ScriptBlocks

FluxGeo Syntax is the exact, editable language used by the ScriptBlock system and the desktop Input Bar. A ScriptBlock groups durable sliders, scalar expressions, user-defined scalar functions, generated loops, and generated-group styles into one source document.

Use the canonical brace form for all new work:

script Example {
    T = Slider(0, 10, 0, 0.1)

    Art = pointcloud for i in -20..20 {
        P_i = (i, sin(i + T))
    }

    style Art {
        pointSize = 2
        visible = true
    }
}

Braces define blocks; indentation is cosmetic. Zero indentation is valid, regular indentation is recommended, and tabs or spaces do not change meaning. Braces inside strings and comments do not define blocks. FluxGeo retains the exact submitted source formatting for editing, diagnostics, and save/load.

2. Running a ScriptBlock

Open Run Script... from the CLI panel, paste a complete script Name { ... } wrapper, and choose Run. Desktop compact mode runs on Enter; the expanded editor uses Enter for new lines and Ctrl+Enter to run.

3. Brace-scoped blocks

Script wrappers, generated loops, and style blocks use braces. A missing closing brace produces a structural diagnostic. Legacy script Name:, loop-colon, and inline style-colon forms remain compatibility syntax where the parser still accepts them; they are not the recommended form and all examples in this guide use braces.

4. Scalars and expressions

Scalar expressions support +, -, *, /, %, and ^, plus comparisons <, <=, >, >=, ==, and !=. Logical operators are !, &&, and ||. Boolean values are numeric: true is 1 and false is 0.

if(condition, whenTrue, whenFalse) is lazy: only the selected branch is evaluated. Likewise, && and || short-circuit. Trigonometric functions use radians. The evaluator provides isfinite, isnan, and isvalid checks.

SafeDivide(a, b) = if(b != 0, a / b, 0)
SafeDivide(4, 0)   # returns 0 without evaluating 4 / 0

Do not use and, or, not, ?:, or if ... then ... else; those are not v1.4-beta forms.

5. Sliders and animation

Both positional and named Slider forms are supported:

T = Slider(0, 120, 0, 0.05)
T = Slider(
    min=0,
    max=120,
    value=0,
    step=0.05,
    speed=1,
    direction=forward,
    mode=bounce
)

direction is forward or backward. mode is stop, wrap, or bounce; the parser also accepts the verified compatibility aliases both, both-directions, and loop. Sliders expose inline Algebra play/pause and speed controls. Script-created Sliders start paused. A Slider at a stop mode ends at its boundary; wrap loops to the other boundary; bounce reverses direction.

Slider values and dependent numeric variables, points, and generated clouds update through their dependency bindings. Slider definitions and values persist through save/load.

6. Conditions and safe expressions

Use comparisons and short-circuit logic to keep generated samples finite. A where clause rejects a tuple before its point output is emitted. Put division guards in the condition or use lazy if for a bounded result.

7. User-defined scalar functions

Square(x) = x^2
Scale(x) = x * T
SafeDivide(a, b) = if(b != 0, a / b, 0)

User functions return scalar values only, require at least one parameter, and use exact argument counts. Parameters are local. Nested calls are supported, but define callees before callers; forward references, recursion, silent redefinition, zero-argument functions, and point-valued returns are rejected. Function names and calls are case-sensitive, while collisions with built-ins, constants, and booleans are rejected case-insensitively.

For dense animated clouds, calculate shared intermediate values as loop-local variables. Repeated nested function calls are readable, but results are not automatically memoized per sample.

# readable, but repeats work at every sample
P_i_j = (Scale(sin(i) + cos(j)), Scale(sin(i) + cos(j)))

# preferred for dense animation
sharedValue = sin(i) + cos(j)
P_i_j = (Scale(sharedValue), Scale(sharedValue))

8. Generated loops

Ranges are inclusive integer ranges. One or two indices are supported, with optional integer step. If the start is greater than the end, the implicit step is -1; explicit descending steps must be negative.

Curve = for i in -20..20 step 2 {
    yValue = i^2
    P_i = (i, yValue)
}

SafeGrid = pointcloud for i in -5..5, j in -5..5 where j != 0 {
    ratio = i / j
    P_i_j = (i, ratio)
}

Loop-local scalar assignments and expression-point assignments are evaluated sequentially for each tuple. External sliders and scalars may be referenced. A loop-local assignment is parsed as one physical line; keep each local assignment on one line when the expression itself spans multiple tokens. The body can contain multiple statements separated by lines or semicolons.

9. where, step, and loop-local values

where belongs to the loop header and is evaluated from the loop indices plus external scalar/Slider and function bindings. It runs before the body-local scalar values are computed, so it cannot read ratio, height, or another name assigned inside the body. The filter is useful for safe index conditions such as j != 0; body-local safety belongs in if.

10. for versus pointcloud for versus objects for

Art = for i in -20..20 {
    P_i = (i, i^2)
}

Art = pointcloud for i in -20..20 {
    P_i = (i, i^2)
}

Art = objects for i in -20..20 {
    P_i = (i, i^2)
}

• for: automatic representation. Expression-only point output resolves to a compact virtual point cloud; real-object statements resolve to a materialized generated group.
• pointcloud for: one compact virtual cloud, no individual scene Points, efficient rendering, sample-aware hover/context information, and empty holes where where filters remove tuples. Virtual samples are not ordinary Point snapping targets and do not create individual DAG nodes.
• objects for: one owner group with real generated child objects, ObjectIds, normal selection/snapping/references/dependencies, and child ownership retained by the group.

Verified aliases are cloud for pointcloud and materialized for objects. v1.4-beta has no Materialize command, no Explode command, and no virtual-sample snapping.

11. Styling generated outputs

style Art {
    color = rgba(80, 160, 255, 0.75)
    opacity = 0.75
    pointSize = 2
    visible = true
}

Static colors support rgb(r,g,b), rgba(r,g,b,a), #RRGGBB, and #RRGGBBAA. Supported generated-group properties are color, opacity, pointSize, and visible. There is no per-sample styling syntax; labels is intentionally rejected by the generated-group style applicator. Unsupported properties produce a diagnostic. Object Properties is the preferred interactive styling workflow; style blocks are convenient for self-contained scripts.

12. Scripts browser and editor

The Scripts section in the Algebra/Object Browser lists ScriptBlocks, status, revision, source preview, dependencies, and artifacts. Use Edit to open the editor. Editing happens in a transient draft, so typing never changes the last successful construction.

13. Apply, Revert, Undo, and Redo

Apply replaces a ScriptBlock atomically. Revert Draft discards unapplied edits. Closing a dirty editor asks for confirmation. If Apply fails, the previous successful construction remains intact. One Undo restores that previous successful script version; one Redo reapplies the new version.

14. Save/load behavior

Project save/load restores ScriptBlock source and its attached artifacts. Loading does not rerun the script and does not add an extra undo entry. Exact source formatting, including comments and whitespace, is retained for later editing.

15. Reserved names

The application rejects user scalar function names and parameters that collide with built-ins, constants, booleans, or the explicit core command-reserved set below. Built-in and reserved collisions are checked case-insensitively. The larger command-catalog and representation lists are included as authoritative names to avoid in scripts; they are syntax/dispatch tokens, not all hard-rejected by the scalar-function registry. A user function must also be defined before it is called and cannot be silently redefined.

E(j) = ... is rejected because E matches the reserved constant e without regard to case. Prefer descriptive names such as Eta, RadiusTerm, AngleTerm, OutX, and OutY; avoid relying on one-letter function names.

16. Limits and current restrictions

• Compact virtual point clouds are limited to 250,000 samples.
• Materialized generated groups are limited to 10,000 children.
• User scalar call depth is limited to 64 nested calls; recursion is rejected.
• Script source is capped at 1 MiB by the analysis scanner.
• Materialized membership cannot depend dynamically on a Slider or external scalar in where; choose a static membership condition or use a virtual cloud.
• Point-cloud loops accept loop-local scalar and expression-point statements. Real-object statements require automatic or materialized representation.

17. Troubleshooting

• Reserved name: if the diagnostic says function name E is reserved, rename it to Eta.
• Unknown function: define called functions earlier in the same script; forward references are not resolved.
• Unknown style target: this can be a cascading error when an earlier object or group failed to create.
• Empty or malformed brace block: provide both the opening and closing braces and at least one body statement.
• Multiline loop-local expression: keep the assignment on one physical line; the generated-body parser splits statements at newlines.
• Point cloud versus real Points: use objects for when real child objects are needed.
• Failed Apply: the previous successful construction is preserved; correct the diagnostic and Apply again.
• Dense animation: compute shared intermediate values once as loop-local scalars to avoid repeated nested function evaluation.

18. Complete examples

script AnimatedWave {
T = Slider(min=0, max=6.28318, value=0, step=0.05, speed=1, direction=forward, mode=wrap)

Wave = pointcloud for i in -100..100 {
    xValue = i / 10
    yValue = sin(xValue + T)
    P_i = (xValue, yValue)
}
}

script SafeReciprocal {
Field = pointcloud for i in -20..20, j in -20..20 where j != 0 {
    ratio = i / j
    height = if(abs(ratio) < 10, ratio, 0)
    P_i_j = (i / 4, height)
}
}

script RealParabolaPoints {
RealPoints = objects for i in -10..10 {
    P_i = (i, i^2 / 10)
}
}

script ParametricWarpFast {
S = Slider(0.01, 0.06, 0.03, 0.001)
T = Slider(min=0, max=60, value=0, step=0.05, speed=1, direction=forward, mode=bounce)

Art = pointcloud for i in -40..40, j in -180..180 {
    kappaValue = 5 * cos(i / 14) * cos(j / 30)
    etaValue = j / 8 - 13
    radiusValue = (kappaValue^2 + etaValue^2) / 59 + 4
    phaseValue = sin(radiusValue^2 - 2 * T)
    qValue = 60 - 3 * sin(atan2(kappaValue, etaValue) + kappaValue * (3 + (4 / radiusValue) * phaseValue))
    angleValue = radiusValue / 2 + etaValue / 99 - T / 18
    pointX = S * 3 * qValue * sin(angleValue)
    pointY = S * 3 * (qValue + 9 * radiusValue) * cos(angleValue)
    P_i_j = (pointX, pointY)
}

style Art {
    pointSize = 2
    visible = true
}
}

1. Triangle Constructions Guide

This guide covers triangle center, line, circle, and derived shape constructions.

If you find a bug in v1.4-beta, please report it with:

• your .fgeo file
• exact steps
• expected result vs actual result

1. Choosing triangle inputs

Triangle constructions accept three point-like objects in order, or a single Triangle object, or a compatible 3-vertex Polygon.

The three points define the triangle vertex order:

• first selected point = A
• second selected point = B
• third selected point = C

This ordering matters for excenters and excircles, which are named relative to their opposite vertex.

2. Triangle Centers

2.1 Basic centers

Menu: Triangle → Centers → Basic

• Centroid — intersection of the three medians.
• Circumcenter — center of the circumcircle (equidistant from all three vertices).
• Orthocenter — intersection of the three altitudes.
• Incenter — center of the incircle (equidistant from all three sides).
• Nine-point center — center of the nine-point circle (midpoint of the orthocenter and circumcenter).

2.2 Excenters

Menu: Triangle → Centers → Excenters

• Excenter opposite A — center of excircle A, opposite vertex A (intersection of the external angle bisectors at B and C and the internal bisector at A).
• Excenter opposite B — center of excircle B, opposite vertex B.
• Excenter opposite C — center of excircle C, opposite vertex C.

2.3 Advanced centers

Menu: Triangle → Centers → Advanced

• Symmedian point / Lemoine point — intersection of the three symmedians (reflections of the medians across the angle bisectors).
• Gergonne point — intersection of the lines from each vertex to the touchpoint of the incircle with the opposite side.
• Nagel point — intersection of the lines from each vertex to the point where the excircle opposite that vertex touches the opposite side.
• Spieker center — center of the incircle of the medial triangle (also the incenter of the medial triangle).

2.4 CLI commands

All triangle centers have CLI commands usable from the Input Bar:

A = (0, 0)
B = (4, 0)
C = (0, 3)
G = Centroid(A, B, C)
O = Circumcenter(A, B, C)
N = NinePointCenter(A, B, C)

3. Triangle Lines

3.1 Euler line

Menu: Triangle → Lines → Euler line

The Euler line passes through the centroid, circumcenter, orthocenter, and nine-point center. It is generated as a line object that updates when the source triangle moves.

There is no dedicated CLI command for the Euler line; use the menu or right-click context menu.

4. Triangle Circles

4.1 Circumcircle

Menu: Triangle → Circles → Circumcircle. Passes through all three vertices. Its center is the circumcenter.

4.2 Incircle

Menu: Triangle → Circles → Incircle. Tangent to all three sides. Its center is the incenter.

4.3 Nine-point circle

Menu: Triangle → Circles → Nine-point circle. Passes through the midpoints of the three sides, the feet of the three altitudes, and the midpoints of the segments from the orthocenter to each vertex. Its center is the nine-point center.

4.4 Excircles

Menu: Triangle → Circles → Excircle opposite ...

• Excircle opposite A — tangent to side BC and the extensions of AB and AC. Opposite vertex A.
• Excircle opposite B — opposite vertex B.
• Excircle opposite C — opposite vertex C.

5. Triangle Derived Shapes

5.1 Medial triangle

Menu: Triangle → Derived Shapes → Medial triangle

The medial triangle connects the three side midpoints of the source triangle. It updates live when the source triangle changes.

6. Desktop workflow

1. Create or select a triangle input (three points in order, a Triangle object, or a compatible 3-vertex Polygon).
2. Open the Triangle menu and choose the target construction.
3. The construction appears on the canvas immediately.

Right-click a compatible selected triangle input to open the context menu. While a construction tool is active, the status bar or hint area shows the current step.

7. Mobile and tablet workflow

1. Choose the tool from the triangle constructions drawer.
2. Tap point 1 of 3 (vertex A).
3. Tap point 2 of 3 (vertex B).
4. Tap point 3 of 3 (vertex C).
5. The construction appears immediately.

In dense scenes, a candidate chooser may appear to help you select the correct point.

8. Live behavior, copy/paste, and macros

• All triangle constructions are live: moving any source point updates the generated center, line, circle, or medial triangle in real time.
• No manual refresh or rebuild is needed.
• Triangle companion constructions preserve their live dependencies when copied with their source points.
• Generated helper centers and internal vertices remain hidden or internal where applicable.
• Triangle centers and companion constructions can be captured in macro definitions. See the Macro / User-defined Tools Guide for details.

9. Related guides

• Object Properties Guide — styling and labeling constructed objects.
• Macro / User-defined Tools Guide — capturing triangle constructions as reusable macros.
• CLI User Guide
• GUI Docking and Workspace Guide

2. Macro / User-defined Tools Guide

This guide covers creating, using, and managing user-defined tools (macros). Macros let you capture a construction as a reusable tool. They replay live semantic geometry — not static coordinate snapshots. When inputs move, macro outputs update in real time.

If you find a bug in v1.4-beta, please report it with:

• your .fgeo file
• exact steps
• expected result vs actual result

1. What macros are

A macro is a user-defined tool built from an existing construction. Macro definition captures:

• the construction recipe (ordered creation steps)
• ordered input slots (point-like boundary objects)
• marked output objects (the visible results)

When you apply a macro, FluxGeo replays the recipe using the picked inputs. Intermediate support geometry is recreated as hidden support objects; it does not clutter the canvas. Outputs receive fresh editable labels on each replay.

Macro definitions persist in the project file (.fgeo) and in a user-wide macro library (~/.config/FluxGeo/macros.json on Linux).

2. Creation workflows

Full-selection path:

1. Build the construction on the canvas (points, lines, circles, etc.).
2. Select the entire construction (all objects you want captured).
3. Open Tools → Macros → Create....
4. Click "Use selection as inputs" — FluxGeo assigns all free (non-dependent) point-like objects as ordered inputs. You can reorder inputs with the ^/v buttons, or toggle input/output checkboxes in the table.
5. Click "Use selection as outputs" — FluxGeo marks the final visible objects as outputs.
6. Enter a Name for the macro.
7. Click "Create".

Canvas-pick path:

1. Open Tools → Macros → Create....
2. Click "Pick input from canvas" — the dialog minimises and the hint area says "Pick input: select a point-like object on the canvas."
3. Click the desired input in order on the canvas. The dialog reopens.
4. Click "Pick output from canvas" and click the desired output objects.
5. Click "Stop picking" when done.
6. Enter a Name and click "Create".

Terminology:

• Inputs — boundary point-like objects the user supplies each time the macro is applied.
• Outputs — the visible result objects created by the macro.
• Intermediate support — hidden geometry that the recipe requires but that is not marked as output. Support objects are recreated and hidden automatically.

3. Using macros

1. Open Tools → Macros. The menu lists all defined macros.
2. Choose a macro name, then click "Use".
3. The canvas hint area shows: "Select input 1/N: <label>".
4. Click an existing point-like object, or click empty space to create a new point at that position.
5. Repeat for each input slot. The hint updates to show the current step.
6. After the final input, the macro replays the construction. Outputs appear with fresh labels.

Escape or right-click cancels the macro tool. Selecting a different tool also cancels the macro tool.

Managing macros

• Rename — Tools → Macros → <name> → Edit.... Change the name in the dialog and click "Save".
• Delete — Tools → Macros → <name> → Delete. Confirm deletion in the popup.
• Edit (inputs/outputs) — Tools → Macros → <name> → Edit... opens the full macro editor. You can add or remove inputs and outputs, reorder slots, or recapture the recipe from the current canvas selection.

All management actions are undoable.

4. Supported macro families

Supported input types

Only point-like objects can be macro inputs: Free Point, ObjectPoint, IntersectionPoint, Midpoint, TriangleCenter, HarmonicConjugate. Slider objects are not accepted as macro inputs.

5. Unsupported and rejected families

6. Good macro examples

6.1 Perpendicular bisector / midpoint helper

Goal: Create a tool that takes two points and produces the midpoint and perpendicular bisector line.

Inputs: A, B (2 points). Outputs: Midpoint M of A and B, Perpendicular bisector line through M.

Construction (build once): Create points A and B. Create Midpoint(A, B). Create PerpendicularBisector(A, B).

6.2 Napoleon triangle macro

Goal: Build the outer Napoleon triangle (equilateral triangles outward on each side of an arbitrary triangle).

Inputs: A, B, C (3 points). Outputs: The three centers of the outward equilateral triangles or the Napoleon triangle itself.

6.3 Five-point conic macro

Goal: Create a tool that takes five points and produces the unique conic through all five.

Inputs: A, B, C, D, E (5 points). Outputs: The conic object through all five points.

6.4 Conic with transform or inversion image macro

Goal: Build a conic, then transform it (rotate/translate) or invert it in a circle.

Example: Create F1, F2 (foci) and P (curve point). Create ellipse1 = Ellipse(F1, F2, P). Create rotation center O. Create r = Rotate(ellipse1, 45°, O). Macro: inputs = F1, F2, P, O; output = r.

6.5 Golden rectangle / pentagon builder

Goal: Build a macro that creates a golden-ratio rectangle from two seed points.

Watch for: Use durable numeric variable GoldenRatio = (1 + sqrt(5))/2 for the golden ratio in your construction. The macro will capture this variable as part of the recipe.

7. Best practices

• Pick inputs in intended order.
• Only mark final objects as outputs.
• Use the full-selection path for complex constructions.
• Use the canvas-pick builder for focused tools.
• Keep labels editable after replay.
• Test your macro on fresh inputs.

8. Related guides

• Triangle Constructions Guide — triangle centers, lines, circles, and companion constructions.
• CLI User Guide — command syntax for construction and transforms usable inside macros.
• Object Properties Guide — styling and relabeling macro outputs.

3. CLI User Guide

This guide documents the desktop Input Bar / CLI syntax currently supported in FluxGeo v1.4-beta. The ScriptBlock chapter above is the canonical reference for brace-scoped syntax.

1. Quick Start

Type one command per line in the Input Bar.

A = (0, 0)
B = (4, 0)
lineAB = Line(A, B)
m = 0.5
P = A + m * Vector(A, B)
O = (1, 1)
R = Rotate(P, 45°, O)

You can also call commands directly:

Point(2, 3)
Segment(A, B)
Circle(O, A)

2. Numeric Variables and Missing Variables

Durable numeric variables:

m = 0.5
k = 2 + 3
alpha = pi / 4
p = pi
p2 = π
GoldenRatio = pi*(3 - sqrt(5))
theta = 45°

Supported numeric constants: pi/π, e, tau, and phi. Numeric variables are durable scene objects (not temporary parser locals). They can depend on sliders and existing durable numeric variables. Self-dependencies and dependency cycles are rejected.

Missing-variable slider prompt: If an expression uses unknown scalar identifiers, FluxGeo opens a slider prompt instead of creating partial objects.

P = A + t * Vector(A, B)

If t does not exist yet, you get a prompt to create slider t, then command retry.

Scalar measurement functions:

Distance(A, B)
Distance(segmentOrVector)
Length(segmentOrVector)
SquaredDistance(A, B)
SquaredDistance(segmentOrVector)
SquaredLength(segmentOrVector)

3. Point and Coordinate Assignment

A = (2, 3)
B = (2*a, sin(a))
C = (sqrt(t^2+1), min(max(t,0),1))
Point(2, 3)

Coordinate extractors: x(P), y(P) create live dependencies in point expressions.

4. Vectors and Affine Point Expressions

v = Vector(A, B)
P = A + t * Vector(A, B)
Q = A + t * v
R = A - v
S = A + t*v + s*w

Unicode multiplication operators · and × are supported. Nested transforms work:

X = Rotate(Translate(Rotate(A, 30°, O), Vector(B, C)), -45°, O)

5. Barycentric Forms

P = (1-t)*A + t*B
P = t*A + (1-t)*B
P = 0.2*A + 0.3*B + 0.5*C
P = (1-b-c)*A + b*B + c*C

6. Core Construction Commands

Line(A, B)
Segment(A, B)
Ray(A, B)
Vector(A, B)
Circle(Center, RadiusPoint)
Circle(Center, RadiusValue)
Triangle(A, B, C)
Rectangle(A, B)
Polygon(A, B, C, D)
RigidPolygon(A, B, C, ...)
RegularPolygon(A, B, n)
Square(A, B)
Midpoint(A, B)
PerpendicularBisector(A, B)
AngleBisector(Vertex, Arm1, Arm2)
Polar(P, Circle1)
Tangent(P, Circle1, 0)
Intersect(Object1, Object2)

Conic commands:

Ellipse(F1, F2, P)
Parabola(Focus, DirectrixLine)
Hyperbola(F1, F2, P)
Conic(A, B, C, D, E, F)

Relations:

Collinear(A, B, C)
Parallel(line1, line2)
Concurrent(line1, line2, line3)
Harmonic(A, B, C, D)

ObjectPoint command

P = ObjectPoint(host)

Validated host categories: line, segment, ray, vector, circle, function plot, parametric plot.

Locus command

L = Locus(targetPoint, slider, min, max, samples)
L = Locus(targetPoint, objectPoint, samples)
L = Locus(targetPoint, objectPoint, min, max, samples)

RigidPolygon

RigidPolygon is an independent rigid copy/template of a polygonal shape. Useful for congruence and similarity exploration.

RP1 = RigidPolygon(A, B, C)
tri1 = Triangle(A, B, C)
RP2 = RigidPolygon(tri1)
poly1 = Polygon(A, B, C)
RP3 = RigidPolygon(poly1, 2, 0)

Key elements: anchor handle (translates the whole rigid polygon), rotation handle (rotates the whole rigid polygon), rigid polygon body (preserves internal geometry and size).

Resize via CLI:

ResizeRigidPolygon(RP1, 2)
ResizeRigidPolygon(RP1, Distance(P,Q) / Distance(A,B))

7. Transform Commands

T1 = Translate(A, v)
T2 = Translate(A, Vector(B, C))
R1 = Reflect(A, lineAB)
R2 = Reflect(A, O)
R3 = Reflect(A, circle1)
I = Invert(P, circle1)
R1 = Rotate(A, O, 45°)
R2 = Rotate(A, 45°, O)
D1 = Dilate(A, O, 2)
D2 = Dilate(A, 2, O)

8. Generated Loops and Lattices

One-line colon syntax is retained only for compatibility. New multiline loops use brace-scoped blocks:

for n in -5..5: P_n = A + n * Vector(B, C)
for i in -2..2, j in -2..2: P_i_j = O + i*u + j*v

Multi-statement form:

for n in -5..5 {
    P_n = A + n*v
    Q_n = B + n*v
    s_n = Segment(P_n, Q_n)
}

Named groups:

Grid = for i in 0..10, j in 0..10 {
    P_i_j = A + u*(i/10) + v*(j/10)
}

Supported statement kinds in classic generated loop bodies: Affine point, Rotate, Dilate, Reflect, Segment, Polygon, and Circle. The ScriptBlock pointcloud subset remains limited to loop-local scalars and expression points; use objects for for real generated outputs.

G = for n in 0..11 {
    P_n = Rotate(A, (n * 30)°, O)
    Q_n = Dilate(P_n, (1 + n * 0.15), O)
    s_n = Segment(P_n, Q_n)
}

Batch paste and mobile expanded CLI: All generated loop commands can be submitted as a multi-line batch by pasting multiple commands at once. On desktop, paste directly into the Input Bar and press Enter. On mobile/web, use the + button to open the CLI Batch Input overlay.

9. Generated Child References and Detach

Seq1[2]
Group4D[0,1,-1,2]
Grid.A[0,0]
Grid.Cell[1,2]
D1 = Detach(Grid.A[1,1])
D2 = Detach(Grid.Cell[1,1])

10. Generated Group Styling and Range Editing

Generated groups expose style sections in Properties: generated points (visible, color, size), generated segments (color and thickness), generated polygons (fill color, fill alpha, outline color, outline thickness). Styles persist across regeneration and save/load.

Range editing: edit start, end, step, click Apply range changes.

11. Unit Graph / Distance Graph Workflow

In Algebra → Unit Graph: Compute Unit Distance Graph (transient overlay), Create Unit Graph (persistent object), Exact unit distance toggle, Clear overlay.

12. Sequence Object vs CLI Generated Loops

Sequence(30)
Sequence(1, 30, 1)
Sequence(Rotate(Dilate(T, 1 + s*k, O), a*k, O), k, 1, 30, 1)

Sequence(...) creates a SequenceGenerator object. Generated loops create labeled generated children inside a GeneratedObjectGroup. These are different systems.

13. Function, Parametric, and Implicit Support

Plot(sin(x) - 3*x)
f(x) = sin(x) - 3*x
Parametric(cos(t), sin(t), -10, 10)

Function composition:

f = Plot(ℯ^(-x^2))
g = Plot(sin(5*x))
m = Plot(f(g(x)))

ObjectPoints and Loci on plotted objects are supported for function and parametric plots. Implicit-plot ObjectPoint/locus drivers are deferred.

14. Common Errors and Fixes

• Unknown variable: create suggested sliders, then let FluxGeo retry command.
• Invalid generated child mutation: delete whole group, or Detach(...) child snapshot.
• Loop syntax errors: missing opening or closing brace, non-integer range bounds, or a label template missing loop variables.
• Barycentric rejection: use supported two-point form or constrained three-point form (1-b-c)*A + b*B + c*C.
• Locus command rejected: ensure target depends on driver, provide explicit min/max for infinite hosts, use integer sample counts.

15. GUI Locus Tool Workflow

Slider-driven: Create a target point depending on a slider, select the Locus tool, click the target point, click/select the slider driver.

ObjectPoint-driven: Create an ObjectPoint on a supported host, create a dependent target point, select the Locus tool, click the target point, click the driver ObjectPoint.

16. Deferred / Future Features

Not available in v1.4-beta: let m = ... syntax, native Sequence[...] bracket syntax, vector literal shortcuts, and virtual-sample snapping. The supported generated-loop forms are documented in the ScriptBlock chapter above.

17. Example Gallery Files

Use these included scene files for reference and validation: erdos-style-unit-distance-projected-lattice.fgeo, unit-distance-square-lattice.fgeo, generated-affine-cell-grid.fgeo, sequence-spiral-dilate-rotate-triangle.fgeo, function-bell-curve-locus-comparison.fgeo, coordinate-locus-butterfly.fgeo, and more.

4. Object Properties Guide

Object Properties is where you inspect and edit the currently selected object.

If you find a bug in v1.4-beta, please report it with:

• your .fgeo file
• exact steps and commands
• expected result vs actual result

1. What this guide is for

• rename object labels
• control label display
• change style (color, point size, thickness, line style)
• edit generated group ranges
• adjust Sequence Generator objects
• edit function, parametric, and implicit plot properties
• inspect Unit Graph properties
• create and pin text notes to geometry

2. Opening Object Properties

1. Select an object on the canvas (or in Algebra).
2. Object Properties opens for that selection.
3. Edit the controls shown for that object type.

3. Selecting what you want to edit

• Single selection: full object-specific properties are shown.
• Multi-selection: shared style controls are shown, then a selected-count summary.
• Generated child selection: direct child mutation is blocked. Select the generated group instead.
• No selection: Object Properties does not show an object editor.

4. Basic properties

• Label — editable for most objects.
• Show Label — toggle display.
• Read-only information: construction/definition text, exact and approximate coordinates.

5. Style properties

• Color, Outline Color (only for object types that support outlines)
• Point Size (for point-like selections)
• Thickness (for non-point selections)
• Line Style: Solid, Dashed, Dotted, TightDashed, WideDashed
• Dash Length and Gap Length (when style is not Solid)
• Line Type: Infinite Line, Segment, Ray, Vector (line-like objects)
• Decoration (line-like objects)
• Show Label

Distance graph special style controls: Edge Color, Edge Opacity, Edge Thickness.

A direct Visible checkbox is not exposed in Object Properties. Use Hide/Show workflow instead.

6. Editing generated group ranges

When a GeneratedObjectGroup is selected, Object Properties shows:

• Generated Group, Definition, Generated Points
• Loop variables (table columns: Variable, Start, End, Step)
• Preview object count, Apply range changes, Reset
• Generated point appearance controls (Point Color, Point Size, Apply point appearance, Reset appearance)

Range edits are apply-based, not slider-live. Use group edits or detach where applicable.

7. Editing Sequence objects

When a Sequence object is selected, Object Properties shows the Sequence Generator section with:

• Body expression, Index variable, Start/End/Increment expression
• Visible copies expression, Fill colour, Generated copies, Visible copies
• Evaluation error (when present)

Structured-mode fields: Count expression, Start Index, Transform chain, Operation, Angle step, Pivot/reference points, and more.

8. Editing function and parametric plots

• Function Plot: f(x) expression, Apply Expression, compile-status, Bound sliders, Use As Default.
• Parametric Plot: x(t), y(t) expressions, Apply Expressions, t min, t max, compile-status, Bound sliders, Use As Default.
• Implicit Plot: Equation field, Wrapped preview, Apply Equation.

9. Unit Graph and Distance Graph properties

For persistent graph objects: Source, Definition, Target distance, Mode (Exact or Tolerance), Epsilon, Point cap, Points, Edges, Max degree, Average degree. Style controls: Edge Color, Edge Opacity, Edge Thickness.

10. Text objects and pinned text

Creating text: Toolbar category Annotations & UI → Text or right-click a point-like object → Text → Add pinned note.

Editing text content: Content, Font Size, Background Box, Show Bounding Box, Background Color.

Pinning text to an object: Select text object → Pin to point... → Click a point-like host. Moving the host moves the text (offset preserved). To unpin: click Detach.

11. Practical mini-workflows

• Rename and show a point label: Select point → edit Label → enable Show Label.
• Change a segment color and thickness: Select segment → set Color → set Thickness → adjust Line Style.
• Grow a generated grid: Select generated group → edit Start/End/Step → click Apply range changes.
• Adjust a Sequence object: Select Sequence → edit expression/range or transform-chain fields.
• Edit a plotted function: Select function plot → edit f(x) → click Apply Expression.
• Pin a note to an object: Create/select text object → Pin to point... → click a point-like host.

12. Troubleshooting

• Properties did not change: Make sure exactly one object is selected.
• Cannot edit generated child: Select the generated group for range edits, or use Detach(...).
• Changed Start/End/Step but nothing happened: Click Apply range changes.
• Text does not stay attached: Confirm Pin to point... completed; check text is not in Pin to screen placement.

13. Related guides

• CLI User Guide
• Generated Geometry + Unit Graph Tutorial
• Sequence Generator Tutorial
• Function Plotting Guide

5. GUI Docking and Workspace Guide

This guide explains how to arrange your FluxGeo workspace for different tasks.

If you find a UI bug in v1.4-beta, report it with: your .fgeo file, exact steps, screenshots if possible, expected result vs actual result.

1. What this guide is for

Workspace customization helps you stay focused on: construction, generated geometry and Unit Graph analysis, sequence and plotting work, conjecture and discovery workflows, narrative and project workflows.

UI behavior can differ between desktop, web DOM shell, and touch layouts.

2. The main workspace areas

• Tools — tool palette
• Global Settings
• Algebra — object list and Unit Graph controls (Objects, Unit Graph with actions: Exact unit distance, Compute Unit Distance Graph, Create Unit Graph, Clear)
• Object Properties — selection editor
• CLI — input bar and command workflow
• Project Navigator — narrative projects (opens as separate window)
• Conjecture Observer — discovery/prover (build-dependent)

3. Moving and docking panels

Tools, Global Settings, Algebra, Object Properties, and CLI are docked or floating windows. You can drag panel title bars or tabs to rearrange docking positions. You can resize docked panel boundaries.

Default arrangement: Global Settings and Object Properties on the left, Tools in the lower-left area, Algebra on the right side, CLI docked near the bottom.

4. Closing and reopening panels

Verified View menu panel toggles: Tools, Global Settings, Algebra, CLI, Project Navigator, Conjecture Observer (if available), Global Styles, Matrix Lab (build-dependent).

Object Properties opens when you select an object and hides when no object is selected. There is no verified Reset Layout menu item in the current UI.

5. Basic construction layout

Keep canvas central and large, keep Tools visible, keep Algebra visible on one side, keep Object Properties visible, keep CLI visible for quick typed commands.

6. Generated geometry and Unit Graph layout

Keep Algebra open and expanded to Objects and Unit Graph, keep Object Properties open for generated range edits, keep CLI visible for loop commands, keep canvas large enough to inspect overlays and dense point sets.

7. Sequence and plotting layout

Keep CLI open, keep Object Properties open, keep Algebra visible for object browsing, leave enough canvas space for curve shape inspection.

8. Discovery and prover layout

If present: Conjecture Observer visible, Algebra visible, Object Properties visible, canvas kept large for geometric context.

9. Narrative project layout

Project Navigator open, Algebra visible, Object Properties visible, canvas centered for step-by-step scene updates. Project Navigator is a dedicated window and may not behave like normal docked panels.

10. Web, mobile, and tablet notes

Desktop and tablet use docked and floating panel workflow. Touch-oriented mobile mode skips desktop dock layout initialization. Web DOM shell mode uses web shell ownership. Do not expect every desktop docking behavior to match web and mobile layouts.

11. Recovering from a confusing layout

1. Re-enable needed panels from View.
2. Select an object to bring Object Properties back.
3. Resize panel boundaries to reclaim canvas space.
4. Close extra panels not needed for the current task.
5. Restart the app if panel placement still feels broken.

12. Related guides

• CLI User Guide
• Generated Geometry + Unit Graph Tutorial
• Sequence Generator Tutorial
• Function Plotting Guide
• Object Properties Guide

6. Generated Geometry + Unit Graph Tutorial

In this tutorial you will build repeated geometry with command-driven generated loops, reuse generated children in later commands, detach editable snapshots, and inspect unit-distance relationships with Unit Graph tools.

If you hit a bug in v1.4-beta, please report it with: the scene file (.fgeo), the exact commands you typed, what you expected vs what happened.

1. What this guide is for

• create repeated geometry quickly with command-driven generated loops
• build point families, grids, and multi-output generated structures
• reuse generated children in later constructions
• detach specific generated children into independent editable objects
• run Unit Graph analysis (transient overlay and persistent UnitGraph object)

2. Generated loops vs Sequence Generator

Generated loops: typed as for ... commands, create a generated group with deterministic child labels, support child references like Seq1[2] and Grid.A[0,0], support range edits from Object Properties.

Sequence Generator (Sequence(...)): separate dedicated Sequence object workflow.

3. First generated line of points

A = (0, 0)
B = (1, 0)
C = (0, 1)
u = Vector(A, B)
v = Vector(A, C)

for n in -5..5 { P_n = A + n * u }

4. Two-index grids and lattices

for i in -2..2, j in -2..2 { P_i_j = O + i*u + j*v }

5. Multi-statement generated blocks

for n in -5..5 {
    P_n = A + n*v
    Q_n = B + n*v
    s_n = Segment(P_n, Q_n)
}

6. Generated child references

Seq1[2]
Grid.A[0,0]
Grid.Cell[1,2]
Q = (1-t)*Grid.A[0,0] + t*Grid.B[0,0]
S = Segment(G.P[1], G.Q[1])

7. Detaching generated children

D1 = Detach(Grid.A[1,1])
D2 = Detach(Grid.Cell[1,1])

Detach currently supports generated point, segment, and polygon children.

8. Editing generated ranges from Object Properties

Select the generated group → edit Start/End/Step under Loop variables → review Preview object count → click Apply range changes.

Range edits are apply-based, not slider-live. Large ranges can make scenes dense/slower.

9. Unit Graph basics

In Algebra → Unit Graph:

• Exact unit distance — toggles exact vs tolerance mode
• Compute Unit Distance Graph — runs a transient overlay analysis
• Create Unit Graph — creates a persistent UnitGraph object
• Clear — clears the transient overlay

Overlay can analyze selected points or a selected generated group. Persistent UnitGraph creation requires a selected generated group.

10. Distance Graph basics

For persistent graph objects, Object Properties shows: Source, Definition, Target distance, Mode (Exact or Tolerance), Epsilon, Point cap, Points, Edges, Max degree, Average degree.

11-13. Walkthroughs

Square unit lattice: Open unit-distance-square-lattice.fgeo, select the generated group, run Unit Graph controls, edit Start/End/Step in Object Properties.

Affine cell grid: Open generated-affine-cell-grid.fgeo, inspect generated outputs, select the generated group, edit range values.

Erdos-style projected lattice: Open erdos-style-unit-distance-projected-lattice.fgeo, inspect scene structure, reduce ranges if needed, run Unit Graph analysis.

14. Generated loop body statement reference

Supported statements per iteration: Affine point, Rotate, Dilate, Reflect, Segment, Polygon.

ScriptBlock boundary: real-object statements are materialized outputs, not compact point-cloud samples. Line, Ray, Vector, FunctionPlot, Parametric, ImplicitPlot, and Sequence are not part of the brace-scoped expression-cloud examples in this chapter.

16. Troubleshooting

• Loop syntax error: Check for opening and closing braces, non-integer ranges, and valid variable names.
• Generated child not found: Verify group label and child index/key syntax.
• Scene too dense: Reduce ranges or increase step size.
• Unit Graph empty: Verify points are selected, check mode (Exact vs Tolerance).

17. Related guides

• CLI User Guide
• Sequence Generator Tutorial
• Object Properties Guide
• Example Gallery Guide

7. Sequence Generator Tutorial

This guide teaches the dedicated Sequence Generator workflow in FluxGeo. You will learn how to create Sequence objects from the Input Bar, drive them with variables/sliders, edit Sequence properties, and explore the Sequence gallery files.

If you find a bug in v1.4-beta, please report it with: the .fgeo file, the exact commands you typed, what you expected vs what happened.

1. What this guide is for

Use this guide when you want repeated patterns from Sequence(...), including: transform chains (rotate, dilate, translate), point-pattern sequences from coordinate expressions, slider-driven visual experiments.

2. Sequence Generator vs generated loops

Sequence(...) creates a dedicated Sequence object evaluating an expression over an index/range. Generated loops (for ...) create generated groups with generated child references. These are different tools.

Important: GeoGebra-style Sequence[...] is not native FluxGeo v1.4-beta input syntax. Use Sequence(...).

3-4. First Sequence and explicit range

Sequence(30)
Sequence(1, 30, 1)

5-6. Transform-based Sequence patterns

A = (0, 0)
B = (1, 0)
C = (0, 1)
O = (0, 0)
T = Triangle(A, B, C)
s = 0.05
a = 10°
Sequence(Rotate(Dilate(T, 1 + s*k, O), a*k, O), k, 1, 30, 1)
Sequence(Translate(T, q*k*Vector(O,A)), k, 1, 40, 1)

7. Coordinate / point-pattern sequences

Sequence((2,k), k, 1, 5)
Sequence((scale*sqrt(k)*cos(k*phi), scale*sqrt(k)*sin(k*phi)), k, 1, 44, 1)

8. Using sliders and variables

Sequence expressions can use variables. If a variable used in Sequence(...) is missing, FluxGeo can open a slider prompt for missing variables.

9. Editing Sequence properties

Select the Sequence object → open Object Properties → Sequence Generator section. Fields: Body expression, Index variable, Start/End/Increment expression, Visible copies expression, Fill colour. Sequence property edits apply as you edit.

10-14. Walkthroughs

Spiral dilate-rotate triangle: sequence-spiral-dilate-rotate-triangle.fgeo. Expression: Rotate(Dilate(T, 1 + s*k, O), a*k, O). Adjust sliders a and s.

Counter-rotating dilate triangle: sequence-counter-rotating-dilate-triangle.fgeo. Uses negative rotation term: -b*k.

Rotating segment fan: sequence-rotating-segment-fan.fgeo. Expression: Rotate(s, t*k, O).

Polar root spiral points: sequence-polar-root-spiral-points.fgeo. Expression: (scale*sqrt(k)*cos(k*phi), scale*sqrt(k)*sin(k*phi)).

Pattern gallery: sequence-gallery-combined-patterns.fgeo. Browse multiple Sequence objects.

15. Troubleshooting

• Sequence[...] fails: Use Sequence(...) syntax.
• Missing variable prompt: Create the suggested sliders, or define variables first.
• Sequence too dense or slow: Reduce end value, increase increment, reduce visible copies.

16. Related guides

• CLI User Guide
• Generated Geometry + Unit Graph Tutorial
• Object Properties Guide
• Example Gallery Guide

8. Function Plotting Guide

This guide covers function plotting and parametric plotting with verified Input Bar / CLI syntax and Object Properties editing.

If something behaves incorrectly, report it with: your .fgeo file, the exact commands you typed, what you expected vs what happened.

1-2. Quick start: first function plot

Plot(sin(x) - 3*x)

A new function plot object appears in the scene. You can select it and edit its expression in Object Properties.

3. Named function assignment

f(x) = sin(x) - 3*x

Creates a function plot labeled f. The assignment form is name(x) = expression. Use x as the function variable.

4. Function composition

f = Plot(ℯ^(-x^2))
g = Plot(sin(5*x))
m = Plot(f(g(x)))

Locus workflow using composition:

A = (-3,0)
B = (3,0)
s = Segment(A,B)
P = ObjectPoint(s)
f = Plot(ℯ^(-x^2))
g = Plot(sin(5*x))
R = (x(P), f(g(x(P))))
M = Locus(R, P, 600)

Only Function Plots are callable this way. Parametric and implicit plots are not scalar-callable by name.

5. Functions with parameters and sliders

a = 1
b = 0
Plot(a*sin(x) + b)

If variables are missing, FluxGeo can prompt you to create sliders.

6. Common supported math functions

sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, sqrt, exp, log, ln, log10, abs, floor, ceil, round, trunc, sgn, sec, csc, cot, min, max, pow, clamp, if.

7-8. Parametric plots

Parametric(cos(t), sin(t), -10, 10)
Parametric(t*cos(t), t*sin(t), 0, 20)

Parameterized parametric plotting is supported:

a = 1
Parametric(a*cos(t), a*sin(t), 0, 6.28318)

9. Plot properties (Object Properties)

Function Plot section: f(x) expression field, Apply Expression, compile status, bound-slider summary, Use As Default.

Parametric Plot section: x(t) and y(t) expression fields, Apply Expressions, t min and t max range fields.

10. ObjectPoints and Loci on Function Plots

f = Plot(x^2)
P = ObjectPoint(f)
Q = (x(P), f(x(P)))
L = Locus(Q, P, 80)

ObjectPoint(f) is supported for function plots. Parametric plot ObjectPoints are supported. Implicit-plot ObjectPoint/locus drivers are deferred.

11. Implicit plotting status (v1.4-beta)

There is no documented native CLI Implicit(...) command. Use implicit plotting UI/tooling if your build exposes it. Object Properties includes an Implicit Plot f(x,y) section.

12. Practical examples

Plot(sin(x))
Plot(cos(x))
f(x) = sin(x) - 3*x
Parametric(cos(t), sin(t), 0, 6.28318)
Parametric(t, sin(t), -10, 10)

13. Troubleshooting

• Expression rejected: Check function names and parentheses, ensure variables are defined.
• FluxGeo asks to create sliders: Accept slider creation, or define variables first.
• Parametric plot incomplete: Check t range (t min, t max).
• Implicit(...) does not work: Use implicit UI tooling if available.

14. Related guides

• CLI User Guide
• Sequence Generator Tutorial
• Generated Geometry and Unit Graph Tutorial

9. Discovery and Prover Guide

This guide explains the user-facing Conjecture Observer workflow for discovery runs, result review, and optional generated-object creation. This panel is explicitly labeled as an experimental observation engine in the UI.

If you find a bug in v1.4-beta, report it with: your .fgeo file, exact steps and settings, screenshots when possible, expected result vs actual result.

1. What this guide is for

• run discovery trials on the current construction
• review conjectures grouped by verification status
• inspect result families such as collinearity, parallelism, concyclicity, and triangle relations
• focus and preview selected conjectures on canvas
• generate supported integrated objects from selected conjectures
• use advanced virtual-helper scanning when needed

2. Availability and opening the panel

Open from View → Conjecture Observer. If present in your desktop default dock layout, it is docked with the right-side panel group.

3. Panel map and primary controls

• Trials — number of random trials
• Aux lines — auxiliary lines to add
• Show obvious / collapsed — toggle visibility of lower-priority results
• Observe — start a discovery run
• Stop — cancel running observation
• Clear Highlights
• Status — progress bar and status display
• Stage Diagnostics — collapsible diagnostics section

4. Running an observation pass

1. Set Trials to the number of perturbation trials you want.
2. Optionally enable Aux lines for richer preview overlays.
3. Click Observe.
4. Watch Status and the progress bar while the worker runs.
5. Click Stop if you need to cancel.

Status values: Idle, Running, Done, Cancelled, Error.

5. Understanding status buckets

• VERIFIED — strongest status, high-confidence findings. Still inspect geometry manually.
• OBSERVED (replay unsupported) — observed but blocked by unsupported replay paths.
• OBSERVED (frame0 candidate) — candidate observed at frame0-level status.

Treat observed results as hints, not final guarantees.

7. Result families you can see

coincident points, collinear points, midpoints, isosceles/right/equilateral triangles, congruent/similar triangles, equal area triangles, area ratios, rhombi, parallelograms, trapezoids, parallel/perpendicular lines, concurrent lines, congruent/supplementary angles, congruent segments, segment sums, distance ratios, concyclic points, points on circle, line-circle/circle-circle tangencies, congruent circumcircles/incircles, harmonic ranges.

9-10. Inspecting results and Generate Object

Each selectable result row supports: Focus (highlights related entities), Preview (transient witness-style overlay), Generate Object (creates integrated generated object for supported relation types).

Generate Object is implemented for: triangle relations (isosceles, right, equilateral), angle relations (equal angle, supplementary), quadrilateral relations (rhombus, parallelogram, trapezoid), concyclicity.

11. Advanced discovery (virtual helpers)

Controls: Use virtual helper points, Include virtual-helper results, Scan virtual helpers, Enable virtual helper preview overlay, Max virtual points/lines/line-scans, Use parallel discovery, Threads.

Virtual helper points are discovery-only helpers, not scene objects, and are not saved.

13. Recommended user workflow

1. Build or open a construction with clear geometric structure.
2. Open Conjecture Observer from View.
3. Set Trials and run Observe.
4. Review VERIFIED first, then OBSERVED groups.
5. Use Focus and Preview on promising rows.
6. Use Generate Object on supported families when you want integrated geometry output.

14. Troubleshooting

• Panel missing: Re-enable Conjecture Observer from View.
• No results after Observe: Increase Trials, verify construction is non-trivial, check Stage Diagnostics.
• Preview unavailable: Some results are focus-only; preview suppressed when no renderable geometry is produced.
• Generate Object disabled: Expected for unsupported relation families.

15. Related guides

• GUI Docking and Workspace Guide
• CLI User Guide
• Object Properties Guide
• Generated Geometry + Unit Graph Tutorial

10. Narrative Project and Project Navigator Guide

This guide explains how to turn a geometry construction into a teachable narrative project using Project Navigator, narrative step snapshots, notes, and optional HTML report export.

If you find a bug in v1.4-beta, report it with: your .fgeo and/or .fgproj file, exact steps, screenshots when possible, expected result vs actual result.

1. What this guide is for

Use this guide when you want to present geometry as a structured story — classroom explanation, theorem exploration notes, step-by-step construction walkthrough, research presentation draft, shareable narrative report.

2. What is a narrative project?

In FluxGeo, a narrative project is a sequence of saved step snapshots plus explanatory text. Verified user-facing elements: Project/Proof title, step timeline cards, per-step Step Description, Hypothesis/Given text, Assertion/Proof text, saved narrative project file (.fgproj), optional HTML report export.

3. Opening the narrative UI

Open from View → Project Navigator. Save/load: File → Save Narrative Project... / Load Narrative Project.... Project Navigator opens as its own dedicated window.

4. Recommended workflow

1. Build or load a construction (the "scene").
2. Open Project Navigator from View.
3. Set a project title. (If your Project Navigator editing opens from a form/button, use that.)
4. Add steps: each construction/observation action becomes a narrative step. For each step, record: Step Description, Hypothesis/Given, Assertion/Proof.
5. Navigate back and forth through step timeline cards to review the story.
6. Optionally export the project to an HTML report.

5-6. Preparing the construction, using labels and pinned notes

Before building narrative steps: label key objects clearly with meaningful names, use pinned notes to annotate geometry, organize object hierarchy in Algebra. Keep the scene clean for clearer step snapshots.

7-8. Saving and loading narrative projects

Save Narrative Project... — saved as .fgproj file. Load Narrative Project... — loads a previously saved .fgproj file. The .fgproj file references the .fgeo scene file. If the scene file moves, loading the project may fail.

9. Exporting or generating output (HTML reports)

FluxGeo can export narrative steps to an HTML report for sharing or review. The generated HTML includes step descriptions, hypotheses, and assertions. The export may not include full canvas renders; saved step previews reflect the scene state at capture time.

10. Using discovery/prover results responsibly

If your build includes Conjecture Observer, you can incorporate discovery results into narrative steps. Only use VERIFIED or manually reviewed results in teaching contexts.

11. Example projects

• Triangle construction walkthrough: Create a construction step by step (points, segments, triangle, circumcircle, Euler line). Each construction step becomes a narrative step with observations.
• Generated geometry investigation: Build a generated lattice or grid, add Unit Graph analysis, note observed patterns.

12. Beta limitations

• .fgproj is a separate file from .fgeo. Moving the scene file may break the reference.
• HTML export is text-focused and may not include full canvas renders.
• No built-in slide-show mode for narrative playback.
• Step reordering and editing may be limited in the current panel.

13. Troubleshooting

• Cannot open Project Navigator: Check View menu. Not all builds expose it.
• Project loads but steps are empty: The .fgproj might reference a moved .fgeo file.
• Export HTML shows no content: Check that steps have descriptions saved.

15. Related guides

• GUI Docking and Workspace Guide
• Discovery and Prover Guide
• CLI User Guide
• Object Properties Guide

11. Example Gallery Guide

FluxGeo includes example .fgeo scenes that help you learn major workflows quickly.

Use examples to practice: Input Bar and CLI commands, generated geometry and Unit Graph workflows, Sequence Generator patterns, discovery/prover exploration on real scenes, narrative/project write-up workflows.

2. How to open examples

1. Open FluxGeo.
2. Use File → Load....
3. Open a file from the examples/ folder.
4. Inspect scene objects in Algebra and object settings in Object Properties.

3. Recommended learning order

1. Basic command/input workflow: start with CLI User Guide.
2. Generated geometry and Unit Graph: unit-distance-square-lattice.fgeo, generated-affine-cell-grid.fgeo, erdos-style-unit-distance-projected-lattice.fgeo.
3. Sequence Generator: sequence-spiral-dilate-rotate-triangle.fgeo, sequence-counter-rotating-dilate-triangle.fgeo, sequence-rotating-segment-fan.fgeo, sequence-polar-root-spiral-points.fgeo, sequence-gallery-combined-patterns.fgeo.
4. Plotting: use Function Plotting Guide.
5. Discovery/prover: try on small clean scenes first.
6. Narrative/project: use Narrative Project Guide.

4. Generated geometry examples

unit-distance-square-lattice.fgeo: Two-index generated lattice scene, Unit Graph workflow, generated group range editing.

generated-affine-cell-grid.fgeo: Multi-statement generated cell grid, generated child reference usage, range editing and regeneration.

erdos-style-unit-distance-projected-lattice.fgeo: Denser generated unit-distance exploration scene, stress case for Unit Graph.

5. Sequence Generator examples

sequence-spiral-dilate-rotate-triangle.fgeo: Rotate+dilate triangle sequence pattern.

sequence-counter-rotating-dilate-triangle.fgeo: Opposing rotation direction with dilation.

sequence-rotating-segment-fan.fgeo: Repeated segment rotation fan structure.

sequence-polar-root-spiral-points.fgeo: Coordinate-expression sequence point cloud pattern.

sequence-gallery-combined-patterns.fgeo: Multiple sequence styles in one scene.

6. Plotting examples

Function composition locus:

A = (-3,0)
B = (3,0)
s = Segment(A,B)
P = ObjectPoint(s)
f = Plot(ℯ^(-x^2))
g = Plot(sin(5*x))
R = (x(P), f(g(x(P))))
M = Locus(R, P, 600)

7-8. Discovery and Narrative examples

Discovery: Start with a small triangle or quadrilateral scene, then try discovery on selected generated or sequence examples.

Narrative: Use any example scene to build your own narrative timeline in Project Navigator.

9. Tips for using examples

• Save a copy before heavy edits.
• Reduce generated ranges if performance drops.
• Use Object Properties to inspect specialized object settings.
• Add labels and pinned notes for your own explanations.
• When reporting issues, include the exact example filename.

10. Related guides

• CLI User Guide
• Generated Geometry + Unit Graph Tutorial
• Sequence Generator Tutorial
• Function Plotting Guide
• Object Properties Guide
• GUI Docking and Workspace Guide
• Discovery and Prover Guide
• Narrative Project and Project Navigator Guide

12. CLI Batch Examples

A collection of paste-ready CLI batch scripts for the Input Bar (desktop) or the + expanded CLI overlay (mobile/web). Each example is a self-contained block. Paste it as-is, then press Enter / Run. The brace-scoped ScriptBlock examples in the chapter above are the v1.4-beta validation set.

1. ObjectPoint and Locus

Parabola from segment driver

A = (-4, 0)
B = (4, 0)
s = Segment(A, B)
P = ObjectPoint(s)

f = Plot(0.4 * x^2)
Q = (x(P), f(x(P)))
L = Locus(Q, P, 500)

Expected: smooth parabola locus. Drag P along the segment to watch Q trace the curve.

Circle ObjectPoint — Limaçon

O = (0, 0)
R = (3, 0)
c = Circle(O, R)
P = ObjectPoint(c)

K = (1, 0)
Q = Rotate(P, 90°, K)
L = Locus(Q, P, 500)

Expected: a limaçon curve.

Two loci from one driver

O = (0, 0)
A = (3, 0)
c = Circle(O, A)
P = ObjectPoint(c)

K = (1, 0)
Q1 = Rotate(P, 90°, K)
Q2 = Rotate(P, 60°, K)

L1 = Locus(Q1, P, 400)
L2 = Locus(Q2, P, 400)

Sine curve — ObjectPoint on function plot

O = (0, 0)
f = Plot(2 * sin(x))
P = ObjectPoint(f)
Q = Rotate(P, 90°, O)
L = Locus(Q, P, 500)

2. Affine Loops — Flexible Scale

String art parabola envelope

O = (0, 0)
A = (4, 0)
B = (0, 4)
u = Vector(O, A)
v = Vector(O, B)

G = for n in 0..10 {
    P_n = O + (n/10)*u
    Q_n = O + (n/10)*v
    s_n = Segment(P_n, Q_n)
}

Two-index segment grid

O = (0, 0)
A = (1, 0)
B = (0, 1)
u = Vector(O, A)
v = Vector(O, B)

Grid = for i in -2..2, j in -2..2 {
    P_i_j = O + i*u + j*v
    Q_i_j = P_i_j + u
    s_i_j = Segment(P_i_j, Q_i_j)
}

3. Rotate in Loops

Wheel spokes

O = (0, 0)
A = (3, 0)

G = for n in 0..11 {
    P_n = Rotate(A, (n * 30)°, O)
    s_n = Segment(O, P_n)
}

Maurer rose (d = 71, p = 10)

O = (0, 0)
A = (3, 0)

G = for n in 0..36 {
    P_n = Rotate(A, (n * 10)°, O)
    Q_n = Rotate(A, (n * 71)°, O)
    s_n = Segment(P_n, Q_n)
}

4. Dilate in Loops

Growing spiral arms

O = (0, 0)
A = (1, 0)

G = for n in 0..23 {
    P_n = Rotate(A, (n * 15)°, O)
    Q_n = Dilate(P_n, (1 + n * 0.1), O)
    s_n = Segment(P_n, Q_n)
}

Phyllotaxis sunflower (golden angle)

O = (0, 0)
A = (0.4, 0)

G = for n in 0..29 {
    P_n = Rotate(A, (n * 137.5)°, O)
    Q_n = Dilate(P_n, (1 + n * 0.12), O)
    s_n = Segment(O, Q_n)
}

5. Reflect in Loops

Symmetric string art — reflect over line

O = (0, 0)
A = (4, 0)
B = (0, 4)
u = Vector(O, A)
v = Vector(O, B)
axis = Line(O, A)

G = for n in 0..8 {
    P_n = O + (n/8)*u
    Q_n = O + (n/8)*v
    R_n = Reflect(P_n, axis)
    T_n = Reflect(Q_n, axis)
    s1_n = Segment(P_n, Q_n)
    s2_n = Segment(R_n, T_n)
}

6. Chained Transforms

Rotate then Dilate — expanding fan

O = (0, 0)
A = (3, 0)

G = for n in 0..11 {
    P_n = Rotate(A, (n * 30)°, O)
    Q_n = Dilate(P_n, (1 + n * 0.2), O)
    s_n = Segment(P_n, Q_n)
}

7. Two-Index Loops with Transforms

Grid with Rotate

O = (0, 0)
A = (1, 0)
B = (0, 1)
u = Vector(O, A)
v = Vector(O, B)

Grid = for i in -2..2, j in -2..2 {
    P_i_j = O + i*u + j*v
    Q_i_j = Rotate(A, (i * 20 + j * 15)°, O)
    s_i_j = Segment(P_i_j, Q_i_j)
}

Notes

• All angle expressions accept ° suffix. Without it, the value is treated as radians.
• pi and π are equivalent in all expressions.
• Loop variable n is an integer; divide with / for fractional steps: (n/10).
• Same-iteration generated points can be used as the source for Rotate, Dilate, Reflect, and Segment in later statements of the same loop body.
• On mobile, paste each example block into the + expanded CLI overlay and press Run.

13. FluxGeo Plotting Examples

This page collects ready-to-paste plotting examples for FluxGeo. It covers explicit functions, parametric plots, implicit plots, generated function families, and points whose coordinates are defined by expressions.

1. Explicit function plots

Use Plot(expr) for explicit functions of x.

Basic explicit functions

f1 = Plot(sin(x))
f2 = Plot(x^2)
f3 = Plot(exp(-x^2))
f4 = Plot(log(x))
f5 = Plot(sqrt(x))

Discontinuities and asymptotes

g1 = Plot(1/x)
g2 = Plot(tan(x))
g3 = Plot(arctan(1/x))

Dense explicit functions

d1 = Plot(sin(10*x^2)*cos(5*x))
d2 = Plot(sin(1/x))
d3 = Plot(cos(x^2))

2. Parametric plots

Use Parametric(xExpr, yExpr, tMin, tMax) for curves parameterized by t.

p1 = Parametric(4*sin(5*t + pi/2), 3*sin(4*t), 0, 2*pi)  -- Lissajous
p2 = Parametric(cos(t), sin(t), 0, 2*pi)                   -- Circle
p3 = Parametric(0.08*t*cos(t), 0.08*t*sin(t), 0, 12*pi)   -- Spiral
p4 = Parametric(cos(5*t)*cos(t), cos(5*t)*sin(t), 0, 2*pi) -- Flower

3. Implicit plots

Use Implicit(expr) for equations of the form expr = 0.

Basic implicit correctness scene

C1 = Implicit(x^2 + y^2 - 1)
C2 = Implicit(x^2 + y^2 - 4)
H1 = Implicit(x*y - 1)
H2 = Implicit(x*y + 1)
W1 = Implicit(sin(x) + sin(y))
W2 = Implicit(cos(x) - cos(y))

Mobile/tablet GPU stress scene

C1 = Implicit(x^2 + y^2 - 1)
C2 = Implicit(x^2 + y^2 - 4)
H1 = Implicit(x*y - 1)
H2 = Implicit(x*y + 1)
W1 = Implicit(sin(x) + sin(y))
W2 = Implicit(cos(x) - cos(y))
R1 = Implicit(sin(x^2 + y^2))
R2 = Implicit(cos(x^2 + y^2))
A1 = Implicit((x^2 + y^2)^2 - 4*(x^2 - y^2))
A2 = Implicit(y^2 - x^3 + x)

Heavier trigonometric implicit scene

S1 = Implicit(sin(x) + sin(y))
S2 = Implicit(sin(2*x) + sin(2*y))
S3 = Implicit(sin(3*x) + sin(3*y))
S4 = Implicit(sin(4*x) + sin(4*y))
S5 = Implicit(cos(x*y))
S6 = Implicit(sin(x*y))
S7 = Implicit(cos(x^2 + y^2))
S8 = Implicit(sin(x^2 - y^2))

4. Generated explicit function families

Harmonic sine family

F = for i in 1..12 {
    f_i = Plot(sin(i*x))
}

Shifted logarithm and square-root families

D = for i in -5..5 {
    l_i = Plot(log(x - i))
    s_i = Plot(sqrt(x - i))
}

Rational and arctangent discontinuity family

R = for i in -5..5 {
    h_i = Plot(1/(x - i))
    a_i = Plot(arctan(1/(x - i)))
}

Two-index generated function family

F2 = for i in 1..5 {
    for j in 1..3 {
        f_i_j = Plot(sin(i*x) + 0.2*j)
    }
}

5. Generated parametric families

P1 = Parametric(cos(t), sin(t), 0, 2*pi)
P2 = Parametric(2*cos(t), 2*sin(t), 0, 2*pi)
P3 = Parametric(3*cos(t), 3*sin(t), 0, 2*pi)

6. Points with function expressions as coordinates

Expression-driven points

A = (sin(1), cos(1))
B = (sin(2), cos(2))
C = (sin(3), cos(3))

Generated sampled sine points

SinePts = for i in -20..20 {
    P_i = (0.2*i, sin(0.2*i))
}

Generated sampled circle points

CirclePts = for i in 0..24 {
    P_i = (cos(2*pi*i/24), sin(2*pi*i/24))
}

Generated spiral points

SpiralPts = for i in 0..80 {
    P_i = (0.03*i*cos(0.25*i), 0.03*i*sin(0.25*i))
}

7-8. Mixed demo and heavy stress scenes

f1 = Plot(sin(x))
f2 = Plot(exp(-x^2))
f3 = Plot(1/x)
p1 = Parametric(4*sin(5*t + pi/2), 3*sin(4*t), 0, 2*pi)
C1 = Implicit(x^2 + y^2 - 4)
W1 = Implicit(sin(x) + sin(y))
SinePts = for i in -20..20 {
    P_i = (0.2*i, sin(0.2*i))
}

The heavy mixed stress scene (8) combines 12 harmonic sine plots, 22 rational/arctangent plots, 5 implicit plots, 1 parametric spiral, and 81 spiral points. Use only after basic scenes are working smoothly.

14. Tangential Circle Tools Guide

FluxGeo v1.4-beta adds three Tangential Circle construction tools: 2P + Tangent Circle, P + 2 Tangents Circle, and 3 Tangents Circle. These let you construct circles that pass through points and are tangent to lines, segments, rays, or circles.

A tangential circle construction is an Apollonius-type problem: find a circle that satisfies a mix of point-passing and tangency constraints.

• 2P + Tangent Circle — circle through two points, tangent to one object.
• P + 2 Tangents Circle — circle through one point, tangent to two objects.
• 3 Tangents Circle — circle tangent to three objects.

Because these are geometric constraints rather than unique definitions, there can be multiple valid solution circles for a given input set. FluxGeo shows all available solutions as previews and lets you choose the one you want.

Why there can be multiple solutions

Geometric constraints often admit more than one solution. For example, two points and a line can produce two valid circles (one on each side of the line), while a point and two circles can have up to six solutions. The 3 Tangents Circle (Apollonius problem) can yield up to eight distinct solution circles.

FluxGeo computes all real solutions within the visible canvas area and presents them as preview circles before you commit.

Selecting a solution

When a construction has more than one valid solution, FluxGeo shows ghost preview circles for each candidate:

• Preview circles appear in a translucent style so you can see the underlying geometry through them.
• The active candidate is highlighted more brightly.
• Press Tab or Shift+Tab to cycle forward or backward through candidates.
• Press Enter to confirm the highlighted candidate.
• Press Escape to cancel the construction.
• Click directly on a preview circle to select the nearest candidate to your click point.

The confirmed circle is created as a permanent circle object in the scene.

Smart point input

During any point-input step you can:

• Click an existing point to select it.
• Click empty canvas to create a free point at the click location.
• Click an object (line, segment, ray, circle) to create an ObjectPoint on that object. The created point stays constrained to its host and updates when the host moves.

Tangent stage behaviour

When the tool expects a tangent object rather than a point:

• Clicking a line or circle during a tangent stage selects that object as the tangent parent.
• The click does not create an ObjectPoint — it selects the object directly for tangency.

This distinction is important: during a tangent stage you cannot create a point. The next stage determines whether a click creates a point or selects a tangent parent.

Tool 1: 2P + Tangent Circle

Creates a circle through two points and tangent to one object.

Workflow:

1. Select or create the first point on the circle.
2. Select or create the second point on the circle.
3. Select the tangent object (line, segment, ray, or circle).
4. If multiple solutions exist, choose a candidate from the preview.
5. Confirm with Enter or by clicking the preview circle.

Example — two points and a line:

1. Place Point A and Point B.
2. Draw a Line L.
3. Activate 2P + Tangent Circle.
4. Click A, then B, then L.
5. Two preview circles appear — one on each side of the line. Tab to the one you want, then Enter.

Example — two points and a circle:

1. Place Point A and Point B.
2. Create Circle C.
3. Activate 2P + Tangent Circle.
4. Click A, then B, then C.
5. Browse the preview candidates and confirm.

Tool 2: P + 2 Tangents Circle

Creates a circle through one point and tangent to two objects.

Workflow:

1. Select or create the point on the circle.
2. Select the first tangent object.
3. Select the second tangent object.
4. Choose a candidate from the preview.
5. Confirm.

Example — one point, one line, and one circle:

1. Place Point A.
2. Draw a Line L and a Circle C.
3. Activate P + 2 Tangents Circle.
4. Click A, then L, then C.
5. Multiple preview circles appear. Choose one.

Tool 3: 3 Tangents Circle

Creates a circle tangent to three objects. This is the classical Apollonius problem — a circle tangent to three given circles (where a line is treated as a circle with infinite radius).

Workflow:

1. Select the first tangent object.
2. Select the second tangent object.
3. Select the third tangent object.
4. Choose a candidate from the preview.
5. Confirm.

Example — three lines (incircle and excircles):

1. Draw three non-concurrent lines forming a triangle.
2. Activate 3 Tangents Circle.
3. Click each of the three lines.
4. Four preview circles appear: the incircle and three excircles of the triangle formed by the three lines.

Example — two lines and one circle:

1. Activate 3 Tangents Circle.
2. Click two lines and one circle.
3. Up to eight solution circles may appear.

Example — three circles (Apollonius):

1. Create three circles that do not contain each other.
2. Activate 3 Tangents Circle.
3. Click each circle.
4. Browse the solutions — up to eight circles are tangent to all three given circles.

Supported tangent objects

Conic, function plot, parametric plot, and implicit plot tangency is not yet supported.

Current limitations

• Segment and Ray tangency uses the supporting full line of the object. The solution circle is tangent to the infinite line containing the segment or ray, not to the bounded portion. Tangent-domain validation is not applied.
• Conic tangency is not yet supported.
• Function plot, parametric plot, and implicit plot tangency is not yet supported.
• Macro support for tangential circle tools is not yet available. These tools cannot be captured in macro definitions.
• In dense scenes with many overlapping preview circles, cycling with Tab / Shift+Tab is the most reliable selection method.

Troubleshooting — no solution found

If no solution circle is found, FluxGeo displays a brief notification. This can happen when:

• Two points are too far from the tangent object to form a valid circle.
• The geometry constraints are contradictory (e.g., a point lies inside all circles and no tangent circle through that point exists).
• The input objects are arranged so all real solutions lie outside the visible canvas area.

Try adjusting the positions of your input objects and retry.

15. Tool Reference