Callie Pro iPad User Guide

Callie Pro for Mac uses the same mathematical foundation as the iPad edition with a desktop-native workspace, mouse and trackpad controls, keyboard shortcuts, larger Matrix and Tensor limits, and higher 3D mesh ceilings.

The Mac interface reorganizes the same core workspaces for resizable desktop windows. This guide remains focused on the iPad interface; see the [Callie Pro Mac overview](/#mac) for the desktop edition.

Use Callie Pro when you want more than a basic calculator but still want a tool that stays direct and visual.

Callie Pro is especially useful for:

• Graphing ordinary functions such as sin(x), x^2, and 2*x - 1.
• Comparing multiple expressions on the same graph.
• Exploring parametric, polar, complex, and 3D graphs.
• Animating parameterized graphs with Temporal playback.
• Tracing points, roots, extrema, slopes, and intersections.
• Creating tables from graph expressions.
• Running symbolic-style CAS operations.
• Working with matrices, systems, eigenvalues, and row reduction.
• Working with rank-N tensors, indexed notation, Einstein summation, metric tensors, and tensor calculus.
• Moving mathematical objects between Matrix, Tensor, Statistics, CAS, graphing, and Python workflows.
• Exploring differential-geometry quantities including Christoffel symbols, Riemann curvature, Ricci tensors, and scalar curvature.
• Using Callie Pro in portrait, landscape, and supported resizable iPad multitasking layouts.
• Running statistics summaries, confidence intervals, and hypothesis tests.
• Writing small local Python scripts for numerical work.
• Exporting graphs, data, and reports as files you can save or share.

Callie Pro does not require an account. Graph documents and calculations are local to your device. Python scripts run locally inside the app's calculator sandbox.

When you open Callie Pro, the app starts in the main calculator shell. The first screen is arranged like a calculator built around a large LCD workspace.

The upper workspace shows the current tool. The lower shell contains the large workspace navigation row, the calculator keypad, modifier keys, and special input modes.

The main workspace buttons are:

• Y=: edit graph expressions.
• GRAPH: view the graph canvas.
• TABLE: view numerical tables for the active graph.
• WINDOW: adjust graph bounds and fitting controls.
• TRACE: trace graph points and analysis results.

These are workspace navigation buttons, not calculator input keys. They take you to the major graph views.

The rest of the shell gives you calculator entry, numeric keys, operations, functions, modifiers, arrows, and text entry tools.

The calculator shell is the persistent control surface at the bottom of the app.

It has several jobs:

• Enter numbers and expressions.
• Switch workspaces.
• Toggle modifier layers.
• Navigate trace points.
• Move text cursors in text entry mode.
• Insert math functions, constants, and operators.
• Run or submit workspace actions when appropriate.

The shell is intentionally fixed. When you move from Graph to CAS, Matrix, Stats, or Python, the shell remains available and the workspace above it changes.

Primary Keys

The main numeric and operation keys handle ordinary calculator input:

• Digits 0 through 9.
• Decimal point.
• Basic operations +, -, x, and division.
• ENTER for submitting an expression or action in the current workspace.
• CLEAR for clearing the active input or workspace state.
• DEL for deleting the character before the cursor.

The exact effect of ENTER, CLEAR, and DEL depends on the active workspace. In the calculator scratch area they affect calculator expressions. In CAS they run or clear CAS input. In text workspaces they route through the focused text editor.

Modifier Keys

Callie Pro includes modifier layers so the keypad can hold more functions without becoming a full keyboard.

The most important modifiers are:

• 2nd: exposes second-layer functions and symbols.
• 3rd: exposes third-layer functions and symbols.
• LTTR: switches into letter and text entry mode.
• MATH, STAT, MATRIX, CAS, PYTHON, and CATALOG: jump to or insert related tools depending on context.

Modifier previews use the app's color language. Second-layer functions use a yellow/brass accent, while third-layer functions use a green/mint accent.

LTTR Text Entry

LTTR turns the calculator shell into a text-entry layer. Use it when you need letters, variable names, Python text, CAS expressions, or function names that are easier to type than assemble from math keys.

In LTTR mode:

• Primary keys enter letters.
• SHIFT changes letter case.
• SPC inserts a space.
• TAB inserts indentation.
• ENTER inserts a newline when the active field is a text editor.
• DEL deletes text.
• The directional pad becomes text navigation.

The LTTR second layer is for common punctuation and operators such as:

. , : ; ' " _ # ? ! + - * / = ( )

The LTTR third layer is for advanced and programming-oriented symbols such as:

[ ] { } < > <= >= == != => ->

LTTR is useful in the Python workspace, CAS, complex expressions, and any field where you want to enter names or structured text.

Directional Pad

Outside LTTR mode, the directional pad is trace-oriented. It moves through graph trace points or analysis targets when a graph is active.

In LTTR mode, the directional pad becomes text navigation:

• Left and right move the cursor by character.
• Up and down move between logical lines when possible.
• The center label changes to NAV to show that it is navigating text, not tracing a graph.

This helps keep text entry calculator-native while still giving you cursor control.

Callie Pro is organized around workspaces.

The core graph workspaces are:

• Y= for editing expressions.
• GRAPH for viewing and interacting with the graph.
• TABLE for numerical values.
• WINDOW for bounds, fit, and viewport controls.
• TRACE for point-by-point exploration.

Additional workspaces include:

• Calculator scratch.
• CAS.
• Matrix.
• Tensor.
• Stats.
• Python.
• Catalog and constants.
• Settings and export tools.

Tensor workspace at a glance

TENSOR opens Callie Pro's multidimensional mathematics workspace. Tensor extends the Matrix workflow from rank-2 matrices to rank-N mathematical objects while preserving proper indexed notation and cross-workspace handoffs.

Use Tensor for rank-N real and complex tensors, component inspection and slicing, tensor algebra and contractions, Einstein summation, axis transformations and reshaping, metric tensors and index raising/lowering, tensor and vector calculus, numerical differential geometry, and Matrix/Python handoffs. Matrix remains the faster workspace for ordinary rank-2 linear algebra.

You do not need to use every workspace. A common workflow might be:

1. Enter sin(x) in Y=.
2. Tap GRAPH.
3. Tap Fit if needed.
4. Use TRACE to inspect values.
5. Open TABLE for numerical rows.
6. Export a PDF or CSV if you want to save the result.

The graph system is the center of Callie Pro.

It supports 2D, 3D, complex, and temporal graphing. Each expression lives in the graph document and can be shown, hidden, edited, traced, tabled, analyzed, and exported.

The app includes ordinary graph types and dedicated Temporal graph types. Ordinary graph types are for static graphs. Temporal graph types are for playback over a changing parameter.

The graph canvas is designed to use the available display area while keeping controls reachable. Two-dimensional graphs fill the main canvas. Three-dimensional graphs reserve room for 3D controls and readouts so that mesh, trace, analysis, and Temporal controls remain accessible.

Starter Graph

Callie Pro opens with a starter graph so the graph workspace is not blank. You can replace those expressions immediately.

To begin from scratch:

1. Tap Y=.
2. Select an existing expression row.
3. Edit the expression.
4. Hide or delete rows you do not need.
5. Tap GRAPH to view the result.

Expression Rows

Each graph expression row has:

• A name such as Y1, R1, Z1, or another prefix depending on type.
• A visibility toggle.
• One or more expression fields.
• Domain or sample settings when relevant.
• Style and graph-type controls.

When an expression is visible, Callie Pro samples and renders it if the expression is valid for the current graph type.

Use Y= to create, edit, and organize graph expressions.

The Y= editor is where you decide what a graph means. The Graph workspace shows the result; the Y= workspace defines the math.

Common tasks:

• Add a function.
• Change a graph type.
• Hide or show an expression.
• Edit domains and sample counts.
• Select a Temporal example.
• Set 3D mesh quality.
• Adjust complex height mode.

Editing A Function

For a standard function, enter an expression in terms of x.

Examples:

sin(x)
x^2
2*x - 1
e^(-0.1*x)*sin(8*x)
sqrt(x)

Then tap GRAPH.

If an expression returns complex values in a standard real-valued graph, Callie Pro does not render invalid graph artifacts. It will indicate that the result is complex and point you toward Complex Graph mode.

Adding Another Expression

Add another row when you want to compare functions.

Example:

Y1 = sin(x)
Y2 = 0.2*x^2 - 2

Both can be visible at the same time. The graph uses separate colors and labels so you can compare them visually.

Hiding Expressions

Hide an expression when you want to keep it in the document but remove it from the current graph.

This is useful when:

• You are comparing several possible models.
• You want to isolate one graph for export.
• A heavy 3D surface is slowing down the view.
• You want to keep a formula but focus on another one.

Changing Graph Type

Graph type controls determine which fields appear.

For example:

• Function uses y = f(x).
• Parametric uses x(t) and y(t).
• Polar uses r(theta).
• Complex uses z(t).
• 3D Surface uses z = f(x, y).
• 3D Curve / Vector uses x(t), y(t), and z(t).
• Complex 3D Surface uses f(z) over the complex input plane.

When you change graph types, review the fields carefully. A formula that makes sense as a function might not make sense as a surface or complex path.

Function graphs plot a real-valued output against x.

Use Function mode for formulas like:

y = sin(x)
y = x^2
y = 2*x - 1
y = e^(-0.1*x)*sin(8*x)

Example: Line

Enter:

2*x - 1

Tap GRAPH, then use Fit if needed.

The graph should show a straight line with slope 2 and y-intercept -1.

Example: Parabola

Enter:

x^2

Use the graph view to inspect the vertex and shape. Use Trace to move along the curve and Table to inspect numeric values.

Example: Wave

Enter:

sin(x)

Use Zoom and Fit to adjust the view. Use Trace to move smoothly along sampled points.

For a faster wave:

sin(8*x)

For a damped wave:

e^(-0.1*x)*sin(8*x)

Callie Pro includes viewport safety limits so extreme zooming or non-finite values do not produce unstable graph artifacts.

Parametric graphs define x and y separately using a parameter, usually t.

Use Parametric mode when the curve is easier to describe as motion or a path.

Example:

x(t) = cos(t)
y(t) = sin(t)
t min = 0
t max = 2*pi

This creates a unit circle.

Another example:

x(t) = t*cos(t)
y(t) = t*sin(t)
t min = 0
t max = 10

This creates a spiral.

Parametric graphs are good for:

• Circles and ellipses.
• Orbits.
• Spirals.
• Projectile paths.
• Curves where x is not a single independent variable.

Polar graphs use an angle and a radius.

The typical form is:

r(theta) = ...

Examples:

2*sin(3*theta)
1 + cos(theta)
3

Polar mode is useful for:

• Rose curves.
• Limacons.
• Circles centered away from the origin.
• Angular patterns.

Use Fit if the curve appears too small or too large. Use Trace to inspect angle and position.

Complex 2D graphing plots complex values on the real-imaginary plane.

A complex number:

z = a + bi

is plotted as:

x = Re(z)
y = Im(z)

So:

• 3 + 4i plots at (3, 4).
• i plots at (0, 1).
• -1 plots at (-1, 0).
• -2 + 5i plots at (-2, 5).

Complex Point Mode

Enter a constant complex expression:

3 + 4i

Callie Pro plots a point at (3, 4).

Trace readouts include:

• z
• Re(z)
• Im(z)
• |z|
• arg(z)

For 3 + 4i, the magnitude is 5.

Complex Path Mode

Enter a complex expression in terms of t.

Example:

z(t) = e^(i*t)
t min = 0
t max = 2*pi

This plots the unit circle because:

e^(i*t) = cos(t) + i*sin(t)

Other examples:

z(t) = t*e^(i*t)

Creates an outward spiral.

z(t) = (1 + 0.1*t)*e^(i*t)

Creates a growing spiral.

z(t) = e^((-0.1 + i)*t)

Creates a decaying spiral.

z(t) = cos(t) + i*sin(t)

Creates the unit circle.

Complex shorthand is accepted in complex graph expressions. You can type forms such as:

2i
3+4i
e^(i*t)
e^(it)
5t
5z

Callie Pro handles those as complex-aware notation without changing normal real-valued graph parsing.

Optional f(z) Transform

Complex mode can also graph a complex function over a path.

Example:

z(t) = e^(i*t)
f(z) = z^2

This maps the unit circle through z^2, creating a circle traced twice over the parameter range.

This is not full complex-plane domain coloring. It is path-based complex graphing: enter a path z(t), optionally transform it through f(z), and Callie Pro plots the resulting real and imaginary values.

3D Surface mode plots:

z = f(x, y)

Examples:

x^2 + y^2
sin(x)*cos(y)
sin(x - t)
sin(x)*cos(t)

Static 3D surfaces use x and y. Temporal 3D surfaces can also use t, which lets the surface move during playback.

Use 3D Surface mode for:

• Terrain-like surfaces.
• Wave surfaces.
• Potential wells.
• Height fields.
• Multivariable functions.

Mesh Quality

3D surfaces are sampled as a mesh. Higher mesh settings can look smoother, but they require more computation.

Use lower mesh settings when:

• You are animating a Temporal surface.
• The expression is expensive.
• The surface has many sharp features.
• You want the app to stay very responsive.

Use higher mesh settings when:

• Playback is paused.
• You want a cleaner export.
• You are inspecting a static surface.

Callie Pro skips invalid points such as NaN, infinity, and singularities when possible, so expressions like 1/sqrt(x^2+y^2) do not force the camera to frame impossible values.

3D Controls

The 3D graph area includes controls for:

• Surface mesh.
• Contours.
• Slices.
• 3D analysis updates.
• Trace center.
• Diagnostics and summaries.

These controls stay in the graph workspace, below or near the 3D canvas, so you can adjust the render without leaving the graph.

3D Curve / Vector mode plots a path in 3D:

x(t) = ...
y(t) = ...
z(t) = ...

Example:

x(t) = cos(t)
y(t) = sin(t)
z(t) = t
t min = 0
t max = 2*pi

This creates a helix.

For a simple vector from the origin, enter:

x(t) = 0.95*t
y(t) = 0.02*t
z(t) = 0.40*t
t min = 0
t max = 1

Callie Pro renders the curve from start to end and can show an endpoint marker/arrow direction when appropriate.

Use 3D Curve / Vector mode for:

• Vectors.
• Helices.
• Space curves.
• Parametric paths.
• Motion traces.

Complex 3D Surface mode plots a real height surface over the complex input plane.

You enter:

f(z) = ...

Callie Pro treats:

z = x + i*y

Then it evaluates f(z) over the selected real and imaginary ranges. The horizontal axes represent:

• Re(z)
• Im(z)

The vertical height is chosen by height mode:

• |f(z)|
• arg(f(z))
• Re(f(z))
• Im(f(z))

Example: z^2

Enter:

z^2

With height mode:

|f(z)|

This shows the magnitude of z^2 over the complex plane.

At z = 1 + i:

z^2 = 2i
|z^2| = 2

Example: 1/z

Enter:

1/z

This has a singularity at zero. Callie Pro skips invalid samples instead of stretching the surface into misleading spikes or crashing the render.

Example: ln(z)

Enter:

ln(z)

Try height mode:

Im(f(z))

This can reveal branch behavior in the complex logarithm.

Example: sin(z)

Enter:

sin(z)

Try height mode:

|f(z)|

This shows how the magnitude of the complex sine changes across the input plane.

Complex 3D is useful for visualizing complex functions as surfaces. It is not domain coloring; it is a height-surface view.

Temporal graph types add playback over a parameter, usually t.

Temporal Mode is built into dedicated temporal graph types rather than attached globally to every graph. That keeps ordinary graphing stable and makes playback behavior easier to understand.

Temporal graph types include:

• Temporal Function.
• Temporal Parametric.
• Temporal Polar.
• Temporal Complex.
• Temporal 3D Surface.

Temporal controls appear only for Temporal graph types.

Controls include:

• Play and Pause.
• Step backward.
• Step forward.
• Speed.
• Loop.
• Timeline or progress.
• Current t.

Temporal Function

Use Temporal Function for a real-valued graph that changes with time.

Example:

y = sin(x - t)
t min = 0
t max = 2*pi

As t advances, the wave translates.

Temporal Parametric

Use Temporal Parametric for motion along a parametric path.

Example:

x(t) = cos(t)
y(t) = sin(t)
t min = 0
t max = 2*pi

Playback moves the marker around the circle.

Temporal Complex

Use Temporal Complex for complex paths.

Example:

z(t) = e^(i*t)
t min = 0
t max = 2*pi

Playback moves around the unit circle on the complex plane.

Another example:

z(t) = e^(i*t) + cos(t)

This creates an offset complex path with a changing real component.

Temporal 3D Surface

Use Temporal 3D Surface for a surface that changes with time.

Examples:

z = sin(x - t)

A translating wave.

z = sin(x)*cos(t)

A standing wave.

z = sin(sqrt((x-t)^2 + y^2))

A moving ripple.

z = e^(-((x-t)^2 + y^2))

A moving Gaussian.

During playback, Callie Pro uses performance protections so the app stays responsive. Static surfaces can remain cached while temporal surfaces update. Playback may use lower-resolution preview meshes, then restore fuller quality when paused.

Synced Temporal Playback

When compatible Temporal expressions are visible together, Callie Pro can synchronize them with a shared scene clock.

This is useful for comparing multiple temporal fields that should move under the same t range.

For example, a multi-layer Temporal 3D Surface scene might include:

Y1 = -1/sqrt(x^2 + y^2 + 0.03^2)
Y2 = 0.35*e^(-80*((x-cos(t))^2 + (y-sin(t))^2))

The first surface is static. The second surface changes with t. Callie Pro keeps the static surface stable and updates the temporal surface during playback.

Temporal Safety

Temporal playback uses the same numeric safety rules as static graphing:

• Non-finite values are skipped.
• Unsafe graph values are rejected.
• Heavy 3D playback is throttled.
• Camera fitting is kept stable during playback.
• Editing an expression stops playback.

If a formula becomes invalid, playback stops or reports a clear problem rather than trying to render nonsense.

Temporal Performance And Quality

Temporal 3D surfaces recalculate geometry as t changes, so they can be substantially more expensive than static graphs.

Callie Pro uses bounded work, cancellation, and stale-frame protection so an older render does not replace a newer temporal state. When available, automatic quality behavior favors responsive playback and can use higher detail when the graph is paused or when more compute headroom is available.

For a fast membrane-style Temporal 3D example, use:

sin(pi*x)*sin(pi*y)*cos(3*t)

This produces a standing-wave membrane that moves smoothly without requiring an unusually dense mesh.

Trace lets you inspect graph values directly on the curve.

Use Trace when you want to answer:

• What is the value here?
• Where am I on the curve?
• What is the current x, y, t, or theta?
• What is the complex value at this point?
• What is the 3D point under the trace?

Starting Trace

Open TRACE or use trace controls from the graph.

For 2D graphs, trace moves along sampled curve points. Left and right move through the curve. Hold-to-repeat lets the trace continue moving while you hold the arrow.

For complex paths, trace reports:

• t
• z
• Re(z)
• Im(z)
• |z|
• arg(z)

For 3D curves, trace reports:

• t
• x
• y
• z

For 3D surfaces, trace can inspect the current surface slice or point depending on the graph type.

Tap-To-Trace

When available, tapping near a curve moves trace to a nearby sampled point. After that, arrow tracing continues normally along the sampled curve.

Tap-to-trace is meant to help you get close quickly. Fine movement still comes from the trace arrows.

Direct Trace Selection

When Trace is enabled, tapping or clicking near a supported 2D curve moves Trace to a nearby plotted point. Callie Pro chooses a nearby visible curve using screen-space proximity, then updates the active trace readout.

This gives you a quick way to jump to an interesting region before using fine trace movement.

Analysis Markers

Analysis tools can create markers for:

• Roots.
• Minimums.
• Maximums.
• Intersections.
• Derivatives and slopes.
• Tangents when explicitly requested.

Repeated analysis actions refresh existing markers instead of stacking duplicate overlays for the same expression and role.

The Table workspace shows numerical values for graph expressions.

Use Table when you want to inspect values without manually tracing point by point.

For a standard function, table rows usually show:

• x
• expression value
• status if a value cannot be evaluated

For complex graph mode, the table uses complex-specific columns:

• t
• Re(z)
• Im(z)
• |z|
• arg(z)

This means a complex table does not simply say that a result is complex. It shows the real and imaginary information in a useful form.

For z(t)=e^(i*t), useful rows include:

t = 0       Re = 1       Im = 0       |z| = 1
t = pi/2    Re = 0       Im = 1       |z| = 1
t = pi      Re = -1      Im = 0       |z| = 1
t = 3pi/2   Re = 0       Im = -1      |z| = 1
t = 2pi     Re = 1       Im = 0       |z| = 1

For 3D and Complex 3D modes, table views focus on the sampled quantities that make sense for the active expression, such as input coordinates, output components, magnitude, argument, and selected height.

The Window workspace controls graph bounds.

For 2D graphs, the main window values are:

• x min
• x max
• y min
• y max

For parameterized graphs, domain fields may also appear:

• t min
• t max
• samples

For 3D surfaces, you may also work with:

• x range
• y range
• z or height fit
• mesh resolution

Fit

Fit asks Callie Pro to frame visible finite graph content in the canvas.

Use Fit when:

• A graph appears too small.
• A graph is off-screen.
• You have zoomed or panned too far.
• You loaded a new expression and want a sensible view.

Fit ignores invalid samples, non-finite values, and skipped singularities. A single impossible spike should not ruin the view.

Zoom

Zoom In and Zoom Out change the visible range.

Callie Pro prevents unsafe numeric zoom extremes. If you attempt to zoom too far in or out, the app stops at a safe graph limit rather than letting the renderer collapse into numeric artifacts.

When a limit is reached, the app may show a small message such as:

Zoom limit reached

Reset

Fit or reset-style actions recover a sane graph view after panning, zooming, or rotating.

Use these when the graph is technically valid but no longer framed in a useful way.

Graph analysis tools help you find important features of a graph.

Depending on graph type and expression, tools may include:

• Root.
• Minimum.
• Maximum.
• Intersection.
• dy/dx.
• Tangent.
• Trace.

Root

Root analysis finds where a curve crosses zero.

For:

x^2 - 4

the roots are:

x = -2
x = 2

If you tap Root again, Callie Pro refreshes the root markers instead of adding duplicate copies.

dy/dx

dy/dx reports slope information.

For:

y = x^2

at:

x = 2

the slope is:

4

dy/dx uses compact slope markers. It does not draw a full tangent line unless you explicitly choose a tangent-style analysis.

Minimum And Maximum

Minimum and Maximum analysis finds local or visible extrema when the expression and sampled region support it.

Use Fit and Window controls to focus on the region you care about before relying on extrema.

Intersection

Intersection analysis compares visible expressions and finds crossing points where possible.

This is helpful when comparing models, solving approximate equations visually, or checking where two curves agree.

The calculator scratch area is for direct computation.

Use it for:

• Arithmetic.
• Scientific functions.
• Constants.
• Complex values.
• Quick checks before graphing.

Examples:

2 + 2
sin(pi/2)
asin(1)
sqrt(-4)
e^(i*pi) + 1
gcd(15, 12)
lcm(15, 28)

Expected results include:

2 + 2 = 4
sin(pi/2) = 1
asin(1) = 1.57079632679
sqrt(-4) = 2i
e^(i*pi) + 1 = 0
gcd(15, 12) = 3
lcm(15, 28) = 420

Calculator memory is designed for calculator-style work:

• M+ adds to memory.
• M- subtracts from memory.
• MR recalls memory.
• MC clears memory.

Memory is meant to persist until you clear it.

CAS is the computer algebra workspace. Use it when you want symbolic or exact-style help instead of only numeric graphing.

CAS operations include:

• Simplify.
• Factor.
• Expand.
• Solve.
• nsolve.
• Derivative.
• Integral.
• Limit.
• Matrix determinant.

Simplify

Simplify reduces an expression when possible.

Examples:

sin(x)^2 + cos(x)^2

Expected:

1

e^(i*pi)

Expected:

-1

Factor

Factor rewrites expressions into products.

Example:

x^2 - 4

Expected:

(x - 2)(x + 2)

Expand

Expand rewrites products or powers into expanded form.

Example:

(x + 1)^2

Expected:

x^2 + 2*x + 1

Solve

Solve finds symbolic solutions when possible.

Example:

x^2 - 4

Expected:

x = -2, 2

nsolve

nsolve is numerical solving. It uses an initial guess.

Use nsolve when:

• An equation is hard to solve symbolically.
• You want a numeric root near a starting point.
• You know approximately where the answer should be.

Derivative

Derivative computes a symbolic derivative.

Example:

x^2

Expected:

2*x

Integral

Integral computes an antiderivative when possible.

Example:

sin(x)

Expected:

-cos(x)

Limit

Limit evaluates expression behavior near a point.

Example:

sin(x)/x

with approach:

0

Expected:

1

Matrix Determinant In CAS

CAS can compute a determinant from matrix text.

Accepted forms include:

[[1,2],[3,4]]

and:

[1,2],[3,4]

Expected determinant:

-2

Malformed matrix text should return a clear syntax problem rather than a misleading result.

Complex CAS

CAS supports user-friendly complex notation.

Examples:

i
1i
2i
3+4i
3-4i
i^2
sqrt(-4)
(1+i)^2
e^(i*pi)
cos(pi) + i*sin(pi)

Expected results include:

i
i
2i
3 + 4i
3 - 4i
-1
2i
2i
-1
-1

The parser treats i as the imaginary unit only when it is actually a complex token. Ordinary names such as sin, limit, initial, and pi are not rewritten as imaginary expressions.

The Matrix workspace is for matrix entry and matrix operations.

Use Matrix for:

• Determinant.
• Inverse.
• RREF.
• Rank.
• Trace.
• Transpose.
• Solving Ax=b.
• Eigen operations.

Entering A Matrix

Use the grid editor or paste matrix text when available.

Example:

[1, 2]
[3, 4]

or:

[[1,2],[3,4]]

Determinant

For:

[[1,2],[3,4]]

determinant is:

-2

Inverse

The inverse of a square nonsingular matrix can be calculated from the Matrix workspace.

If a matrix is singular, Callie Pro reports that it cannot compute the inverse rather than returning invalid values.

RREF

RREF converts a matrix to reduced row echelon form.

Use it for:

• Solving linear systems.
• Checking rank.
• Understanding row dependencies.

Solve Ax=b

For systems of equations, enter matrix A and vector b, then solve.

The result is shown as variables such as:

x1 = ...
x2 = ...
x3 = ...

Eigen

Eigen output can be long, especially for larger matrices. Each matrix result card is meant to be readable, individually copyable, and clearable from history.

Advanced Matrix Operations

Callie Pro 1.1 adds additional professional linear-algebra tools.

Available operations include:

• LU decomposition.
• QR decomposition.
• Least-squares solving.
• Matrix norms.
• Conditioning diagnostics.

LU

LU decomposition factors a suitable matrix into triangular factors, with pivot information when required. Callie Pro uses scale-aware pivot handling and reports unreliable or singular cases rather than presenting a misleading factorization.

QR

QR decomposition produces orthogonal and upper-triangular factors for supported matrices. QR is also used internally in numerically stable fitting and least-squares workflows.

Least Squares

Least-squares solving is useful when a system has more equations than unknowns or when the data does not have an exact solution.

Norms

The Matrix workspace can report useful norms such as one norm, infinity norm, and Frobenius norm.

Conditioning

Condition diagnostics help indicate whether a matrix problem may be numerically sensitive. An unavailable condition estimate does not automatically mean Callie failed; singular or unreliable matrices may not have a useful finite condition estimate.

Derived Matrix Workflow

Matrix operations can create new named matrix objects. For example, applying an inverse and then another transformation may create a derived object that becomes the currently selected Matrix.

This lets you continue evolving a result without destroying the original matrix. Use the Matrix selector to return to the original object whenever you want to begin another calculation from it.

Matrix History

Matrix operations create result cards. You can review previous results, copy individual cards, and clear history when you want a fresh workspace.

Clear History removes all Matrix history cards, including long eigen output and error cards.

The Tensor workspace extends Callie Pro's linear-algebra tools into rank-N mathematics. A scalar can be considered rank 0, a vector rank 1, a matrix rank 2, and a general tensor rank N.

The workspace is organized into:

• Components
• Algebra
• Transform
• Metrics
• Geometry
• Calculus

Callie Pro keeps advanced tools separated so you can inspect a tensor without exposing every geometry or calculus control at once.

Creating And Selecting Tensors

Use New to create a tensor or Load Example to create a known working example. A tensor stores a name, shape, values, rank, real or complex values, optional index notation, and optional basis or coordinate information.

For example, a shape of 2, 2 creates a rank-2 object with four components. A shape of 3, 3, 3 creates a rank-3 object with 27 components. Callie Pro protects against requests that would require unreasonable memory or temporary workspace.

Components

Components shows the actual stored values. For a rank-2 tensor, the component view behaves much like a matrix. For rank 3 and higher, Callie Pro displays a selected two-dimensional slice while the remaining indices choose which slice you are viewing. Component indices are zero-based in the component inspector.

This lets you work with high-rank tensors without trying to display every component in one enormous grid.

Indexed Notation

Callie Pro supports upper and lower tensor indices. Examples include A_ij, T^i_jk, g_ij, g^ij, v^i, and v_i. Callie renders these as professional mathematical superscripts and subscripts.

Upper and lower indices are mathematically meaningful. Callie Pro does not silently raise or lower an index simply because its notation changed. Use a metric tensor when an index must actually be raised or lowered.

Einstein Summation

The Algebra workspace supports Einstein-style indexed contractions. For example, C_ij = A_ik B^k_j contracts the repeated index k, which appears once lower and once upper. Free indices remain on the output tensor.

Callie Pro rejects ambiguous or dimensionally incompatible indexed expressions rather than guessing.

einsum

The Tensor workspace also supports explicit einsum notation for array-style contractions, such as ij,jk->ik. Use Einstein indexed notation when upper/lower variance matters. Use einsum when you want explicit array contraction semantics.

Transform

Transform operations include reshape, axis permutation, inserting singleton axes, reductions, generalized trace, contractions, outer products, Kronecker products, and joining compatible tensors. Axis permutation changes the order of tensor axes; for a rank-2 tensor, 1, 0 acts like a transpose.

Callie creates derived tensor objects so you can keep the original object and continue working from a result.

Metrics, Symmetry, And Identities

The Metrics workspace includes raising and lowering an index, inverting a metric, symmetric and antisymmetric parts, the Kronecker delta, the Levi-Civita symbol, and coordinate transformation.

For dimension 3, δⁱⱼ produces the mixed-index identity tensor. The three-dimensional Levi-Civita symbol creates a rank-3, 3×3×3 antisymmetric object whose nonzero components are ±1 according to permutation parity; components with repeated indices are zero.

Tensor Calculus

The Calculus workspace includes supported operations such as gradient, Jacobian, Hessian, divergence, and curl. These operations return mathematical objects where appropriate rather than only formatted text.

Geometry

The Geometry workspace provides numerical differential-geometry tools built on the tensor engine. Supported quantities include metric evaluation, Christoffel symbols, Riemann curvature tensor, Ricci tensor, and scalar curvature. These tools are numerical/function-backed calculations; they are not a claim of unrestricted symbolic differential geometry.

A useful reference check is flat polar coordinates: Christoffel symbols can be nonzero even though curvature remains zero.

Tensor And Matrix

Rank-2 tensors can be opened in Matrix, and Matrix objects can be sent into Tensor. Callie preserves the original object and creates a new mathematical object for the handoff where appropriate. Higher-rank tensors are not silently flattened into matrices; use a rank-2 slice when you want to inspect part of a higher-rank tensor in Matrix.

Tensor And Python

A Tensor can be sent to the Python workspace. Callie prepares an editable Python representation; it does not execute the script automatically. Compatible Python results can also be deliberately imported back into Tensor. The same local Python sandbox restrictions still apply.

Tensor Persistence

Tensor drafts and saved tensor objects participate in Callie Pro's document persistence. Edits are retained across workspace changes and normal app backgrounding, and the app flushes pending state during lifecycle transitions.

Apply validates edited tensor definitions before updating the named mathematical object. Draft persistence and mathematical validation are intentionally separate: unfinished input can be preserved without becoming a valid tensor operation target.

The Stats workspace is for descriptive statistics, confidence intervals, and hypothesis tests.

Use Stats when you have data and want summaries or inference.

Common tasks include:

• Enter a dataset.
• Compute summary statistics.
• Run confidence intervals.
• Run hypothesis tests.
• Export dataset CSV.

Dataset Entry

Enter numeric values in the dataset area. Depending on the active tool, values may be separated by lines, commas, or table-style input.

Use clear labels in your own notes so you remember what each dataset represents.

Descriptive Statistics

Stats can summarize a dataset with values such as:

• Count.
• Mean.
• Median.
• Standard deviation.
• Minimum and maximum.
• Quartiles when available.

Confidence Intervals

Confidence intervals estimate a range for a population value from sample data.

Use them when you want a statement such as:

The mean is estimated to be within this range at the selected confidence level.

Choose the interval type that matches your data and question.

Hypothesis Tests

Hypothesis tests compare data against a claim or comparison value.

Use them when you want to test questions such as:

• Is the mean different from a target?
• Is a proportion different from a claimed value?
• Is a difference statistically meaningful under the selected assumptions?

Callie Pro reports the relevant test output and keeps the workflow inside the calculator workspace.

Regression Improvements

Callie Pro 1.1 uses a more consistent regression workflow so fitted coefficients, residuals, diagnostics, and graph output refer to the same fitted model. Polynomial fitting uses numerically more stable internal methods for supported datasets.

Regression output can include coefficient estimates, RMSE, R² when defined, and excluded or invalid observation counts. Use Explore or the available graph handoff to send data and fitted models into graphing without manually recreating the result. Datasets can also be handed to Tensor or Python when the current data is compatible.

Stats Export

Stats datasets can be exported as CSV. On iPad, the export creates a persistent file and opens the standard share sheet so you can save or send it.

The Python workspace lets you write and run small local scripts for numerical work.

It is designed for calculator-style scripts, not for installing packages or building external apps.

Use Python for:

• Numerical checks.
• Small loops.
• Formula exploration.
• Vector calculations.
• Data transformations.
• Generating graph points through supported app bridges.

Script Editor

The script editor is the main text area. It is scrollable, so longer scripts stay inside the editor rather than pushing the workspace around.

Use LTTR for text entry. The directional pad becomes text navigation while LTTR is active.

Helpful keys:

• SPC inserts a space.
• TAB inserts indentation.
• ENTER inserts a newline.
• DEL deletes text.
• Arrows move the cursor.

Running A Script

Tap Run Script to execute the current visible script buffer.

Output appears in the output panel. Errors appear there as well, so you can correct the script without leaving the workspace.

Copying And Clearing Output

Use:

• Copy Output to copy the latest output text.
• Clear Output to clear only the output panel.
• Clear Script to clear the current script after confirmation.
• Reset Runtime to reset runtime state without replacing the script.

Example: Basic Loop

for i in range(5):
    print(i)

Expected output:

0
1
2
3
4

Example: Lists And Comprehensions

xs = [-3, -2, -1, 0, 1, 2, 3]
ys = [x*x - 4 for x in xs]
print(ys)

Expected output:

[5, 0, -3, -4, -3, 0, 5]

Example: Dot Product

def dot(a, b):
    return sum(x*y for x, y in zip(a, b))

print(dot([1, 2], [3, 4]))

Expected output:

11

Example: Math Module

from math import gcd

print(gcd(15, 12))

Expected output:

3

Python Sandbox Limits

The Python workspace runs locally inside a restricted calculator sandbox.

The sandbox is intended for visible, user-written numerical scripts. It is not designed for:

• Downloading code.
• Installing packages.
• Accessing the network.
• Spawning processes.
• Reading or writing arbitrary files.
• Modifying app features.

If a script attempts something outside the calculator sandbox, Callie Pro blocks it and reports the issue.

Matrix And Tensor Handoffs

Callie Pro can prepare Matrix, Tensor, and compatible dataset values for Python. A handoff creates editable Python code or data representation; it does not automatically run the script.

Tensor transfers preserve shape information. Larger transfers may use structured JSON rather than an enormous inline value list. When a compatible script explicitly emits a Callie tensor payload, the result can be deliberately imported back into Tensor.

Python remains local and sandboxed. Cross-workspace handoffs do not grant Python additional system access.

The Catalog helps you find functions, constants, and insertable terms without memorizing every key layer.

Use Catalog when you need:

• A trig function.
• A logarithm.
• A hyperbolic function.
• Complex functions.
• Constants.
• Engineering values.
• Special functions that are easier to search than type.

Examples of useful entries include:

sin(
cos(
tan(
asin(
acos(
atan(
sqrt(
ln(
log10(
gamma(
gcd(
lcm(

Constants and engineering values can help with applied calculations. Use them as references or insert them into compatible fields when available.

Callie Pro can export graph and data artifacts.

Available export types include:

• PNG.
• PDF.
• CSV.
• JSON.
• SVG.

Stats can also export dataset CSV.

On iPad, exports use the standard iPadOS share sheet. The flow is:

1. Choose an export type from the File/export controls.
2. Callie Pro generates the file.
3. The file is saved in the app's Downloads/CalliePro location.
4. The iPadOS share sheet opens.
5. Choose Save to Files, AirDrop, Mail, Copy, or another available action.

Canceling the share sheet does not delete the generated file.

PNG Export

PNG exports are image exports of the graph view.

Use PNG when you want:

• A quick visual.
• A web image.
• A screenshot-like graph artifact.
• A file to drop into a document or presentation.

PDF Export

PDF exports include a graph page and report-style context.

Graph PDF reports can include:

• The graph.
• Equations.
• Window settings.
• Annotations.
• Table preview.

Use PDF when you want a more complete saved explanation of the graph.

CSV Export

CSV exports are best for data.

Graph CSV exports can include:

• Graph metadata.
• Equations.
• Window context.
• Table preview.
• Additional workspace sections when relevant.

Use CSV when you want to analyze or archive values outside the app.

JSON Export

JSON exports are structured graph-document data.

Use JSON when you want a machine-readable representation of the graph document.

SVG Export

SVG exports create scalable vector graph output.

SVG is useful for:

• Web graphics.
• Scalable diagrams.
• Design workflows.
• Clean line-art style graph output.

Graph SVG exports include metadata so the file carries more context than only the visible plot.

Callie Pro 1.1 supports portrait and landscape iPad layouts and adapts to supported resizable multitasking windows. Wide layouts can place mathematical work and supporting controls side by side.

Examples include Graph with expressions or window controls beside the plot, Matrix with editing and results using more horizontal space, Tensor with operation controls and component/result inspection, and Python with more room for code and output.

The calculator keypad can be hidden when you want to give a professional workspace more screen area, especially when using a hardware keyboard. Changing window size does not change the mathematical document; workspace drafts and saved objects continue to use the same persistence system.

Callie Pro distinguishes between preserving what you are typing and committing a valid mathematical object.

Drafts

Matrix, Tensor, Statistics, and other supported workspace drafts are saved automatically. Incomplete input can survive switching workspaces, moving Callie Pro to the background, returning to the app, and supported iPad multitasking transitions.

Apply

Apply validates the current Matrix or Tensor definition and updates the named mathematical object. Use Apply when you want the edited object to become the version used by mathematical operations.

Automatic Persistence

Callie Pro uses ordered document writes and lifecycle flushing so newer state is not intentionally replaced by an older pending save. If a save fails, the app preserves the last good document where possible rather than silently replacing it with unreadable data.

As with any important work, keep external backups of documents you cannot easily recreate.

Callie Pro is built as a local calculator workspace.

Core behavior:

• No account is required.
• Calculations run locally.
• Graph documents are local.
• Matrix, Stats, CAS, and Python workspaces run inside the app.
• Python is sandboxed for calculator-style numerical scripts.
• Exports are generated as files you choose to save or share.

The app does not require a sign-in workflow to use the calculator, graphing, CAS, Matrix, Stats, Python, or export features.

The graph is blank

Check:

• Is the expression visible?
• Is the expression valid for its graph type?
• Is the window range appropriate?
• Does the expression produce real values in a real graph mode?
• Would Complex Graph mode be more appropriate?

Try:

1. Tap Y= and confirm the expression.
2. Tap GRAPH.
3. Tap Fit.
4. Check Table for evaluation messages.

The graph is too small or off-screen

Use Fit.

If the graph still looks wrong:

• Check for extreme values.
• Narrow the window.
• Hide other expressions.
• Reduce 3D mesh complexity if the expression is heavy.

A 3D surface has holes

Holes usually mean some sampled points were invalid or singular.

Examples:

• Division by zero.
• Logarithm branch behavior.
• Infinite or non-finite results.
• Values beyond safe graph limits.

This is often better than drawing misleading spikes.

Temporal playback feels heavy

Try:

• Lowering mesh resolution while playback is running.
• Hiding nonessential 3D surfaces and overlays.
• Using a simpler expression.
• Pausing playback before increasing mesh quality.
• Using Fit before playback starts.
• Letting automatic quality manage detail where available.

Temporal 3D surfaces can be computationally expensive. Callie Pro uses bounded work, cancellation, stale-frame protection, preview meshes, and throttling to keep the app responsive, but very heavy formulas can still take more time.

A CAS result is not what you expected

Check:

• Did you choose the right CAS operation?
• Did you specify the variable?
• For limit, did you set the approach value?
• For nsolve, did you choose a reasonable initial guess?
• Is your matrix syntax valid?

Try simplifying the expression first or testing a smaller expression in the calculator scratch area.

Python did not run

Check:

• Is the script visible in the editor?
• Did you tap Run Script?
• Is there an error message in output?
• Did the script try to use a blocked module or system feature?

Python is intentionally sandboxed. Keep scripts focused on local numerical work.

Matrix operation failed

Check:

• Determinant and inverse require square matrices.
• Inverse requires a nonsingular matrix.
• Solve Ax=b requires compatible dimensions.
• Eigen output may be long for larger matrices.
• Matrix text must be valid rectangular numeric data.

My Tensor Operation Failed

Check:

• Does the tensor shape match the operation?
• Are contraction dimensions compatible?
• Does an Einstein dummy index appear once upper and once lower?
• Are you trying to raise or lower an index without a compatible metric?
• Does the selected object contain unapplied draft changes?
• Is the requested tensor too large for the current resource limit?

Callie Pro rejects ambiguous indexed operations rather than silently guessing.

My Tensor Does Not Fit On Screen

For rank-3 and higher tensors, use the component slice controls. Callie Pro displays a two-dimensional plane and fixes the remaining indices to selected values. This is intentional and avoids rendering an unusable multidimensional grid.

My Work Changed When I Switched Objects

Matrix and Tensor operations can create derived mathematical objects and select the result. Use the object selector to return to the original Matrix or Tensor. This is designed to let you evolve a calculation without overwriting the source object.

Export did not go where expected

After choosing an export type, use the iPadOS share sheet to decide where the file goes.

If you cancel the share sheet, the generated file still remains in Callie Pro's export location. Run the export again if you want to send it somewhere else.

If you are new to Callie Pro, try this sequence.

1. Basic Graph

Enter:

Y1 = sin(x)

Open GRAPH, then TRACE.

Move along the curve with the arrows.

2. Compare Two Functions

Enter:

Y1 = sin(x)
Y2 = 0.2*x^2 - 2

Use GRAPH, TABLE, and TRACE.

Try intersection analysis if available for the visible curves.

3. Complex Graph

Create a Complex graph:

z(t) = e^(i*t)
t min = 0
t max = 2*pi

Trace the path and watch Re, Im, |z|, and arg.

4. 3D Surface

Create a 3D Surface:

z = sin(x)*cos(y)

Use Fit, rotate the view, and try mesh or contour controls.

5. Temporal Surface

Create a Temporal 3D Surface:

z = sin(x - t)
t min = 0
t max = 2*pi

Press Play and observe the wave movement.

6. CAS

Open CAS and try:

sin(x)^2 + cos(x)^2

Choose Simplify.

Then try:

x^2 - 4

Choose Factor or Solve.

7. Matrix

Open Matrix and enter:

[[1,2],[3,4]]

Run determinant and inverse.

8. Tensor

Open Tensor and run Load Example. Evaluate the supplied Einstein contraction, then try a transform or identity such as δⁱⱼ.

9. Stats

Enter a small dataset and compute descriptive statistics. Then try a confidence interval or hypothesis test if it matches your data.

10. Python

Open Python and run:

xs = [-3, -2, -1, 0, 1, 2, 3]
ys = [x*x - 4 for x in xs]
print(ys)

Copy the output, clear it, and try a second script.

11. Export

Return to a graph and export:

• PNG for a quick image.
• PDF for a graph report.
• CSV for table/context data.
• SVG for scalable graph artwork.
• JSON for structured graph document data.

• Use Y= to define, GRAPH to inspect, TRACE to explore, TABLE to verify, and WINDOW to frame.
• Use Fit whenever a graph looks lost.
• Use Complex Graph mode when a real graph reports complex values.
• Use Temporal graph types only when you want playback.
• Keep heavy 3D meshes lower during playback and higher when paused.
• Use CAS for symbolic work and the calculator scratch area for fast numeric checks.
• Use Matrix for structured linear algebra rather than forcing matrix text through the calculator.
• Use Python for small custom numerical scripts, loops, and data checks.
• Export PDF when you want context, not just an image.
• Export CSV when values matter more than visuals.

CAS

Computer algebra workspace for operations such as simplify, factor, expand, solve, derivative, integral, limit, nsolve, and determinant.

Complex Graph

A graph mode that plots complex outputs using real values on the horizontal axis and imaginary values on the vertical axis.

Complex 3D Surface

A graph mode that evaluates f(z) across the complex input plane and maps magnitude, argument, real part, or imaginary part to height.

Fit

A graph action that frames visible finite graph content inside the canvas.

LTTR

The calculator shell's letter/text entry mode.

Matrix Workspace

Workspace for matrix input, determinant, inverse, RREF, rank, trace, transpose, solve Ax=b, eigen operations, LU, QR, least-squares solving, norms, and conditioning diagnostics.

Tensor

A multidimensional mathematical object. Scalars, vectors, and matrices can be viewed as rank-0, rank-1, and rank-2 cases.

Rank

The number of tensor axes. A matrix has rank 2.

Shape

The size of each tensor axis, such as 3 × 3 × 3.

Tensor Index

A label attached to a tensor axis. Callie Pro distinguishes upper and lower indices.

Einstein Summation

A notation where compatible repeated indices imply contraction.

Metric Tensor

A tensor used to define geometric inner products and to raise or lower indices.

Kronecker Delta

The mixed-index identity tensor, commonly written δⁱⱼ.

Levi-Civita Symbol

A fully antisymmetric indexed object used in tensor and vector calculations.

Christoffel Symbols

Connection coefficients derived from a metric and its coordinate derivatives. They can be nonzero even in a flat coordinate system.

Riemann Curvature Tensor

A tensor describing intrinsic curvature.

Ricci Tensor

A contraction of the Riemann curvature tensor.

Scalar Curvature

A scalar contraction derived from the Ricci tensor and metric.

Mesh

The sampled grid used to draw a 3D surface.

Temporal Graph

A dedicated graph type that supports playback over a time-like parameter t.

Trace

A graph exploration mode that moves through points and reports values.

Window

The graph bounds and viewing range.

Callie Pro is meant to feel like a mathematical workspace rather than a stack of separate tools. The graph, calculator shell, CAS, Matrix, Tensor, Stats, Python, Catalog, and export flows are designed to stay close together so you can move from question to expression to visualization to result without rebuilding your context.

Start with one expression. Trace it. Table it. Change the window. Then try Complex, 3D, Temporal, CAS, Matrix, Tensor, Stats, and Python as the problem asks for them.