Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Wolfram Language Notation

Topic: parser.wolfram

Parse and generate Mathematica/Wolfram Language syntax for compatibility with Wolfram products. Supports bidirectional conversion between MathHook expressions and Wolfram notation.

Wolfram Language Notation

Parse and generate Mathematica/Wolfram Language syntax for compatibility with Wolfram products.

Understanding Wolfram Notation

What is Wolfram Language?

Wolfram Language (used in Mathematica, Wolfram Alpha, Wolfram Cloud) is a symbolic computation language with:

  • Capital letter functions: Sin, Cos, Exp (not sin, cos, exp)
  • Bracket notation: Function calls use [] (e.g., Sin[x], not Sin(x))
  • Symbolic core: Everything is an expression tree (similar to MathHook)
  • Pattern matching: Powerful transformation rules (MathHook: simplification)

Why Wolfram Compatibility?

  • Academic Migration: Many researchers use Mathematica
  • Cross-Platform: Export MathHook results to Wolfram Alpha
  • Data Exchange: Import/export equations between systems
  • Validation: Compare MathHook results with Mathematica

How It Works (Architecture)

Parser:

  • Recognizes Wolfram function tokens (Sin, Cos, D, Integrate)
  • Bracket parsing: f[x, y, z] → Function call
  • PascalCase → snake_case conversion for custom functions

Formatter:

  • Lowercase → Capitalized function names (sin → Sin)
  • Parentheses → Brackets ((...) → [...])
  • Operator precedence matching Wolfram

Wolfram ↔ MathHook Translation Table

OperationWolframMathHookNotes
Additiona + ba + bSame
Multiplicationa * b or a ba * bSame
Divisiona / ba / bSame
Powera^ba^bSame
Function callf[x]f(x)Brackets vs parens
DerivativeD[f, x]f.derivative(&x, 1)Functional vs method
IntegralIntegrate[f, x]f.integrate(&x)Functional vs method
SqrtSqrt[x]sqrt(x)Capital vs lowercase
SinSin[x]sin(x)Capital vs lowercase
CosCos[x]cos(x)Capital vs lowercase
ExpExp[x]exp(x)Capital vs lowercase
LogLog[x]log(x)Capital vs lowercase

Examples

Basic Wolfram Parsing

Parse common Wolfram Language expressions

Rust 
#![allow(unused)]
fn main() {
use mathhook::parser::wolfram::parse_wolfram;

// Functions (capital letters, brackets)
let expr = parse_wolfram("Sin[x]")?;
let expr = parse_wolfram("Exp[x]")?;
let expr = parse_wolfram("Log[x]")?;

// Powers use ^ (not brackets)
let expr = parse_wolfram("x^2")?;

}
Python 
from mathhook.parser import parse_wolfram

# Functions (capital letters, brackets)
expr = parse_wolfram("Sin[x]")
expr = parse_wolfram("Exp[x]")
expr = parse_wolfram("Log[x]")

# Powers use ^ (not brackets)
expr = parse_wolfram("x^2")
JavaScript 
const { parseWolfram } = require('mathhook');

// Functions (capital letters, brackets)
const expr = parseWolfram("Sin[x]");
const expr = parseWolfram("Exp[x]");
const expr = parseWolfram("Log[x]");

// Powers use ^ (not brackets)
const expr = parseWolfram("x^2");

Calculus Operations

Wolfram calculus notation

Rust 
#![allow(unused)]
fn main() {
use mathhook::parser::wolfram::parse_wolfram;

// Derivative: D[expr, var]
let expr = parse_wolfram("D[x^2, x]")?;  // 2x

// Integral: Integrate[expr, var]
let expr = parse_wolfram("Integrate[x^2, x]")?;  // x^3/3

// Definite integral: Integrate[expr, {var, a, b}]
let expr = parse_wolfram("Integrate[x^2, {x, 0, 1}]")?;

// Limit: Limit[expr, var -> value]
let expr = parse_wolfram("Limit[Sin[x]/x, x -> 0]")?;

}
Python 
from mathhook.parser import parse_wolfram

