levycas 1.0.0__tar.gz

levycas-1.0.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alex Levy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

levycas-1.0.0/MANIFEST.in

@@ -0,0 +1 @@
+include src/levycas/cli/screens/styles/*

levycas-1.0.0/PKG-INFO

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: levycas
+Version: 1.0.0
+Summary: A computer algebra system written in python, with an interactive text-based user interface complete with a built-in scripting language and graphing directly in the terminal.
+Author-email: Alex Levy <ajlevy246@gmail.com>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/ajlevy246/LevyCAS
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Provides-Extra: tui
+Requires-Dist: textual; extra == "tui"
+Requires-Dist: textual-plot; extra == "tui"
+Provides-Extra: dev
+Requires-Dist: textual; extra == "dev"
+Requires-Dist: textual-plot; extra == "dev"
+Requires-Dist: textual-dev; extra == "dev"
+Requires-Dist: pytest-textual-snapshot; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Dynamic: license-file
+
+# Welcome to LevyCAS!
+
+[![CI](https://github.com/ajlevy246/LevyCAS/actions/workflows/python-package.yml/badge.svg)](https://github.com/ajlevy246/LevyCAS/actions/workflows/python-package.yml)
+[![codecov](https://codecov.io/gh/ajlevy246/LevyCAS/graph/badge.svg?token=MlatPlQxJ6)](https://codecov.io/gh/ajlevy246/LevyCAS)
+
+**LevyCAS** is a lightweight symbolic computer algebra system (CAS) written in Python. It focuses on parsing natural mathematical expressions into symbolic objects and performing symbolic manipulation, calculus, simplification, and number-theoretic computations.
+
+<img src="https://github.com/ajlevy246/LevyCAS/blob/main/assets/graph.png?raw=true" width=1000 alt="A screenshot of the LevyCAS graphing textual user interface. Expressions are entered on the left hand side, and an interactive graph is plotted on the right.">
+
+<br/> 
+
+LevyCAS remains an educational project, exploring symbolic computation, expression trees, Pratt parsing, grammars, and terminal UIs. It's designed to combine the best of existing computational tools that I regularly use: Desmos, Sympy, and Matlab. 
+
+## Features
+- Parse natural mathematical expressions.
+- Write scripts with a custom scripting language.
+- Symbolic integrals & derivatives.
+- Expression simplification & normalization.
+- Integer factorization & number-theoretic operations.
+- Multivariate polynomial operations: factoring, partial fractions, rationalization.
+- Interactive Textual-based graphing & scripting interface.
+- Python library core with no required dependencies.
+
+<br/>
+
+# Installation & Quick Start:
+
+While the base package has no dependencies, it is designed for Python3.10+
+
+## Core package & CLI
+LevyCAS is uploaded as a Python package on the TestPyPi index [here](https://test.pypi.org/project/levycas/). Install with pip:
+
+```bash
+$ python3 -m pip install levycas --index-url https://test.pypi.org/simple/ 
+```
+
+Then, get started by launching python and running:
+```python
+from levycas import symbols, parse, derivative, integrate
+
+x, y = symbols("x y")
+expr = parse("sin(x)cos(y)")
+print(expr)
+
+print(derivative(expr, x))
+print(integrate(expr, x))
+```
+
+Or through the command-line interface:
+```bash
+$ levycas integrate "xsin(x^2)"
+```
+
+## Terminal-Based TUI
+To use the textual user interface, install with the `tui` extra. This extra depends on the [`Textual`](https://textual.textualize.io/) library, as well as the `textual-plot` package.
+
+```bash
+$ python3 -m pip install levycas[tui] --extra-index-url https://test.pypi.org/simple/ 
+```
+
+Launch the TUI directly in your terminal:
+
+```bash
+$ levycas
+```
+
+Or jump straight to the graphing interface:
+
+```bash
+$ levycas graph "sin(x)" "x^2" "lnx" "exp(x)"
+```
+
+<br/>
+
+# Textual User Interface
+
+By default, installing the `tui` extra adds the `levycas` script to PATH. Launch the powerful interface to write scripts or plot expressions:
+
+<img src="https://github.com/ajlevy246/LevyCAS/blob/main/assets/script.png?raw=true" width=1000 alt="A screenshot of the LevyCAS scripting textual user interface. A script is entered on the left hand side, while output is printed on the right.">
+
+<br/>
+
+# Project Structure
+
+The base package consists of a set of core expression objects, along with a set of routines acting on them.
+
+In addition, LevyCAS includes a native Pratt parser capable of interpreting natural mathematical syntax such as `sin(x)cosx`, `1/2x`, and `3ln(x^2)` into symbolic expression trees.
+
+### [`src/levycas/`](./src/levycas/__init__.py)
+- [`expressions/`](./src/levycas/expressions/__init__.py): Defines the symbolic expression tree classes used through LevyCAS. These classes make extensive use of Python's operator overloading and inheritance to provide a simple interface.
+
+- [`operations/`](./src/levycas/operations/__init__.py): The routines consist of both the fundamental simplification operations (`simplify`, `sym_eval`), as well as useful symbolic computations like `derivative` and `integrate`. 
+
+- [`parser/`](./src/levycas/parser/__init__.py): All of the Pratt parsing logic is contained here. Lexing converts and input string into tokens, and the parsing logic converts it to native objects.
+
+- [`cli/`](./src/levycas/cli/__init__.py): All of the logic for the textual user interface is contained here. This module does not expose any external functions, but the scripts here may be interesting to those building simple Textual apps themselves.
+
+- [`scripting/`](./src/levycas/scripting/__init__.py): The custom scripting language logic is written here. See the grammar and examples in [`GRAMMAR.md`](./src/levycas/scripting/GRAMMAR.md). Use the TUI to run scripts or load them from disk.
+
+<br/>
+
+# Examples:
+
+### Parse
+```python
+>>> from levycas import parse
+
+# implicit multiplication & function args
+>>> parse("1/2sin(x)cosx")
+(1/2)Sin(x)Cos(x)
+
+# symbol generation
+>>> parse("ax^2 + bx + c")
+ax² + bx + c
+
+# automatic simplification/normalization
+>>> parse("2(x+3) - x - 6y/y")
+x
+```
+
+### Polynomial Factoring
+```python
+>>> from levycas import Variable, factor
+>>> x = Variable("x")
+
+# repeated irreducible factors
+>>> factor(x**8 + 2*x**6 - 6*x**5 - 12*x**3 + 9*x**2 + 18, x)
+[1, x² + 2, (x³ - 3)^2]
+
+# generalized polynomial variables
+>>> factor(4*Ln(x)**2 + 10*Ln(x) + 6, Ln(x))
+[2, Ln(x) + 1, 2Ln(x) + 3]
+```
+
+### Symbolic Integration
+```python
+>>> from levycas.expressions import Variable, Sin, Cos, Ln,
+>>> from levycas.operations  import integrate, collect_terms
+>>> x = Variable("x")
+
+# u-substitution
+>>> integrate(x*Sin(x**2), x)
+-(1/2)(Cos(x)^2)
+
+# partial fractions via Hermite reduction
+>>> integrate(1 / ((x**2+1)*(x-2)), x)
+-(1/10)Ln(x² + 1) + (1/5)Ln(x - 2) - (2/5)Arctan(x)
+
+# integration by parts
+>>> integrate(x**3 * Exp(x), x)
+>>> collect_terms(_, Exp(x))
+(x³ - 3x² + 6x - 6)Exp(x)
+```
+
+### Symbolic Derivatives
+```python
+>>> from levycas.expression import Variable, Cos, Ln
+>>> from levycas.operations import derivative, trig_simplify
+>>> x = Variable('x')
+
+>>> derivative(x**4 + x**3 + x**2 + x, x)
+1 + 2x + 3x² + 4x³
+
+>>> derivative((Cos(x)+Sin(x))**2,  x)
+>>> trig_simplify(_)
+2Cos(2x)
+
+>>> derivative(x*Ln(x) - x, x)
+Ln(x)
+```
+
+### Algebraic Operations
+```python
+>>> from levycas.expressions import Variable
+>>> from levycas.operations import rationalize, partial_fractions as partial
+>>> x = Variable('x')
+
+# partial fractions
+>>> partial(8*x+7, [x+2, x-1], x)
+3/(x+2) + 5/(x-1)
+
+# rationalization
+>>> rationalize(3/(x+2) + 5/(x-1))
+(8x+7)/((x+2)*(x-1))
+```
+
+### Integer Operations
+```python
+>>> from levycas import is_prime, factor_integer, gcd
+
+>>> gcd(2**4 * 3**5 * 5**3, 7**4 * 11**4 * 13**5)
+1
+
+>>> factor_integer(2**4 * 3**5 * 5**3 * 7**9)
+{2: 4, 3: 5, 5: 3, 7: 9}
+
+# integer radical
+>>> def rad(n: Integer) -> Integer:
+>>>     rad, factors = 1, factor_integer(n).keys()
+>>>     for factor in factors:
+>>>         rad *= factor
+>>>     return rad
+
+>>> rad(18)
+6
+```
+

levycas-1.0.0/README.md

@@ -0,0 +1,207 @@
+# Welcome to LevyCAS!
+
+[![CI](https://github.com/ajlevy246/LevyCAS/actions/workflows/python-package.yml/badge.svg)](https://github.com/ajlevy246/LevyCAS/actions/workflows/python-package.yml)
+[![codecov](https://codecov.io/gh/ajlevy246/LevyCAS/graph/badge.svg?token=MlatPlQxJ6)](https://codecov.io/gh/ajlevy246/LevyCAS)
+
+**LevyCAS** is a lightweight symbolic computer algebra system (CAS) written in Python. It focuses on parsing natural mathematical expressions into symbolic objects and performing symbolic manipulation, calculus, simplification, and number-theoretic computations.
+
+<img src="https://github.com/ajlevy246/LevyCAS/blob/main/assets/graph.png?raw=true" width=1000 alt="A screenshot of the LevyCAS graphing textual user interface. Expressions are entered on the left hand side, and an interactive graph is plotted on the right.">
+
+<br/> 
+
+LevyCAS remains an educational project, exploring symbolic computation, expression trees, Pratt parsing, grammars, and terminal UIs. It's designed to combine the best of existing computational tools that I regularly use: Desmos, Sympy, and Matlab. 
+
+## Features
+- Parse natural mathematical expressions.
+- Write scripts with a custom scripting language.
+- Symbolic integrals & derivatives.
+- Expression simplification & normalization.
+- Integer factorization & number-theoretic operations.
+- Multivariate polynomial operations: factoring, partial fractions, rationalization.
+- Interactive Textual-based graphing & scripting interface.
+- Python library core with no required dependencies.
+
+<br/>
+
+# Installation & Quick Start:
+
+While the base package has no dependencies, it is designed for Python3.10+
+
+## Core package & CLI
+LevyCAS is uploaded as a Python package on the TestPyPi index [here](https://test.pypi.org/project/levycas/). Install with pip:
+
+```bash
+$ python3 -m pip install levycas --index-url https://test.pypi.org/simple/ 
+```
+
+Then, get started by launching python and running:
+```python
+from levycas import symbols, parse, derivative, integrate
+
+x, y = symbols("x y")
+expr = parse("sin(x)cos(y)")
+print(expr)
+
+print(derivative(expr, x))
+print(integrate(expr, x))
+```
+
+Or through the command-line interface:
+```bash
+$ levycas integrate "xsin(x^2)"
+```
+
+## Terminal-Based TUI
+To use the textual user interface, install with the `tui` extra. This extra depends on the [`Textual`](https://textual.textualize.io/) library, as well as the `textual-plot` package.
+
+```bash
+$ python3 -m pip install levycas[tui] --extra-index-url https://test.pypi.org/simple/ 
+```
+
+Launch the TUI directly in your terminal:
+
+```bash
+$ levycas
+```
+
+Or jump straight to the graphing interface:
+
+```bash
+$ levycas graph "sin(x)" "x^2" "lnx" "exp(x)"
+```
+
+<br/>
+
+# Textual User Interface
+
+By default, installing the `tui` extra adds the `levycas` script to PATH. Launch the powerful interface to write scripts or plot expressions:
+
+<img src="https://github.com/ajlevy246/LevyCAS/blob/main/assets/script.png?raw=true" width=1000 alt="A screenshot of the LevyCAS scripting textual user interface. A script is entered on the left hand side, while output is printed on the right.">
+
+<br/>
+
+# Project Structure
+
+The base package consists of a set of core expression objects, along with a set of routines acting on them.
+
+In addition, LevyCAS includes a native Pratt parser capable of interpreting natural mathematical syntax such as `sin(x)cosx`, `1/2x`, and `3ln(x^2)` into symbolic expression trees.
+
+### [`src/levycas/`](./src/levycas/__init__.py)
+- [`expressions/`](./src/levycas/expressions/__init__.py): Defines the symbolic expression tree classes used through LevyCAS. These classes make extensive use of Python's operator overloading and inheritance to provide a simple interface.
+
+- [`operations/`](./src/levycas/operations/__init__.py): The routines consist of both the fundamental simplification operations (`simplify`, `sym_eval`), as well as useful symbolic computations like `derivative` and `integrate`. 
+
+- [`parser/`](./src/levycas/parser/__init__.py): All of the Pratt parsing logic is contained here. Lexing converts and input string into tokens, and the parsing logic converts it to native objects.
+
+- [`cli/`](./src/levycas/cli/__init__.py): All of the logic for the textual user interface is contained here. This module does not expose any external functions, but the scripts here may be interesting to those building simple Textual apps themselves.
+
+- [`scripting/`](./src/levycas/scripting/__init__.py): The custom scripting language logic is written here. See the grammar and examples in [`GRAMMAR.md`](./src/levycas/scripting/GRAMMAR.md). Use the TUI to run scripts or load them from disk.
+
+<br/>
+
+# Examples:
+
+### Parse
+```python
+>>> from levycas import parse
+
+# implicit multiplication & function args
+>>> parse("1/2sin(x)cosx")
+(1/2)Sin(x)Cos(x)
+
+# symbol generation
+>>> parse("ax^2 + bx + c")
+ax² + bx + c
+
+# automatic simplification/normalization
+>>> parse("2(x+3) - x - 6y/y")
+x
+```
+
+### Polynomial Factoring
+```python
+>>> from levycas import Variable, factor
+>>> x = Variable("x")
+
+# repeated irreducible factors
+>>> factor(x**8 + 2*x**6 - 6*x**5 - 12*x**3 + 9*x**2 + 18, x)
+[1, x² + 2, (x³ - 3)^2]
+
+# generalized polynomial variables
+>>> factor(4*Ln(x)**2 + 10*Ln(x) + 6, Ln(x))
+[2, Ln(x) + 1, 2Ln(x) + 3]
+```
+
+### Symbolic Integration
+```python
+>>> from levycas.expressions import Variable, Sin, Cos, Ln,
+>>> from levycas.operations  import integrate, collect_terms
+>>> x = Variable("x")
+
+# u-substitution
+>>> integrate(x*Sin(x**2), x)
+-(1/2)(Cos(x)^2)
+
+# partial fractions via Hermite reduction
+>>> integrate(1 / ((x**2+1)*(x-2)), x)
+-(1/10)Ln(x² + 1) + (1/5)Ln(x - 2) - (2/5)Arctan(x)
+
+# integration by parts
+>>> integrate(x**3 * Exp(x), x)
+>>> collect_terms(_, Exp(x))
+(x³ - 3x² + 6x - 6)Exp(x)
+```
+
+### Symbolic Derivatives
+```python
+>>> from levycas.expression import Variable, Cos, Ln
+>>> from levycas.operations import derivative, trig_simplify
+>>> x = Variable('x')
+
+>>> derivative(x**4 + x**3 + x**2 + x, x)
+1 + 2x + 3x² + 4x³
+
+>>> derivative((Cos(x)+Sin(x))**2,  x)
+>>> trig_simplify(_)
+2Cos(2x)
+
+>>> derivative(x*Ln(x) - x, x)
+Ln(x)
+```
+
+### Algebraic Operations
+```python
+>>> from levycas.expressions import Variable
+>>> from levycas.operations import rationalize, partial_fractions as partial
+>>> x = Variable('x')
+
+# partial fractions
+>>> partial(8*x+7, [x+2, x-1], x)
+3/(x+2) + 5/(x-1)
+
+# rationalization
+>>> rationalize(3/(x+2) + 5/(x-1))
+(8x+7)/((x+2)*(x-1))
+```
+
+### Integer Operations
+```python
+>>> from levycas import is_prime, factor_integer, gcd
+
+>>> gcd(2**4 * 3**5 * 5**3, 7**4 * 11**4 * 13**5)
+1
+
+>>> factor_integer(2**4 * 3**5 * 5**3 * 7**9)
+{2: 4, 3: 5, 5: 3, 7: 9}
+
+# integer radical
+>>> def rad(n: Integer) -> Integer:
+>>>     rad, factors = 1, factor_integer(n).keys()
+>>>     for factor in factors:
+>>>         rad *= factor
+>>>     return rad
+
+>>> rad(18)
+6
+```
+

levycas-1.0.0/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "levycas"
+version = "1.0.0"
+authors = [
+    {name = "Alex Levy", email = "ajlevy246@gmail.com"},
+]
+description = "A computer algebra system written in python, with an interactive text-based user interface complete with a built-in scripting language and graphing directly in the terminal."
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICENSE.txt"]
+
+[project.optional-dependencies]
+tui = [
+    "textual",
+    "textual-plot",
+]
+dev = [
+    "textual",
+    "textual-plot",
+    "textual-dev",
+    "pytest-textual-snapshot",
+    "pytest-cov",
+    "pytest-asyncio",
+]
+
+[project.urls]
+homepage = "https://github.com/ajlevy246/LevyCAS"
+
+[project.scripts]
+levycas = "levycas.__main__:main"
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+source = ["levycas"]
+
+[tool.coverage.report]
+omit = [
+    "src/levycas/cli/*",
+]
+show_missing = true
+skip_covered = true

levycas-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

levycas-1.0.0/src/levycas/__init__.py

@@ -0,0 +1,13 @@
+"""LevyCAS is an implementation of a Computer Algebra System written
+in pure Python. It requires only the built-in regex (re) and math modules.
+
+Install with the `tui` extra and run `levycas` for the interactive Textual user interface.
+Or, check out https://alexlevy.me for an online LevyCAS demo, hosted with Gradio on Huggingface.
+
+- Alex Levy (2025)
+"""
+from .expressions import *
+from .operations import *
+from .parser import *
+from .scripting import *
+from .cli import *

levycas-1.0.0/src/levycas/__main__.py

@@ -0,0 +1,160 @@
+from argparse import ArgumentParser
+
+from levycas.parser import parse
+from levycas.operations import derivative, integrate, get_symbols, factor, simplify
+from levycas.expressions import Product
+
+def print_version():
+    try:
+        from importlib.metadata import version
+        print(f"LevyCAS: version=={version('levycas')}")
+    except ImportError:
+        print("importlib not found in standard library... LevyCAS may not support this Python version.")
+
+def launch_terminal_session():
+    raise NotImplementedError("Terminal session not yet implemented...  ")
+
+def integrate_action(args) -> None:
+    expr, wrt = parse(args.expr), parse(args.wrt)
+    print(f"{integrate(expr, wrt)}")
+
+def diff_action(args) -> None:
+    expr, wrt = parse(args.expr), parse(args.wrt)
+    print(f"{derivative(expr, wrt)}")
+
+def factor_action(args) -> None:
+    poly, var = parse(args.poly), parse(args.var)
+    factors = factor(poly, var)
+    print(simplify(Product(*factors)))
+
+def graph_action(args) -> None:
+    try:
+        import textual, textual_plot
+    except ImportError as e:
+        raise ImportError(
+            f"The LevyCAS TUI requires the '{e.name}' package. "
+            f"Please see installation instructions in the README."
+        )
+
+    assert len(args.exprs) <= 4, f"Support for more than four graphs at once is not yet available."
+    from levycas.cli.__main__ import LevyCasApp
+    app = LevyCasApp(graphing=True, exprs=args.exprs)
+    app.run()
+
+def launch_tui_action() -> None:
+    try:
+        import textual, textual_plot
+    except ImportError as e:
+        raise ImportError(
+            f"The LevyCAS TUI requires the '{e.name}' package. "
+            f"Please see installation instructions in the README."
+        )
+
+    from levycas.cli.__main__ import main as launch_tui
+    launch_tui()
+
+def build_parser() -> ArgumentParser:
+    # Help opens with `levycas -h or --help`
+    parser = ArgumentParser(
+        prog="levycas",
+        description=(
+            "A set of symbolic computation tools, with a powerful text-based UI built with Textual. "
+            "Do calculus, simplification, graphing, scripting, and more. "
+        ),
+        epilog=(
+            "See github.com/ajlevy246/LevyCAS/ for examples and source. "
+            "Run with no arguments to launch the TUI."
+        )
+    )
+    parser.add_argument("-v", "--version", help="print the levycas version and exit.", action='store_true')
+    parser.add_argument("-i", "--interactive", help="launch an interactive python session with common commands already run.", action='store_true')
+
+    subparsers = parser.add_subparsers(
+        dest="command",
+        description="The specific command to run. Run with no command to launch the TUI.")
+    
+    # Differentiate with `levycas diff ...`
+    diff_parser = subparsers.add_parser(
+        "diff",
+        help="compute the derivative of an expression.",
+    )
+    diff_parser.add_argument(
+        "expr", metavar="EXPR",
+        help="the expression to compute the derivative of, e.g. 'x^2ln(x)'",
+    )
+    diff_parser.add_argument(
+        "wrt", metavar="VAR",
+        nargs="?", default="x",
+        help="the variable of differentiation; 'x' by default.",
+    )
+
+    # Integrate with `levycas integrate ...`
+    int_parser = subparsers.add_parser(
+        "integrate",
+        help="compute the integral of an expression.",
+    )
+    int_parser.add_argument(
+        "expr", metavar="EXPR",
+        help="the expression to compute the integral of, e.g. 'xsin(x^2)",
+    )
+    int_parser.add_argument(
+        "wrt", metavar="VAR",
+        nargs="?", default="x",
+        help="the variable of integration; 'x' by default.",
+    )
+
+    # Factor with `levycas factor ...`
+    fact_parser = subparsers.add_parser(
+        "factor",
+        help="factor a univariate polynomial with rational coefficients.",
+    )
+    fact_parser.add_argument(
+        "poly", metavar="POLY",
+        help="the polynomial to factor, e.g. 'x^2 + 3x + 2'",
+    )
+    fact_parser.add_argument(
+        "var", metavar="VAR",
+        nargs="?", default="x",
+        help="the polynomial variable; 'x' by default.",
+    )
+
+    # Graph with `levycas graph ...`
+    graph_parser = subparsers.add_parser(
+        "graph",
+        help="graph up to four expressions.",
+    )
+    graph_parser.add_argument(
+        "exprs", metavar="EXPRS",
+        nargs="*",
+        help="enter up to four expressions to plot, e.g. 'sin(x)'",
+    )
+    return parser
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+    
+    # -v or -i launch actions and exit
+    if args.version:
+        print_version()
+        return
+
+    if args.interactive:
+        launch_terminal_session()
+        return
+
+    # otherwise, expect a command + optional arguments
+    command = args.command
+    if command is None:
+        launch_tui_action()
+    elif command == "integrate":
+        integrate_action(args)
+    elif command == "diff":
+        diff_action(args)
+    elif command == "factor":
+        factor_action(args)
+    elif command == "graph": 
+        graph_action(args)
+
+if __name__ == "__main__":
+    main()