# Derivative: D[expr, var]
expr = parse_wolfram("D[x^2, x]")  # 2x

# Integral: Integrate[expr, var]
expr = parse_wolfram("Integrate[x^2, x]")  # x^3/3

# Definite integral: Integrate[expr, {var, a, b}]
expr = parse_wolfram("Integrate[x^2, {x, 0, 1}]")

# Limit: Limit[expr, var -> value]
expr = parse_wolfram("Limit[Sin[x]/x, x -> 0]")
JavaScript 
const { parseWolfram } = require('mathhook');

// Derivative: D[expr, var]
const expr = parseWolfram("D[x^2, x]");  // 2x

// Integral: Integrate[expr, var]
const expr = parseWolfram("Integrate[x^2, x]");  // x^3/3

// Definite integral: Integrate[expr, {var, a, b}]
const expr = parseWolfram("Integrate[x^2, {x, 0, 1}]");

// Limit: Limit[expr, var -> value]
const expr = parseWolfram("Limit[Sin[x]/x, x -> 0]");

Generating Wolfram Output

Format MathHook expressions as Wolfram Language

Rust 
#![allow(unused)]
fn main() {
use mathhook::prelude::*;
use mathhook::formatter::wolfram::WolframFormatter;

let formatter = WolframFormatter::new();
let x = symbol!(x);

// Functions
let expr = expr!(sin(x));
println!("{}", formatter.format(&expr));  // Sin[x]

// Complex expressions
let expr = expr!((x + 1) / (x - 1));
println!("{}", formatter.format(&expr));  // (x + 1)/(x - 1)

}
Python 
from mathhook import symbol, expr, WolframFormatter

formatter = WolframFormatter()
x = symbol('x')

# Functions
expr_obj = expr('sin(x)')
print(formatter.format(expr_obj))  # Sin[x]

# Complex expressions
expr_obj = expr('(x + 1) / (x - 1)')
print(formatter.format(expr_obj))  # (x + 1)/(x - 1)
JavaScript 
const { symbol, expr, WolframFormatter } = require('mathhook');

const formatter = new WolframFormatter();
const x = symbol('x');

// Functions
const exprObj = expr('sin(x)');
console.log(formatter.format(exprObj));  // Sin[x]

// Complex expressions
const exprObj = expr('(x + 1) / (x - 1)');
console.log(formatter.format(exprObj));  // (x + 1)/(x - 1)

Cross-Platform Validation

Export to Wolfram for verification

Rust 
#![allow(unused)]
fn main() {
use mathhook::prelude::*;
use mathhook::formatter::wolfram::WolframFormatter;

// Compute derivative in MathHook
let x = symbol!(x);
let f = expr!(x^3 + 2*x^2 + x);
let df = f.derivative(&x, 1);

// Export to Wolfram for verification
let formatter = WolframFormatter::new();
let wolfram_code = formatter.format(&df);

println!("Verify in Wolfram Alpha:");
println!("Simplify[{}]", wolfram_code);

}
Python 
from mathhook import symbol, expr, WolframFormatter

# Compute derivative in MathHook
x = symbol('x')
f = expr('x^3 + 2*x^2 + x')
df = f.derivative(x, 1)

# Export to Wolfram for verification
formatter = WolframFormatter()
wolfram_code = formatter.format(df)

print("Verify in Wolfram Alpha:")
print(f"Simplify[{wolfram_code}]")
JavaScript 
const { symbol, expr, WolframFormatter } = require('mathhook');

// Compute derivative in MathHook
const x = symbol('x');
const f = expr('x^3 + 2*x^2 + x');
const df = f.derivative(x, 1);

// Export to Wolfram for verification
const formatter = new WolframFormatter();
const wolframCode = formatter.format(df);

console.log("Verify in Wolfram Alpha:");
console.log(`Simplify[${wolframCode}]`);

Performance

Time Complexity: O(n) where n = expression tree size

API Reference

  • Rust: mathhook_core::parser::wolfram
  • Python: mathhook.parser.wolfram
  • JavaScript: mathhook.parser.wolfram

See Also