# Native symbolic algebra surface. Expressions use a compact postfix numeric
# stream owned by the direct runtime; no host-language symbolic engine is used.

m: .math
errors: .errors
linalg: .linalg

_symbolic_domain_unknown: 0
_symbolic_domain_natural: 1
_symbolic_domain_integer: 2
_symbolic_domain_rational: 3
_symbolic_domain_real: 4
_symbolic_domain_complex: 5

_symbolic_solution_set_kind: 20
_symbolic_solution_family_kind: 21
_symbolic_solution_branches_kind: 22
_symbolic_solution_method_polynomial: 1

_symbolic_storage_kind(value:symbolic) -> num:
    value.(value.length() - 3)

_symbolic_domain(value:symbolic) -> num:
    _symbolic_storage_kind(value) = 1?
        @: value.2
    _symbolic_storage_kind(value) = 10?
        root: _symbolic_dag_root(value)
        _symbolic_dag_node_operation(value, root) = 1?
            entry: _symbolic_dag_catalog_entry(value, _symbolic_dag_node_left(value, root))
            @: entry.1
    _symbolic_domain_unknown

_symbolic_function_signature_index(value:symbolic) -> num:
    entry: _symbolic_raw_catalog(value)
    name_length: entry.3
    latex_length_index: 4 + name_length
    latex_length_index + 1 + entry.(latex_length_index)

_symbolic_function_arity(value:symbolic) -> num:
    entry: _symbolic_raw_catalog(value)
    entry.(_symbolic_function_signature_index(value))

_symbolic_function_domain_at(value:symbolic, index:num) -> num:
    result: _symbolic_domain_unknown
    arity: _symbolic_function_arity(value)
    index >= 0 /\ index < arity /\ index % 1 = 0?
        entry: _symbolic_raw_catalog(value)
        .result: entry.(_symbolic_function_signature_index(value) + 1 + index * 2)
    result

_symbolic_function_domain_dimension_at(value:symbolic, index:num) -> num:
    result: 0
    arity: _symbolic_function_arity(value)
    index >= 0 /\ index < arity /\ index % 1 = 0?
        entry: _symbolic_raw_catalog(value)
        .result: entry.(_symbolic_function_signature_index(value) + 2 + index * 2)
    result

_symbolic_function_domain(value:symbolic) -> num:
    result: _symbolic_domain_unknown
    _symbolic_function_arity(value) = 1?
        .result: _symbolic_function_domain_at(value, 0)
    result

_symbolic_function_codomain(value:symbolic) -> num:
    arity: _symbolic_function_arity(value)
    result: _symbolic_domain_unknown
    arity > 0?
        entry: _symbolic_raw_catalog(value)
        .result: entry.(_symbolic_function_signature_index(value) + 1 + arity * 2)
    result

_symbolic_function_codomain_dimension(value:symbolic) -> num:
    arity: _symbolic_function_arity(value)
    result: 0
    arity > 0?
        entry: _symbolic_raw_catalog(value)
        .result: entry.(_symbolic_function_signature_index(value) + 2 + arity * 2)
    result

_symbolic_domain_dimension(value:symbolic) -> num:
    result: 0
    _symbolic_function_arity(value) = 0?
        entry: _symbolic_raw_catalog(value)
        .result: entry.(_symbolic_function_signature_index(value) + 2)
    result

_symbolic_is_discrete_domain(domain:num) -> bit:
    domain = _symbolic_domain_natural \/ domain = _symbolic_domain_integer

_symbolic_is_continuous_domain(domain:num) -> bit:
    domain = _symbolic_domain_real \/ domain = _symbolic_domain_complex

_symbolic_dependent_accepts_domain(dependent:symbolic, domain:num) -> bit:
    arity: _symbolic_function_arity(_symbolic_clone(dependent))
    arity = 0?
        @: _symbolic_domain(dependent) = domain
    arity = 1 /\ _symbolic_function_domain(dependent) = domain

symbol_name(value:symbol) -> str:
    entry: _symbolic_raw_catalog(value)
    entry.length() < 5?
        errors.TypeError("symbolic.symbol_name expects a symbol")!
    name_length: entry.3
    result: ""
    name_length > 0?
        ..name_length - 1 >>
            .result: result & str(chr(entry.(4 + $)))
    result

symbol_is_constant(value:symbol) -> bit:
    _symbolic_raw_catalog(value).2 = 3

_symbolic_symbol_latex(value:symbolic) -> str:
    entry: _symbolic_raw_catalog(value)
    entry.length() < 6?
        errors.TypeError("symbolic.symbol_latex expects a symbol")!
    name_length: entry.3
    latex_length_index: 4 + name_length
    latex_length: entry.(latex_length_index)
    result: ""
    latex_length > 0?
        ..latex_length - 1 >>
            .result: result & str(chr(entry.(latex_length_index + 1 + $)))
    result

symbol_latex(value:symbol) -> str:
    _symbolic_symbol_latex(value)

_symbolic_katex_precedence(operation:num) -> num:
    operation = 27? @: 0
    (operation = 13 \/ (operation >= 20 /\ operation <= 23))? @: 1
    (operation = 3 \/ operation = 4)? @: 2
    (operation = 5 \/ operation = 6)? @: 3
    operation = 7? @: 4
    5

_symbolic_katex_parenthesize(value:str, precedence:num, parent_precedence:num) -> str:
    precedence < parent_precedence?
        @: "\\left(" & value & "\\right)"
    value

_symbolic_katex_at(value:symbolic, parent_precedence:num) -> str:
    _symbolic_storage_kind(_symbolic_clone(value)) != 10?
        kind: _symbolic_root_kind(_symbolic_clone(value))
        kind = 1? @: _symbolic_symbol_latex(value)
        kind = 2? @: str(_symbolic_number_value(value))
        @: _symbolic_katex_at(_symbolic_as_dag(value), parent_precedence)

    operation: _symbolic_dag_operation(_symbolic_clone(value))
    operation = 1? @: _symbolic_symbol_latex(value)
    operation = 2? @: str(_symbolic_number_value(value))
    precedence: _symbolic_katex_precedence(operation)
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_clone(left)
    ((operation >= 3 /\ operation <= 7) \/
     (operation >= 13 /\ operation <= 24) \/ operation = 27)?
        .right: _symbolic_right(value)
    rendered: ""
    operation??
        3 => .rendered: _symbolic_katex_at(left, precedence) & " + " & _symbolic_katex_at(right, precedence)
        4 => .rendered: _symbolic_katex_at(left, precedence) & " - " & _symbolic_katex_at(right, precedence + 1)
        5 => .rendered: _symbolic_katex_at(left, precedence) & " " & _symbolic_katex_at(right, precedence)
        6 => .rendered: "\\frac{" & _symbolic_katex_at(left, 0) & "}{" & _symbolic_katex_at(right, 0) & "}"
        7 => .rendered: _symbolic_katex_at(left, precedence) & "^{" & _symbolic_katex_at(right, 0) & "}"
        8 => .rendered: "\\sin\\left(" & _symbolic_katex_at(left, 0) & "\\right)"
        9 => .rendered: "\\cos\\left(" & _symbolic_katex_at(left, 0) & "\\right)"
        10 => .rendered: "\\log\\left(" & _symbolic_katex_at(left, 0) & "\\right)"
        11 => .rendered: "\\sqrt{" & _symbolic_katex_at(left, 0) & "}"
        12 => .rendered: "\\exp\\left(" & _symbolic_katex_at(left, 0) & "\\right)"
        13 => .rendered: _symbolic_katex_at(left, precedence) & " = " & _symbolic_katex_at(right, precedence)
        18 => .rendered: _symbolic_katex_at(left, precedence) & "\\left(" & _symbolic_katex_at(right, 0) & "\\right)"
        20 => .rendered: _symbolic_katex_at(left, precedence) & " < " & _symbolic_katex_at(right, precedence)
        21 => .rendered: _symbolic_katex_at(left, precedence) & " \\le " & _symbolic_katex_at(right, precedence)
        22 => .rendered: _symbolic_katex_at(left, precedence) & " > " & _symbolic_katex_at(right, precedence)
        23 => .rendered: _symbolic_katex_at(left, precedence) & " \\ge " & _symbolic_katex_at(right, precedence)
        27 => .rendered: _symbolic_katex_at(left, precedence) & " \\Rightarrow " & _symbolic_katex_at(right, precedence)
        errors.RuntimeError("native symbolic KaTeX rendering is not implemented for this expression yet")!
    _symbolic_katex_parenthesize(rendered, precedence, parent_precedence)

katex(value:expression) -> str:
    _symbolic_katex_at(value, 0)

same(left:expression, right:expression) -> bit:
    left_kind: _symbolic_storage_kind(_symbolic_clone(left))
    right_kind: _symbolic_storage_kind(_symbolic_clone(right))
    left_kind = 1 /\ right_kind = 1?
        @: _symbolic_catalog_identity_same(_symbolic_raw_catalog(left), _symbolic_raw_catalog(right))
    left_kind = 3 /\ right_kind = 3?
        _symbolic_root_operation(left) != _symbolic_root_operation(right)?
            @: false
        left_equal: same(_symbolic_left(left), _symbolic_left(right))
        ~left_equal?
            @: false
        @: same(_symbolic_right(left), _symbolic_right(right))
    left_kind = 7 /\ right_kind = 7?
        _symbolic_root_operation(left) != _symbolic_root_operation(right)?
            @: false
        @: same(_symbolic_argument(left), _symbolic_argument(right))
    (left_kind = 4 \/ left_kind = 6) /\ (right_kind = 4 \/ right_kind = 6)?
        residual: _symbolic_polynomial_subtract(left, right)
        @: _symbolic_polynomial_term_count(residual) = 0
    _symbolic_storage_kind(left) = 10 \/ _symbolic_storage_kind(right) = 10?
        @: _symbolic_dag_same(_symbolic_as_dag(left), _symbolic_as_dag(right))
    left.length() != right.length()?
        @: false
    equal: true
    ..left.length() - 1 >>
        left.($) != right.($)?
            .equal: false
    equal

_symbolic_root_kind(value:symbolic) -> num:
    _symbolic_storage_kind(value) = 10?
        operation: _symbolic_dag_node_operation(value, _symbolic_dag_root(value))
        operation = 1? @: 1
        operation = 2? @: 2
        operation >= 3 /\ operation <= 7? @: 3
        (operation >= 8 /\ operation <= 12) \/ operation = 25 \/ operation = 26? @: 7
    _symbolic_storage_kind(value)

_symbolic_root_operation(value:symbolic) -> num:
    _symbolic_storage_kind(value) = 10?
        operation: _symbolic_dag_node_operation(value, _symbolic_dag_root(value))
        operation >= 3 /\ operation <= 7? @: operation - 2
        operation >= 8 /\ operation <= 12? @: operation - 7
        operation = 25? @: 6
        operation = 26? @: 7
        @: 0
    value.(value.length() - 2)

_symbolic_number_value(value:symbolic) -> num:
    _symbolic_storage_kind(value) = 10?
        @: _symbolic_dag_node_value(value, _symbolic_dag_root(value))
    value.(1)

_symbolic_left(value:symbolic) -> symbolic:
    _symbolic_storage_kind(value) = 10?
        root: _symbolic_dag_root(value)
        @: _symbolic_dag_with_root(value, _symbolic_dag_node_left(value, root))
    right_end: value.length() - 4
    right_size: value.(right_end)
    left_end: right_end - right_size
    left_size: value.(left_end)
    start: left_end - left_size + 1
    [start..left_end >> value.($)]

_symbolic_right(value:symbolic) -> symbolic:
    _symbolic_storage_kind(value) = 10?
        root: _symbolic_dag_root(value)
        @: _symbolic_dag_with_root(value, _symbolic_dag_node_right(value, root))
    right_end: value.length() - 4
    right_size: value.(right_end)
    start: right_end - right_size + 1
    [start..right_end >> value.($)]

_symbolic_argument(value:symbolic) -> symbolic:
    _symbolic_storage_kind(value) = 10?
        root: _symbolic_dag_root(value)
        @: _symbolic_dag_with_root(value, _symbolic_dag_node_left(value, root))
    argument_end: value.length() - 4
    argument_size: value.(argument_end)
    start: argument_end - argument_size + 1
    [start..argument_end >> value.($)]

_symbolic_clone(value:symbolic) -> symbolic:
    [..value.length() - 1 >> value.($)]

# Reconstruct owned numeric cells through the established ordinary nominal
# return issuer. A lowercase nominal is not a type-prefixed bind keyword.
_symbolic_owned_cells(cells:[num]) -> symbolic:
    [..cells.length() - 1 >> cells.($)]

_symbolic_suffix_domain_variable(name:chr, domain:num) -> symbol:
    code: int(name)
    [num] result: [1, 9, domain, 1, 1, code, 1, code, 0, domain, 1, 1, 0, 14]
    result

_symbolic_infinity() -> constant:
    [num] result: [1, 16, 4, 3, 3, 105, 110, 102, 6, 92, 105, 110, 102, 116, 121, 0, 4, 1, 1, 0, 21]
    result

_symbolic_suffix_variable(value:symbolic, name:chr) -> symbol:
    real: _symbolic_suffix_domain_variable(name, _symbolic_domain_real)
    depends_on(_symbolic_clone(value), _symbolic_clone(real))?
        @: real
    natural: _symbolic_suffix_domain_variable(name, _symbolic_domain_natural)
    depends_on(_symbolic_clone(value), _symbolic_clone(natural))?
        @: natural
    integer: _symbolic_suffix_domain_variable(name, _symbolic_domain_integer)
    depends_on(_symbolic_clone(value), _symbolic_clone(integer))?
        @: integer
    rational: _symbolic_suffix_domain_variable(name, _symbolic_domain_rational)
    depends_on(_symbolic_clone(value), _symbolic_clone(rational))?
        @: rational
    complex: _symbolic_suffix_domain_variable(name, _symbolic_domain_complex)
    depends_on(_symbolic_clone(value), _symbolic_clone(complex))?
        @: complex
    real

_symbolic_raw_number(value:num) -> constant:
    [num] result: [2, value, 3]
    result

constant(value:num) -> constant:
    _symbolic_raw_number(value)

_symbolic_function(value:symbolic, operation:num) -> expression:
    _symbolic_dag_unary(value, operation + 7)

sin(value:expression) -> expression:
    _symbolic_function(value, 1)

cos(value:expression) -> expression:
    _symbolic_function(value, 2)

log(value:expression) -> expression:
    _symbolic_function(value, 3)

ln(value:expression) -> expression:
    log(value)

sqrt(value:expression) -> expression:
    _symbolic_function(value, 4)

exp(value:expression) -> expression:
    _symbolic_function(value, 5)

real_part(value:expression) -> expression:
    _symbolic_dag_unary(value, 25)

magnitude(value:expression) -> expression:
    _symbolic_dag_unary(value, 26)

_symbolic_rebuild_inspection(value:symbolic, operation:num, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    source: _symbolic_inspection_unary_source(value, operation, ordinal)
    _symbolic_root_kind(value) = 2?
        numeric: _symbolic_number_value(value)
        operation = 1 /\ (numeric = 0 \/ numeric = 3.141592653589793 \/ numeric = -3.141592653589793)?
            @: _symbolic_inspection_rule(source, _symbolic_raw_number(0), "sine_exact_numeric", "applied", "known_elementary_literal", value, ordinal)
        operation = 2 /\ numeric = 0?
            @: _symbolic_inspection_rule(source, _symbolic_raw_number(1), "cosine_zero", "applied", "known_elementary_literal", value, ordinal)
        operation = 3 /\ numeric = 1?
            @: _symbolic_inspection_rule(source, _symbolic_raw_number(0), "log_unit", "applied", "known_elementary_literal", value, ordinal)
        operation = 4 /\ (numeric = 0 \/ numeric = 1)?
            @: _symbolic_inspection_rule(source, _symbolic_raw_number(numeric), "sqrt_zero_or_unit", "applied", "known_elementary_literal", value, ordinal)
        operation = 5 /\ numeric = 0?
            @: _symbolic_inspection_rule(source, _symbolic_raw_number(1), "exp_zero", "applied", "known_elementary_literal", value, ordinal)
    operation <= 5?
        @: _symbolic_inspection_rule(source, _symbolic_function(value, operation), "elementary_function_rebuild", "represented", "function_source_domain_retained", source, ordinal)
    operation = 6?
        @: _symbolic_inspection_rule(source, real_part(value), "real_part_rebuild", "represented", "function_source_domain_retained", source, ordinal)
    _symbolic_inspection_rule(source, magnitude(value), "magnitude_rebuild", "represented", "function_source_domain_retained", source, ordinal)

_symbolic_rebuild_function(value:symbolic, operation:num) -> expression:
    _symbolic_rebuild_inspection(value, operation, -1).expression

+(left:expression, right:expression) -> expression:
    _symbolic_storage_kind(left) = 4 \/ _symbolic_storage_kind(right) = 4?
        @: _symbolic_polynomial_add(expand(left), expand(right))
    _symbolic_dag_binary(left, right, 3)

+(left:num, right:expression) -> expression:
    _symbolic_dag_binary(_symbolic_raw_number(left), right, 3)

+(left:expression, right:num) -> expression:
    _symbolic_dag_binary(left, _symbolic_raw_number(right), 3)

-(left:expression, right:expression) -> expression:
    _symbolic_storage_kind(left) = 4 \/ _symbolic_storage_kind(right) = 4?
        @: _symbolic_polynomial_subtract(expand(left), expand(right))
    _symbolic_dag_binary(left, right, 4)

-(left:num, right:expression) -> expression:
    _symbolic_dag_binary(_symbolic_raw_number(left), right, 4)

-(left:expression, right:num) -> expression:
    _symbolic_dag_binary(left, _symbolic_raw_number(right), 4)

-(value:expression) -> expression:
    _symbolic_dag_binary(_symbolic_raw_number(0), value, 4)

*(left:expression, right:expression) -> expression:
    _symbolic_storage_kind(left) = 4 \/ _symbolic_storage_kind(right) = 4?
        @: _symbolic_polynomial_multiply(expand(left), expand(right))
    _symbolic_dag_binary(left, right, 5)

*(left:num, right:expression) -> expression:
    _symbolic_dag_binary(_symbolic_raw_number(left), right, 5)

*(left:expression, right:num) -> expression:
    _symbolic_dag_binary(left, _symbolic_raw_number(right), 5)

/(left:expression, right:expression) -> expression:
    _symbolic_dag_binary(left, right, 6)

/(left:num, right:expression) -> expression:
    _symbolic_dag_binary(_symbolic_raw_number(left), right, 6)

/(left:expression, right:num) -> expression:
    _symbolic_dag_binary(left, _symbolic_raw_number(right), 6)

^(left:expression, right:expression) -> expression:
    _symbolic_dag_binary(left, right, 7)

^(left:num, right:expression) -> expression:
    _symbolic_dag_binary(_symbolic_raw_number(left), right, 7)

^(left:expression, right:num) -> expression:
    _symbolic_storage_kind(left) = 4 /\ right >= 0 /\ right % 1 = 0?
        @: _symbolic_polynomial_power(left, right)
    _symbolic_dag_binary(left, _symbolic_raw_number(right), 7)

equation(left:expression, right:expression) -> relation:
    _symbolic_dag_binary(left, right, 13)

equation(left:expression, right:num) -> relation:
    equation(left, _symbolic_raw_number(right))

equation(left:num, right:expression) -> relation:
    equation(_symbolic_raw_number(left), right)

less_than(left:expression, right:expression) -> relation:
    _symbolic_dag_binary(left, right, 20)

less_equal(left:expression, right:expression) -> relation:
    _symbolic_dag_binary(left, right, 21)

greater_than(left:expression, right:expression) -> relation:
    _symbolic_dag_binary(left, right, 22)

greater_equal(left:expression, right:expression) -> relation:
    _symbolic_dag_binary(left, right, 23)

not_equal(left:expression, right:expression) -> relation:
    greater_than(magnitude(left - right), _symbolic_raw_number(0))

not_equal(left:expression, right:num) -> relation:
    not_equal(left, _symbolic_raw_number(right))

not_equal(left:num, right:expression) -> relation:
    not_equal(_symbolic_raw_number(left), right)

=(left:expression, right:expression) -> relation:
    equation(left, right)

=(left:expression, right:num) -> relation:
    equation(left, right)

=(left:num, right:expression) -> relation:
    equation(left, right)

<(left:expression, right:expression) -> relation:
    less_than(left, right)

<(left:expression, right:num) -> relation:
    less_than(left, _symbolic_raw_number(right))

<(left:num, right:expression) -> relation:
    less_than(_symbolic_raw_number(left), right)

<=(left:expression, right:expression) -> relation:
    less_equal(left, right)

<=(left:expression, right:num) -> relation:
    less_equal(left, _symbolic_raw_number(right))

<=(left:num, right:expression) -> relation:
    less_equal(_symbolic_raw_number(left), right)

>(left:expression, right:expression) -> relation:
    greater_than(left, right)

>(left:expression, right:num) -> relation:
    greater_than(left, _symbolic_raw_number(right))

>(left:num, right:expression) -> relation:
    greater_than(_symbolic_raw_number(left), right)

>=(left:expression, right:expression) -> relation:
    greater_equal(left, right)

>=(left:expression, right:num) -> relation:
    greater_equal(left, _symbolic_raw_number(right))

>=(left:num, right:expression) -> relation:
    greater_equal(_symbolic_raw_number(left), right)

implies(left:proposition, right:proposition) -> proposition:
    _symbolic_dag_binary(left, right, 27)

=>(left:proposition, right:proposition) -> proposition:
    implies(left, right)

premise(value:proposition) -> proposition:
    _symbolic_left(value)

conclusion(value:proposition) -> proposition:
    _symbolic_right(value)

derivative(value:expression, variable:symbol) -> expression:
    _symbolic_dag_binary(value, variable, 14)

derivative(variable_name:chr, value:expression) -> expression:
    derivative(value, _symbolic_suffix_variable(value, variable_name))

prime(value:expression, order:num = 1) -> expression:
    order < 1 \/ ~(order % 1 = 0)?
        errors.ValueError("symbolic.prime order must be a positive integer")!
    _symbolic_dag_binary(value, _symbolic_raw_number(order), 24)

partial(value:expression, variable:symbol, order:num = 1) -> expression:
    order < 1 \/ ~(order % 1 = 0)?
        errors.ValueError("symbolic.partial order must be a positive integer")!
    result: _symbolic_clone(value)
    remaining: order
    remaining > 0?>
        .result: derivative(result, _symbolic_clone(variable))
        .remaining -: 1
    result

partial(variable_name:chr, value:expression, order:num = 1) -> expression:
    partial(value, _symbolic_suffix_variable(value, variable_name), order)

at(value:expression, point:num) -> expression:
    _symbolic_dag_binary(value, _symbolic_raw_number(point), 15)

at(value:expression, argument:expression) -> expression:
    _symbolic_dag_binary(value, argument, 18)

at(value:expression, variable:symbol, point:num) -> expression:
    location: _symbolic_dag_binary(value, variable, 16)
    _symbolic_dag_binary(location, _symbolic_raw_number(point), 17)

at(variable_name:chr, value:expression, point:num) -> expression:
    at(value, _symbolic_suffix_variable(value, variable_name), point)

at(value:expression, arguments:[expression:n]) -> expression:
    result: _symbolic_clone(value)
    index: 0
    index < arguments.length()?>
        .result: _symbolic_dag_binary(result, arguments.(index), 18)
        .index+: 1
    result

where(value_constraint:relation, domain_constraint:relation) -> relation:
    _symbolic_dag_binary(value_constraint, domain_constraint, 19)

boundary_value(boundary:relation) -> relation:
    _symbolic_left(boundary)

boundary_domain(boundary:relation) -> relation:
    _symbolic_right(boundary)

_symbolic_z_transform_domains_match(index:symbolic, frequency:symbolic) -> bit:
    _symbolic_domain(index) = _symbolic_domain_natural /\ _symbolic_domain(frequency) = _symbolic_domain_complex

_symbolic_require_z_transform_domains(index:symbolic, frequency:symbolic) -> bit:
    ~_symbolic_z_transform_domains_match(index, frequency)?
        errors.TypeError("symbolic Z-transform requires index domain N and frequency domain C")!
    true

_symbolic_transform_scale(coefficient:symbolic, transformed:symbolic) -> symbolic:
    is_quotient: _symbolic_root_kind(_symbolic_clone(transformed)) = 3 /\ _symbolic_root_operation(_symbolic_clone(transformed)) = 4
    is_quotient?
        numerator: _symbolic_left(_symbolic_clone(transformed))
        denominator: _symbolic_right(transformed)
        @: simplify(coefficient * numerator) / denominator
    coefficient * transformed

_symbolic_rational_numerator(value:symbolic) -> symbolic:
    _symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 4?
        @: _symbolic_left(value)
    _symbolic_clone(value)

_symbolic_rational_denominator(value:symbolic) -> symbolic:
    _symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 4?
        @: _symbolic_right(value)
    constant(1)

_symbolic_contains_function(value:symbolic) -> bit:
    node: 0
    operation: 0
    node_count: 0
    stack_size: 0
    [num] stack: []
    _symbolic_storage_kind(_symbolic_clone(value)) = 10?
        .node_count: _symbolic_dag_node_count(_symbolic_clone(value))
        .stack: [0:node_count]
        stack.0: _symbolic_dag_root(_symbolic_clone(value))
        .stack_size: 1
        stack_size > 0?>
            .stack_size-: 1
            .node: stack.(stack_size)
            .operation: _symbolic_dag_node_operation(_symbolic_clone(value), node)
            (operation >= 8 /\ operation <= 12) \/ operation = 25 \/ operation = 26?
                @: true
            operation >= 3 /\ operation <= 7?
                stack.(stack_size): _symbolic_dag_node_left(_symbolic_clone(value), node)
                .stack_size+: 1
                stack.(stack_size): _symbolic_dag_node_right(_symbolic_clone(value), node)
                .stack_size+: 1
        @: false
    kind: _symbolic_root_kind(_symbolic_clone(value))
    kind = 7?
        @: true
    kind != 3?
        @: false
    (_symbolic_contains_function(_symbolic_left(_symbolic_clone(value))) \/
     _symbolic_contains_function(_symbolic_right(value)))

equivalent(left:expression, right:expression) -> bit:
    same(_symbolic_clone(left), _symbolic_clone(right))?
        @: true
    source_contains_function: (
        _symbolic_contains_function(_symbolic_clone(left)) \/
        _symbolic_contains_function(_symbolic_clone(right))
    )
    source_contains_function?
        @: false
    left_numerator: _symbolic_rational_numerator(_symbolic_clone(left))
    left_denominator: _symbolic_rational_denominator(left)
    right_numerator: _symbolic_rational_numerator(_symbolic_clone(right))
    right_denominator: _symbolic_rational_denominator(right)
    residual: expand(left_numerator * right_denominator - right_numerator * left_denominator)
    _symbolic_root_kind(_symbolic_clone(residual)) = 4?
        @: _symbolic_polynomial_term_count(residual) = 0
    _symbolic_is_raw_number(residual, 0)

_symbolic_numeric_scale_relative(value:symbolic, target:symbolic):
    same(_symbolic_clone(value), _symbolic_clone(target))?
        @: (matched:true, scale:1)
    ~(_symbolic_root_kind(_symbolic_clone(value)) = 3)?
        @: (matched:false, scale:0)
    operation: _symbolic_root_operation(_symbolic_clone(value))
    operation = 1 \/ operation = 2?
        additive_left_match: _symbolic_numeric_scale_relative(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(target)
        )
        additive_right_match: _symbolic_numeric_scale_relative(
            _symbolic_right(value),
            target
        )
        ~(additive_left_match.matched /\ additive_right_match.matched)?
            @: (matched:false, scale:0)
        operation = 1?
            @: (
                matched:true,
                scale:additive_left_match.scale + additive_right_match.scale
            )
        @: (
            matched:true,
            scale:additive_left_match.scale - additive_right_match.scale
        )
    operation = 3?
        multiplicative_left: _symbolic_left(_symbolic_clone(value))
        multiplicative_right: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(multiplicative_left)) = 2?
            left_nested_match: _symbolic_numeric_scale_relative(
                multiplicative_right,
                target
            )
            left_nested_match.matched?
                @: (
                    matched:true,
                    scale:_symbolic_number_value(multiplicative_left) * left_nested_match.scale
                )
        _symbolic_root_kind(_symbolic_clone(multiplicative_right)) = 2?
            right_nested_match: _symbolic_numeric_scale_relative(
                multiplicative_left,
                target
            )
            right_nested_match.matched?
                @: (
                    matched:true,
                    scale:_symbolic_number_value(multiplicative_right) * right_nested_match.scale
                )
    operation = 4?
        quotient_numerator: _symbolic_left(_symbolic_clone(value))
        quotient_denominator: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(quotient_denominator)) = 2?
            divisor: _symbolic_number_value(quotient_denominator)
            divisor != 0?
                quotient_nested_match: _symbolic_numeric_scale_relative(
                    quotient_numerator,
                    target
                )
                quotient_nested_match.matched?
                    @: (
                        matched:true,
                        scale:quotient_nested_match.scale / divisor
                    )
    (matched:false, scale:0)

_symbolic_transform_equivalent(left:symbolic, right:symbolic) -> bit:
    equivalent(_symbolic_clone(left), _symbolic_clone(right))?
        @: true
    left_scale: _symbolic_numeric_scale_relative(
        _symbolic_clone(left),
        _symbolic_clone(right)
    )
    left_scale.matched /\ left_scale.scale = 1?
        @: true
    right_scale: _symbolic_numeric_scale_relative(right, left)
    right_scale.matched /\ right_scale.scale = 1

z_transform(value:symbolic, index:symbolic, frequency:symbolic) -> symbolic:
    _symbolic_require_z_transform_domains(_symbolic_clone(index), _symbolic_clone(frequency))
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: _symbolic_root_operation(_symbolic_clone(value))
    ~depends_on(_symbolic_clone(value), _symbolic_clone(index))?
        output_frequency: _symbolic_clone(frequency)
        denominator_frequency: _symbolic_clone(frequency)
        @: value * output_frequency / (denominator_frequency - 1)
    value_kind = 3 /\ value_operation = 1?
        left: z_transform(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(index), _symbolic_clone(frequency))
        right: z_transform(_symbolic_right(value), index, frequency)
        @: left + right
    value_kind = 3 /\ value_operation = 2?
        left: z_transform(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(index), _symbolic_clone(frequency))
        right: z_transform(_symbolic_right(value), index, frequency)
        @: left - right
    value_kind = 3 /\ value_operation = 3?
        left_factor: _symbolic_left(_symbolic_clone(value))
        right_factor: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left_factor), _symbolic_clone(index))?
            @: _symbolic_transform_scale(left_factor, z_transform(right_factor, index, frequency))
        ~depends_on(_symbolic_clone(right_factor), _symbolic_clone(index))?
            @: _symbolic_transform_scale(right_factor, z_transform(left_factor, index, frequency))
        errors.RuntimeError("native symbolic Z-transform product strategy requires a constant factor")!
    base: _symbolic_left(_symbolic_clone(value))
    exponent: _symbolic_right(value)
    base_is_constant: ~depends_on(_symbolic_clone(base), _symbolic_clone(index))
    exponent_matches: same(exponent, index)
    supported: value_kind = 3 /\ value_operation = 5 /\ base_is_constant /\ exponent_matches
    supported?
        left_frequency: _symbolic_clone(frequency)
        right_frequency: _symbolic_clone(frequency)
        @: left_frequency / (right_frequency - base)
    errors.RuntimeError("native symbolic Z-transform strategy is not implemented for this expression")!

_symbolic_z_transform_source_supported(value:symbolic, index:symbolic) -> bit:
    ~depends_on(_symbolic_clone(value), _symbolic_clone(index))?
        @: true
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ (operation = 1 \/ operation = 2)?
        left_supported: _symbolic_z_transform_source_supported(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(index)
        )
        right_supported: _symbolic_z_transform_source_supported(
            _symbolic_right(value),
            index
        )
        @: left_supported /\ right_supported
    kind = 3 /\ operation = 3?
        left: _symbolic_left(_symbolic_clone(value))
        right: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left), _symbolic_clone(index))?
            @: _symbolic_z_transform_source_supported(right, index)
        ~depends_on(_symbolic_clone(right), _symbolic_clone(index))?
            @: _symbolic_z_transform_source_supported(left, index)
        @: false
    kind = 3 /\ operation = 5?
        base: _symbolic_left(_symbolic_clone(value))
        exponent: _symbolic_right(value)
        supported: ~depends_on(_symbolic_clone(base), _symbolic_clone(index)) /\ same(exponent, index)
        @: supported
    false

_symbolic_z_transform_verification_expected(
    value:symbolic,
    index:symbolic,
    frequency:symbolic
) -> symbolic:
    ~depends_on(_symbolic_clone(value), _symbolic_clone(index))?
        @: value * frequency / (_symbolic_clone(frequency) - 1)
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ operation = 1?
        left: _symbolic_z_transform_verification_expected(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(index),
            _symbolic_clone(frequency)
        )
        right: _symbolic_z_transform_verification_expected(
            _symbolic_right(value), index, frequency
        )
        @: left + right
    kind = 3 /\ operation = 2?
        left: _symbolic_z_transform_verification_expected(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(index),
            _symbolic_clone(frequency)
        )
        right: _symbolic_z_transform_verification_expected(
            _symbolic_right(value), index, frequency
        )
        @: left - right
    kind = 3 /\ operation = 3?
        left_factor: _symbolic_left(_symbolic_clone(value))
        right_factor: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left_factor), _symbolic_clone(index))?
            transformed: _symbolic_z_transform_verification_expected(
                right_factor, index, frequency
            )
            @: _symbolic_transform_scale(left_factor, transformed)
        transformed: _symbolic_z_transform_verification_expected(
            left_factor, index, frequency
        )
        @: _symbolic_transform_scale(right_factor, transformed)
    base: _symbolic_left(value)
    frequency / (_symbolic_clone(frequency) - base)

verify_z_transform(
    candidate:symbolic,
    value:symbolic,
    index:symbolic,
    frequency:symbolic
) -> bit:
    ~_symbolic_z_transform_domains_match(_symbolic_clone(index), _symbolic_clone(frequency))?
        @: false
    ~_symbolic_z_transform_source_supported(_symbolic_clone(value), _symbolic_clone(index))?
        @: false
    expected: _symbolic_z_transform_verification_expected(value, index, frequency)
    equivalent(candidate, expected)

_symbolic_z_transform_rate(value:symbolic, index:symbolic) -> symbolic:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    ~depends_on(_symbolic_clone(value), _symbolic_clone(index))?
        @: constant(1)
    kind = 3 /\ operation = 3?
        left: _symbolic_left(_symbolic_clone(value))
        right: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left), _symbolic_clone(index))?
            @: _symbolic_z_transform_rate(right, index)
        ~depends_on(_symbolic_clone(right), _symbolic_clone(index))?
            @: _symbolic_z_transform_rate(left, index)
    kind = 3 /\ operation = 5?
        base: _symbolic_left(_symbolic_clone(value))
        exponent: _symbolic_right(value)
        same(exponent, index) /\ ~depends_on(_symbolic_clone(base), _symbolic_clone(index))?
            @: base
    errors.RuntimeError("native symbolic Z-transform condition requires one geometric basis term")!

z_transform_condition(value:symbolic, index:symbolic, frequency:symbolic) -> relation:
    _symbolic_require_z_transform_domains(_symbolic_clone(index), _symbolic_clone(frequency))
    z_transform(_symbolic_clone(value), _symbolic_clone(index), _symbolic_clone(frequency))
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: _symbolic_root_operation(_symbolic_clone(value))
    value_kind = 3 /\ (value_operation = 1 \/ value_operation = 2)?
        errors.RuntimeError("a transform sum has multiple convergence conditions; use z_transform_conditions")!
    rate: _symbolic_z_transform_rate(value, index)
    magnitude(frequency) > magnitude(rate)

verify_z_transform_condition(
    candidate:relation,
    value:symbolic,
    index:symbolic,
    frequency:symbolic
) -> bit:
    ~_symbolic_z_transform_domains_match(_symbolic_clone(index), _symbolic_clone(frequency))?
        @: false
    ~_symbolic_z_transform_source_supported(_symbolic_clone(value), _symbolic_clone(index))?
        @: false
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: _symbolic_root_operation(_symbolic_clone(value))
    value_kind = 3 /\ (value_operation = 1 \/ value_operation = 2)?
        @: false
    rate: _symbolic_z_transform_rate(value, index)
    expected: magnitude(frequency) > magnitude(rate)
    same(candidate, expected)

_symbolic_transform_condition_single(condition:symbolic) -> [num]:
    [num] header: [1, condition.length()]
    [num] payload: [..condition.length() - 1 >> condition.($)]
    header & payload

_symbolic_transform_condition_merge(left:[num], right:[num]) -> [num]:
    [num] header: [left.0 + right.0]
    [num] left_payload: [1..left.length() - 1 >> left.($)]
    [num] right_payload: [1..right.length() - 1 >> right.($)]
    header & left_payload & right_payload

transform_condition_count(conditions:[num]) -> num:
    conditions.length() < 1?
        errors.ValueError("symbolic transform condition set is empty")!
    conditions.0

transform_condition(conditions:[num], index:num) -> symbolic:
    count: transform_condition_count(conditions)
    index < 0 \/ index >= count \/ ~(index % 1 = 0)?
        errors.IndexError("symbolic transform condition index is out of range")!
    cursor: 1
    position: 0
    position < index?>
        .cursor: cursor + 1 + conditions.(cursor)
        .position: position + 1
    size: conditions.(cursor)
    start: cursor + 1
    [start..start + size - 1 >> conditions.($)]

_symbolic_transform_conditions_same(left:[num], right:[num]) -> bit:
    left_count: transform_condition_count(left)
    right_count: transform_condition_count(right)
    left_count != right_count?
        @: false
    valid: true
    ..left_count - 1 >>
        .valid: valid /\ same(transform_condition(left, $), transform_condition(right, $))
    valid

z_transform_conditions(value:symbolic, index:symbolic, frequency:symbolic) -> [num]:
    _symbolic_require_z_transform_domains(_symbolic_clone(index), _symbolic_clone(frequency))
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: _symbolic_root_operation(_symbolic_clone(value))
    value_kind = 3 /\ (value_operation = 1 \/ value_operation = 2)?
        [num] left: z_transform_conditions(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(index),
            _symbolic_clone(frequency)
        )
        [num] right: z_transform_conditions(
            _symbolic_right(value),
            index,
            frequency
        )
        @: _symbolic_transform_condition_merge(left, right)
    _symbolic_transform_condition_single(z_transform_condition(value, index, frequency))

_symbolic_z_transform_verification_conditions(
    value:symbolic,
    index:symbolic,
    frequency:symbolic
) -> [num]:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ (operation = 1 \/ operation = 2)?
        [num] left: _symbolic_z_transform_verification_conditions(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(index),
            _symbolic_clone(frequency)
        )
        [num] right: _symbolic_z_transform_verification_conditions(
            _symbolic_right(value), index, frequency
        )
        @: _symbolic_transform_condition_merge(left, right)
    rate: _symbolic_z_transform_rate(value, index)
    condition: magnitude(frequency) > magnitude(rate)
    _symbolic_transform_condition_single(condition)

verify_z_transform_conditions(
    candidate:[num],
    value:symbolic,
    index:symbolic,
    frequency:symbolic
) -> bit:
    ~_symbolic_z_transform_domains_match(_symbolic_clone(index), _symbolic_clone(frequency))?
        @: false
    ~_symbolic_z_transform_source_supported(_symbolic_clone(value), _symbolic_clone(index))?
        @: false
    [num] expected: _symbolic_z_transform_verification_conditions(value, index, frequency)
    _symbolic_transform_conditions_same(candidate, expected)

_symbolic_inverse_z_numerator_coefficient(value:symbolic, frequency:symbolic) -> symbolic:
    same(_symbolic_clone(value), _symbolic_clone(frequency))?
        @: constant(1)
    ~(_symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 3)?
        errors.RuntimeError("native symbolic inverse Z-transform numerator must be coefficient*z")!
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_is_coefficient: ~depends_on(_symbolic_clone(left), _symbolic_clone(frequency)) /\ same(_symbolic_clone(right), _symbolic_clone(frequency))
    right_is_coefficient: ~depends_on(_symbolic_clone(right), _symbolic_clone(frequency)) /\ same(_symbolic_clone(left), frequency)
    left_is_coefficient?
        @: left
    right_is_coefficient?
        @: right
    errors.RuntimeError("native symbolic inverse Z-transform numerator must be coefficient*z")!

_symbolic_inverse_z_transform_unverified(value:symbolic, frequency:symbolic, index:symbolic) -> symbolic:
    _symbolic_require_z_transform_domains(_symbolic_clone(index), _symbolic_clone(frequency))
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ operation = 1?
        left: _symbolic_inverse_z_transform_unverified(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(frequency), _symbolic_clone(index))
        right: _symbolic_inverse_z_transform_unverified(_symbolic_right(value), frequency, index)
        @: left + right
    kind = 3 /\ operation = 2?
        left: _symbolic_inverse_z_transform_unverified(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(frequency), _symbolic_clone(index))
        right: _symbolic_inverse_z_transform_unverified(_symbolic_right(value), frequency, index)
        @: left - right
    kind = 3 /\ operation = 3?
        left_factor: _symbolic_left(_symbolic_clone(value))
        right_factor: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left_factor), _symbolic_clone(frequency))?
            @: _symbolic_multiply_simplified(left_factor, _symbolic_inverse_z_transform_unverified(right_factor, frequency, index))
        ~depends_on(_symbolic_clone(right_factor), _symbolic_clone(frequency))?
            @: _symbolic_multiply_simplified(right_factor, _symbolic_inverse_z_transform_unverified(left_factor, frequency, index))
        errors.RuntimeError("native symbolic inverse Z-transform product strategy requires a constant factor")!
    ~(kind = 3 /\ operation = 4)?
        errors.RuntimeError("native symbolic inverse Z-transform strategy is not implemented for this expression")!
    numerator: _symbolic_left(_symbolic_clone(value))
    denominator: _symbolic_right(value)
    coefficient: _symbolic_inverse_z_numerator_coefficient(numerator, _symbolic_clone(frequency))
    denominator_is_shift: _symbolic_root_kind(_symbolic_clone(denominator)) = 3 /\ _symbolic_root_operation(_symbolic_clone(denominator)) = 2
    denominator_left: _symbolic_left(_symbolic_clone(denominator))
    denominator_right: _symbolic_right(denominator)
    supported: denominator_is_shift /\ same(denominator_left, frequency) /\ ~depends_on(_symbolic_clone(denominator_right), _symbolic_clone(frequency))
    ~supported?
        errors.RuntimeError("native symbolic inverse Z-transform expects coefficient*z/(z-rate)")!
    rate: _symbolic_clone(denominator_right)
    same(_symbolic_clone(rate), constant(1))?
        @: coefficient
    geometric: rate^index
    same(_symbolic_clone(coefficient), constant(1))?
        @: geometric
    _symbolic_multiply_simplified(coefficient, geometric)

verify_inverse_z_transform(
    candidate:symbolic,
    value:symbolic,
    frequency:symbolic,
    index:symbolic
) -> bit:
    ~_symbolic_z_transform_domains_match(_symbolic_clone(index), _symbolic_clone(frequency))?
        @: false
    transformed: z_transform(candidate, index, frequency)
    equivalent(transformed, value)

inverse_z_transform(value:symbolic, frequency:symbolic, index:symbolic) -> symbolic:
    candidate: _symbolic_inverse_z_transform_unverified(
        _symbolic_clone(value),
        _symbolic_clone(frequency),
        _symbolic_clone(index)
    )
    verify_inverse_z_transform(
        _symbolic_clone(candidate),
        value,
        frequency,
        index
    )?
        @: candidate
    errors.RuntimeError("native symbolic inverse Z-transform candidate failed forward-transform verification")!

_symbolic_laplace_domains_match(time:symbolic, frequency:symbolic) -> bit:
    _symbolic_domain(time) = _symbolic_domain_real /\ _symbolic_domain(frequency) = _symbolic_domain_complex

_symbolic_require_laplace_domains(time:symbolic, frequency:symbolic) -> bit:
    ~_symbolic_laplace_domains_match(time, frequency)?
        errors.TypeError("symbolic Laplace transform requires time domain R and frequency domain C")!
    true

_symbolic_transform_linear_argument_matches(argument:symbolic, variable:symbolic) -> bit:
    same(_symbolic_clone(argument), _symbolic_clone(variable))?
        @: true
    ~(_symbolic_root_kind(_symbolic_clone(argument)) = 3 /\ _symbolic_root_operation(_symbolic_clone(argument)) = 3)?
        @: false
    left: _symbolic_left(_symbolic_clone(argument))
    right: _symbolic_right(argument)
    (
        (same(_symbolic_clone(left), _symbolic_clone(variable)) /\ ~depends_on(right, _symbolic_clone(variable))) \/
        (same(_symbolic_clone(right), _symbolic_clone(variable)) /\ ~depends_on(left, variable))
    )

_symbolic_transform_linear_rate(argument:symbolic, variable:symbolic) -> symbolic:
    same(_symbolic_clone(argument), _symbolic_clone(variable))?
        @: constant(1)
    left: _symbolic_left(_symbolic_clone(argument))
    right: _symbolic_right(argument)
    same(_symbolic_clone(left), _symbolic_clone(variable))?
        @: right
    left

laplace(value:symbolic, time:symbolic, frequency:symbolic) -> symbolic:
    _symbolic_require_laplace_domains(_symbolic_clone(time), _symbolic_clone(frequency))
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: _symbolic_root_operation(_symbolic_clone(value))
    is_time: same(_symbolic_clone(value), time)
    constant_frequency: _symbolic_clone(frequency)
    linear_frequency: _symbolic_clone(frequency)
    ~depends_on(_symbolic_clone(value), _symbolic_clone(time))?
        @: value / constant_frequency
    is_time?
        @: 1 / linear_frequency^2
    value_kind = 3 /\ value_operation = 1?
        left_transform: laplace(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(time), _symbolic_clone(frequency))
        right_transform: laplace(_symbolic_right(value), time, frequency)
        @: left_transform + right_transform
    value_kind = 3 /\ value_operation = 2?
        left_transform: laplace(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(time), _symbolic_clone(frequency))
        right_transform: laplace(_symbolic_right(value), time, frequency)
        @: left_transform - right_transform
    value_kind = 3 /\ value_operation = 3?
        left_factor: _symbolic_left(_symbolic_clone(value))
        right_factor: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left_factor), _symbolic_clone(time))?
            @: _symbolic_transform_scale(left_factor, laplace(right_factor, time, frequency))
        ~depends_on(_symbolic_clone(right_factor), _symbolic_clone(time))?
            @: _symbolic_transform_scale(right_factor, laplace(left_factor, time, frequency))
        errors.RuntimeError("native symbolic Laplace product strategy requires a constant factor")!
    value_kind = 3 /\ value_operation = 5?
        power_base: _symbolic_left(_symbolic_clone(value))
        power_exponent: _symbolic_right(value)
        power_supported: same(power_base, _symbolic_clone(time)) /\ _symbolic_root_kind(_symbolic_clone(power_exponent)) = 2
        power_supported?
            order: _symbolic_number_value(power_exponent)
            order < 0 \/ ~(order % 1 = 0)?
                errors.RuntimeError("native symbolic Laplace power strategy requires a nonnegative integer exponent")!
            @: _symbolic_factorial(order) / frequency^(order + 1)
    value_kind = 7 /\ (value_operation = 1 \/ value_operation = 2 \/ value_operation = 5)?
        argument: _symbolic_argument(value)
        _symbolic_transform_linear_argument_matches(_symbolic_clone(argument), _symbolic_clone(time))?
            rate: _symbolic_transform_linear_rate(argument, time)
            value_operation = 1?
                @: rate / (frequency^2 + _symbolic_clone(rate)^2)
            value_operation = 2?
                @: frequency / (frequency^2 + rate^2)
            @: 1 / (frequency - rate)
    errors.RuntimeError("native symbolic Laplace strategy is not implemented for this expression")!

_symbolic_laplace_source_supported(value:symbolic, time:symbolic) -> bit:
    ~depends_on(_symbolic_clone(value), _symbolic_clone(time))?
        @: true
    same(_symbolic_clone(value), _symbolic_clone(time))?
        @: true
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ (operation = 1 \/ operation = 2)?
        left_supported: _symbolic_laplace_source_supported(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(time)
        )
        right_supported: _symbolic_laplace_source_supported(
            _symbolic_right(value),
            time
        )
        @: left_supported /\ right_supported
    kind = 3 /\ operation = 3?
        left: _symbolic_left(_symbolic_clone(value))
        right: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left), _symbolic_clone(time))?
            @: _symbolic_laplace_source_supported(right, time)
        ~depends_on(_symbolic_clone(right), _symbolic_clone(time))?
            @: _symbolic_laplace_source_supported(left, time)
        @: false
    kind = 3 /\ operation = 5?
        base: _symbolic_left(_symbolic_clone(value))
        exponent: _symbolic_right(value)
        power_supported: (
            same(base, _symbolic_clone(time)) /\
            _symbolic_root_kind(_symbolic_clone(exponent)) = 2 /\
            _symbolic_number_value(_symbolic_clone(exponent)) >= 0 /\
            _symbolic_number_value(exponent) % 1 = 0
        )
        power_supported?
            @: true
    kind = 7 /\ (operation = 1 \/ operation = 2 \/ operation = 5)?
        @: _symbolic_transform_linear_argument_matches(_symbolic_argument(value), time)
    false

_symbolic_laplace_verification_expected(
    value:symbolic,
    time:symbolic,
    frequency:symbolic
) -> symbolic:
    ~depends_on(_symbolic_clone(value), _symbolic_clone(time))?
        @: value / frequency
    same(_symbolic_clone(value), _symbolic_clone(time))?
        @: 1 / frequency^2
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ operation = 1?
        left: _symbolic_laplace_verification_expected(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(time),
            _symbolic_clone(frequency)
        )
        right: _symbolic_laplace_verification_expected(
            _symbolic_right(value), time, frequency
        )
        @: left + right
    kind = 3 /\ operation = 2?
        left: _symbolic_laplace_verification_expected(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(time),
            _symbolic_clone(frequency)
        )
        right: _symbolic_laplace_verification_expected(
            _symbolic_right(value), time, frequency
        )
        @: left - right
    kind = 3 /\ operation = 3?
        left_factor: _symbolic_left(_symbolic_clone(value))
        right_factor: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left_factor), _symbolic_clone(time))?
            transformed: _symbolic_laplace_verification_expected(
                right_factor, time, frequency
            )
            @: _symbolic_transform_scale(left_factor, transformed)
        transformed: _symbolic_laplace_verification_expected(
            left_factor, time, frequency
        )
        @: _symbolic_transform_scale(right_factor, transformed)
    kind = 3 /\ operation = 5?
        exponent: _symbolic_right(value)
        order: _symbolic_number_value(exponent)
        @: _symbolic_factorial(order) / frequency^(order + 1)
    argument: _symbolic_argument(value)
    rate: _symbolic_transform_linear_rate(argument, time)
    operation = 1?
        @: rate / (frequency^2 + _symbolic_clone(rate)^2)
    operation = 2?
        @: frequency / (frequency^2 + rate^2)
    1 / (frequency - rate)

verify_laplace(
    candidate:symbolic,
    value:symbolic,
    time:symbolic,
    frequency:symbolic
) -> bit:
    ~_symbolic_laplace_domains_match(_symbolic_clone(time), _symbolic_clone(frequency))?
        @: false
    ~_symbolic_laplace_source_supported(_symbolic_clone(value), _symbolic_clone(time))?
        @: false
    expected: _symbolic_laplace_verification_expected(value, time, frequency)
    equivalent(candidate, expected)

_symbolic_laplace_growth_rate(value:symbolic, time:symbolic) -> symbolic:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ operation = 3?
        left: _symbolic_left(_symbolic_clone(value))
        right: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left), _symbolic_clone(time))?
            @: _symbolic_laplace_growth_rate(right, time)
        ~depends_on(_symbolic_clone(right), _symbolic_clone(time))?
            @: _symbolic_laplace_growth_rate(left, time)
    kind = 7 /\ operation = 5?
        argument: _symbolic_argument(value)
        _symbolic_transform_linear_argument_matches(_symbolic_clone(argument), _symbolic_clone(time))?
            @: _symbolic_transform_linear_rate(argument, time)
    constant(0)

laplace_condition(value:symbolic, time:symbolic, frequency:symbolic) -> relation:
    _symbolic_require_laplace_domains(_symbolic_clone(time), _symbolic_clone(frequency))
    laplace(_symbolic_clone(value), _symbolic_clone(time), _symbolic_clone(frequency))
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: _symbolic_root_operation(_symbolic_clone(value))
    value_kind = 3 /\ (value_operation = 1 \/ value_operation = 2)?
        errors.RuntimeError("a transform sum has multiple convergence conditions; use laplace_conditions")!
    growth_rate: _symbolic_laplace_growth_rate(value, time)
    real_part(frequency) > real_part(growth_rate)

verify_laplace_condition(
    candidate:relation,
    value:symbolic,
    time:symbolic,
    frequency:symbolic
) -> bit:
    ~_symbolic_laplace_domains_match(_symbolic_clone(time), _symbolic_clone(frequency))?
        @: false
    ~_symbolic_laplace_source_supported(_symbolic_clone(value), _symbolic_clone(time))?
        @: false
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: _symbolic_root_operation(_symbolic_clone(value))
    value_kind = 3 /\ (value_operation = 1 \/ value_operation = 2)?
        @: false
    growth_rate: _symbolic_laplace_growth_rate(value, time)
    expected: real_part(frequency) > real_part(growth_rate)
    same(candidate, expected)

laplace_conditions(value:symbolic, time:symbolic, frequency:symbolic) -> [num]:
    _symbolic_require_laplace_domains(_symbolic_clone(time), _symbolic_clone(frequency))
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: _symbolic_root_operation(_symbolic_clone(value))
    value_kind = 3 /\ (value_operation = 1 \/ value_operation = 2)?
        [num] left: laplace_conditions(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(time),
            _symbolic_clone(frequency)
        )
        [num] right: laplace_conditions(
            _symbolic_right(value),
            time,
            frequency
        )
        @: _symbolic_transform_condition_merge(left, right)
    _symbolic_transform_condition_single(laplace_condition(value, time, frequency))

_symbolic_laplace_verification_conditions(
    value:symbolic,
    time:symbolic,
    frequency:symbolic
) -> [num]:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ (operation = 1 \/ operation = 2)?
        [num] left: _symbolic_laplace_verification_conditions(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(time),
            _symbolic_clone(frequency)
        )
        [num] right: _symbolic_laplace_verification_conditions(
            _symbolic_right(value), time, frequency
        )
        @: _symbolic_transform_condition_merge(left, right)
    growth_rate: _symbolic_laplace_growth_rate(value, time)
    condition: real_part(frequency) > real_part(growth_rate)
    _symbolic_transform_condition_single(condition)

verify_laplace_conditions(
    candidate:[num],
    value:symbolic,
    time:symbolic,
    frequency:symbolic
) -> bit:
    ~_symbolic_laplace_domains_match(_symbolic_clone(time), _symbolic_clone(frequency))?
        @: false
    ~_symbolic_laplace_source_supported(_symbolic_clone(value), _symbolic_clone(time))?
        @: false
    [num] expected: _symbolic_laplace_verification_conditions(value, time, frequency)
    _symbolic_transform_conditions_same(candidate, expected)

_symbolic_inverse_laplace_unverified(value:symbolic, frequency:symbolic, time:symbolic) -> symbolic:
    _symbolic_require_laplace_domains(_symbolic_clone(time), _symbolic_clone(frequency))
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ operation = 1?
        left: _symbolic_inverse_laplace_unverified(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(frequency), _symbolic_clone(time))
        right: _symbolic_inverse_laplace_unverified(_symbolic_right(value), frequency, time)
        @: left + right
    kind = 3 /\ operation = 2?
        left: _symbolic_inverse_laplace_unverified(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(frequency), _symbolic_clone(time))
        right: _symbolic_inverse_laplace_unverified(_symbolic_right(value), frequency, time)
        @: left - right
    kind = 3 /\ operation = 3?
        left_factor: _symbolic_left(_symbolic_clone(value))
        right_factor: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left_factor), _symbolic_clone(frequency))?
            @: _symbolic_multiply_simplified(left_factor, _symbolic_inverse_laplace_unverified(right_factor, frequency, time))
        ~depends_on(_symbolic_clone(right_factor), _symbolic_clone(frequency))?
            @: _symbolic_multiply_simplified(right_factor, _symbolic_inverse_laplace_unverified(left_factor, frequency, time))
        errors.RuntimeError("native symbolic inverse Laplace product strategy requires a constant factor")!
    ~(kind = 3 /\ operation = 4)?
        errors.RuntimeError("native symbolic inverse Laplace strategy is not implemented for this expression")!
    numerator: _symbolic_left(_symbolic_clone(value))
    denominator: _symbolic_right(value)
    depends_on(_symbolic_clone(numerator), _symbolic_clone(frequency))?
        errors.RuntimeError("native symbolic inverse Laplace numerator must be independent of frequency")!
    coefficient: _symbolic_clone(numerator)
    same(_symbolic_clone(denominator), _symbolic_clone(frequency))?
        @: coefficient
    denominator_is_power: _symbolic_root_kind(_symbolic_clone(denominator)) = 3 /\ _symbolic_root_operation(_symbolic_clone(denominator)) = 5
    denominator_is_power?
        base: _symbolic_left(_symbolic_clone(denominator))
        exponent: _symbolic_right(denominator)
        power_supported: (
            same(_symbolic_clone(base), _symbolic_clone(frequency)) /\
            _symbolic_root_kind(_symbolic_clone(exponent)) = 2 /\
            _symbolic_number_value(_symbolic_clone(exponent)) >= 1 /\
            _symbolic_number_value(_symbolic_clone(exponent)) % 1 = 0
        )
        power_supported?
            order: _symbolic_number_value(exponent) - 1
            scale: _symbolic_divide_simplified(coefficient, constant(_symbolic_factorial(order)))
            order = 0?
                @: scale
            basis: _symbolic_clone(time)
            order != 1?
                .basis: time^order
            @: _symbolic_multiply_simplified(scale, basis)
    denominator_is_shift: _symbolic_root_kind(_symbolic_clone(denominator)) = 3 /\ _symbolic_root_operation(_symbolic_clone(denominator)) = 2
    denominator_is_shift?
        shift_left: _symbolic_left(_symbolic_clone(denominator))
        shift_right: _symbolic_right(denominator)
        same(_symbolic_clone(shift_left), _symbolic_clone(frequency)) /\ ~depends_on(_symbolic_clone(shift_right), _symbolic_clone(frequency))?
            exponential: exp(_symbolic_multiply_simplified(shift_right, time))
            same(_symbolic_clone(coefficient), constant(1))?
                @: exponential
            @: _symbolic_multiply_simplified(coefficient, exponential)
    errors.RuntimeError("native symbolic inverse Laplace denominator is not a supported basis term")!

verify_inverse_laplace(
    candidate:symbolic,
    value:symbolic,
    frequency:symbolic,
    time:symbolic
) -> bit:
    ~_symbolic_laplace_domains_match(_symbolic_clone(time), _symbolic_clone(frequency))?
        @: false
    transformed: laplace(candidate, time, frequency)
    equivalent(transformed, value)

inverse_laplace(value:symbolic, frequency:symbolic, time:symbolic) -> symbolic:
    candidate: _symbolic_inverse_laplace_unverified(
        _symbolic_clone(value),
        _symbolic_clone(frequency),
        _symbolic_clone(time)
    )
    verify_inverse_laplace(
        _symbolic_clone(candidate),
        value,
        frequency,
        time
    )?
        @: candidate
    errors.RuntimeError("native symbolic inverse Laplace candidate failed forward-transform verification")!

_symbolic_ode_application_target(value:symbolic) -> symbolic:
    result: _symbolic_clone(value)
    _symbolic_storage_kind(_symbolic_clone(result)) != 10?
        @: result
    operation: _symbolic_dag_node_operation(_symbolic_clone(result), _symbolic_dag_root(_symbolic_clone(result)))
    operation = 18?>
        .result: _symbolic_left(result)
        .operation: 0
        _symbolic_storage_kind(_symbolic_clone(result)) = 10?
            .operation: _symbolic_dag_node_operation(_symbolic_clone(result), _symbolic_dag_root(_symbolic_clone(result)))
    result

_symbolic_rate_product_matches(value:symbolic, dependent:symbolic) -> bit:
    is_product: _symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 3
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_number: _symbolic_root_kind(_symbolic_clone(left)) = 2
    right_number: _symbolic_root_kind(_symbolic_clone(right)) = 2
    left_dependent: same(_symbolic_clone(left), _symbolic_clone(dependent))
    right_dependent: same(_symbolic_clone(right), dependent)
    is_product /\ ((left_number /\ right_dependent) \/ (right_number /\ left_dependent))

_symbolic_applied_rate_product_matches(value:symbolic, dependent:symbolic) -> bit:
    is_product: _symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 3
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_number: _symbolic_root_kind(_symbolic_clone(left)) = 2
    right_number: _symbolic_root_kind(_symbolic_clone(right)) = 2
    left_application: false
    right_application: false
    _symbolic_storage_kind(_symbolic_clone(left)) = 10?
        .left_application: _symbolic_dag_operation(_symbolic_clone(left)) = 18
    _symbolic_storage_kind(_symbolic_clone(right)) = 10?
        .right_application: _symbolic_dag_operation(_symbolic_clone(right)) = 18
    left_dependent: left_application /\ same(_symbolic_left(_symbolic_clone(left)), _symbolic_clone(dependent))
    right_dependent: right_application /\ same(_symbolic_left(_symbolic_clone(right)), dependent)
    is_product /\ ((left_number /\ right_dependent) \/ (right_number /\ left_dependent))

_symbolic_application_matches(
    value:symbolic,
    dependent:symbolic,
    argument:symbolic
) -> bit:
    storage_matches: _symbolic_storage_kind(_symbolic_clone(value)) = 10
    operation_matches: _symbolic_dag_operation(_symbolic_clone(value)) = 18
    target_matches: same(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(dependent))
    argument_matches: same(_symbolic_right(_symbolic_clone(value)), _symbolic_clone(argument))
    storage_matches /\ operation_matches /\ target_matches /\ argument_matches

_symbolic_applied_rate_product_matches_at(
    value:symbolic,
    dependent:symbolic,
    argument:symbolic
) -> bit:
    is_product: _symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 3
    ~is_product?
        @: false
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_number: _symbolic_root_kind(_symbolic_clone(left)) = 2
    right_number: _symbolic_root_kind(_symbolic_clone(right)) = 2
    left_number?
        @: _symbolic_application_matches(right, dependent, argument)
    right_number?
        @: _symbolic_application_matches(left, dependent, argument)
    false

_symbolic_rate_product_value(value:symbolic) -> num:
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    _symbolic_root_kind(_symbolic_clone(left)) = 2?
        @: _symbolic_number_value(left)
    _symbolic_number_value(right)

_symbolic_variable_rate_product_matches(value:symbolic, dependent:symbolic, independent:symbolic) -> bit:
    is_product: _symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 3
    ~is_product?
        @: false
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_application: _symbolic_application_matches(_symbolic_clone(left), _symbolic_clone(dependent), _symbolic_clone(independent))
    right_application: _symbolic_application_matches(_symbolic_clone(right), _symbolic_clone(dependent), _symbolic_clone(independent))
    left_application?
        @: depends_on(_symbolic_clone(right), _symbolic_clone(independent)) /\ ~depends_on(right, dependent)
    right_application?
        @: depends_on(_symbolic_clone(left), _symbolic_clone(independent)) /\ ~depends_on(left, dependent)
    false

_symbolic_variable_rate_product_coefficient(value:symbolic, dependent:symbolic, independent:symbolic) -> symbolic:
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    _symbolic_application_matches(_symbolic_clone(left), dependent, independent)?
        @: right
    left

_symbolic_first_order_value_condition_facts(initial_condition:symbolic, dependent:symbolic):
    ~(_symbolic_dag_operation(_symbolic_clone(initial_condition)) = 13)?
        @: (valid:false, point:0, initial:0)
    evaluation: _symbolic_left(_symbolic_clone(initial_condition))
    ~(_symbolic_dag_operation(_symbolic_clone(evaluation)) = 15)?
        @: (valid:false, point:0, initial:0)
    target_matches: same(_symbolic_left(_symbolic_clone(evaluation)), dependent)
    point_value: _symbolic_right(evaluation)
    initial_value: _symbolic_right(initial_condition)
    point_is_number: _symbolic_root_kind(_symbolic_clone(point_value)) = 2
    initial_is_number: _symbolic_root_kind(_symbolic_clone(initial_value)) = 2
    ~(target_matches /\ point_is_number /\ initial_is_number)?
        @: (valid:false, point:0, initial:0)
    (valid:true, point:_symbolic_number_value(point_value), initial:_symbolic_number_value(initial_value))

_symbolic_solve_ode_unverified(
    differential_equation:symbolic,
    initial_condition:symbolic,
    dependent:symbolic,
    independent:symbolic
) -> symbolic:
    orientation_left: _symbolic_left(_symbolic_clone(differential_equation))
    orientation_right: _symbolic_right(_symbolic_clone(differential_equation))
    left_is_derivative: _symbolic_first_order_derivative_surface_matches(
        _symbolic_clone(orientation_left),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    right_is_derivative: _symbolic_first_order_derivative_surface_matches(
        _symbolic_clone(orientation_right),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    right_is_derivative /\ ~left_is_derivative?
        normalized_relation: equation(orientation_right, orientation_left)
        @: _symbolic_solve_ode_unverified(
            normalized_relation,
            initial_condition,
            dependent,
            independent
        )
    relation_root: _symbolic_dag_root(_symbolic_clone(differential_equation))
    relation_is_equation: _symbolic_dag_node_operation(_symbolic_clone(differential_equation), relation_root) = 13
    derivative_value: _symbolic_left(_symbolic_clone(differential_equation))
    derivative_root: _symbolic_dag_root(_symbolic_clone(derivative_value))
    derivative_operation: _symbolic_dag_node_operation(_symbolic_clone(derivative_value), derivative_root)
    derivative_target: _symbolic_clone(derivative_value)
    derivative_argument: _symbolic_clone(independent)
    derivative_operation = 18?
        .derivative_target: _symbolic_left(_symbolic_clone(derivative_value))
        .derivative_argument: _symbolic_right(derivative_value)
    target_operation: _symbolic_dag_node_operation(_symbolic_clone(derivative_target), _symbolic_dag_root(_symbolic_clone(derivative_target)))
    explicit_derivative: target_operation = 14 /\ same(_symbolic_left(_symbolic_clone(derivative_target)), _symbolic_clone(dependent)) /\ same(_symbolic_right(_symbolic_clone(derivative_target)), _symbolic_clone(independent))
    prime_derivative: target_operation = 24 /\ same(_symbolic_left(_symbolic_clone(derivative_target)), _symbolic_clone(dependent)) /\ _symbolic_is_raw_number(_symbolic_right(_symbolic_clone(derivative_target)), 1)
    derivative_matches: explicit_derivative \/ prime_derivative
    derivative_argument_matches: derivative_operation != 18 \/ same(derivative_argument, _symbolic_clone(independent))

    affine: _symbolic_right(differential_equation)
    affine_is_addition: _symbolic_root_kind(_symbolic_clone(affine)) = 3 /\ _symbolic_root_operation(_symbolic_clone(affine)) = 1
    affine_left: _symbolic_clone(affine)
    affine_right: _symbolic_raw_number(0)
    affine_is_addition?
        .affine_left: _symbolic_left(_symbolic_clone(affine))
        .affine_right: _symbolic_right(affine)
    affine_left_is_number: _symbolic_root_kind(_symbolic_clone(affine_left)) = 2
    affine_right_is_number: _symbolic_root_kind(_symbolic_clone(affine_right)) = 2
    rate_product: _symbolic_clone(affine_left)
    offset_value: _symbolic_clone(affine_right)
    affine_is_addition /\ affine_left_is_number?
        .rate_product: _symbolic_clone(affine_right)
        .offset_value: _symbolic_clone(affine_left)
    rate_matches: _symbolic_rate_product_matches(_symbolic_clone(rate_product), _symbolic_clone(dependent)) \/ _symbolic_applied_rate_product_matches(_symbolic_clone(rate_product), _symbolic_clone(dependent))

    condition_root: _symbolic_dag_root(_symbolic_clone(initial_condition))
    condition_is_equation: _symbolic_dag_node_operation(_symbolic_clone(initial_condition), condition_root) = 13
    condition_at: _symbolic_left(_symbolic_clone(initial_condition))
    condition_at_root: _symbolic_dag_root(_symbolic_clone(condition_at))
    condition_is_at: _symbolic_dag_node_operation(_symbolic_clone(condition_at), condition_at_root) = 15
    condition_dependent: _symbolic_left(_symbolic_clone(condition_at))
    condition_point: _symbolic_right(condition_at)
    condition_dependent_matches: same(condition_dependent, dependent)
    condition_at_zero: _symbolic_is_raw_number(condition_point, 0)
    initial_value: _symbolic_right(initial_condition)
    initial_is_number: _symbolic_root_kind(_symbolic_clone(initial_value)) = 2

    variable_rate_matches: _symbolic_variable_rate_product_matches(_symbolic_clone(affine), _symbolic_clone(dependent), _symbolic_clone(independent))
    variable_condition: _symbolic_first_order_value_condition_facts(_symbolic_clone(initial_condition), _symbolic_clone(dependent))
    variable_rate_supported: relation_is_equation /\ derivative_matches /\ derivative_argument_matches /\ variable_rate_matches /\ variable_condition.valid
    variable_rate_supported?
        coefficient: _symbolic_variable_rate_product_coefficient(affine, _symbolic_clone(dependent), _symbolic_clone(independent))
        antiderivative: integrate(coefficient, _symbolic_clone(independent))
        anchor: evaluate(_symbolic_clone(antiderivative), [variable_condition.point])
        @: variable_condition.initial * exp(simplify(antiderivative - anchor))

    affine_matches: ~affine_is_addition \/ affine_left_is_number \/ affine_right_is_number
    supported: relation_is_equation /\ derivative_matches /\ derivative_argument_matches /\ rate_matches /\ affine_matches /\ condition_is_equation /\ condition_is_at /\ condition_dependent_matches /\ condition_at_zero /\ initial_is_number
    homogeneous_supported: supported /\ _symbolic_is_raw_number(_symbolic_clone(offset_value), 0)
    homogeneous_supported?
        @: _symbolic_number_value(initial_value) * exp(_symbolic_rate_product_value(rate_product) * independent)
    zero_rate_supported: supported /\ _symbolic_rate_product_value(_symbolic_clone(rate_product)) = 0
    zero_rate_supported?
        @: _symbolic_number_value(initial_value) + _symbolic_number_value(offset_value) * independent
    supported?
        @: (_symbolic_number_value(initial_value) + _symbolic_number_value(_symbolic_clone(offset_value)) / _symbolic_rate_product_value(_symbolic_clone(rate_product))) * exp(_symbolic_rate_product_value(_symbolic_clone(rate_product)) * independent) - _symbolic_number_value(offset_value) / _symbolic_rate_product_value(rate_product)
    errors.RuntimeError("native symbolic ODE planner has no strategy for this problem")!

verify_ode_solution(solution:symbolic, independent:symbolic, rate:num, initial:num) -> bit:
    ~_symbolic_is_continuous_domain(_symbolic_domain(_symbolic_clone(independent)))?
        @: false
    expected: initial * exp(rate * independent)
    same(solution, expected)

_symbolic_condition_target(condition:symbolic) -> symbolic:
    evaluation: _symbolic_left(condition)
    _symbolic_dag_operation(_symbolic_clone(evaluation)) = 15?
        @: _symbolic_left(evaluation)
    location: _symbolic_left(evaluation)
    _symbolic_left(location)

_symbolic_condition_variable(condition:symbolic) -> symbolic:
    evaluation: _symbolic_left(condition)
    location: _symbolic_left(evaluation)
    _symbolic_right(location)

_symbolic_condition_point(condition:symbolic) -> num:
    evaluation: _symbolic_left(condition)
    _symbolic_number_value(_symbolic_right(evaluation))

_symbolic_condition_value(condition:symbolic) -> num:
    _symbolic_number_value(_symbolic_right(condition))

_symbolic_condition_is_value(condition:symbolic, dependent:symbolic, independent:symbolic) -> bit:
    evaluation: _symbolic_left(_symbolic_clone(condition))
    operation: _symbolic_dag_operation(_symbolic_clone(evaluation))
    operation = 15?
        @: same(_symbolic_left(evaluation), dependent)
    target: _symbolic_condition_target(_symbolic_clone(condition))
    variable: _symbolic_condition_variable(condition)
    operation = 17 /\ same(target, dependent) /\ same(variable, independent)

_symbolic_condition_is_derivative(condition:symbolic, dependent:symbolic, independent:symbolic) -> bit:
    evaluation: _symbolic_left(_symbolic_clone(condition))
    operation: _symbolic_dag_operation(_symbolic_clone(evaluation))
    target: _symbolic_condition_target(_symbolic_clone(condition))
    operation = 15?
        @: _symbolic_prime_matches(target, dependent, 1) \/ _symbolic_derivative_matches(target, dependent, independent)
    variable: _symbolic_condition_variable(condition)
    operation = 17 /\ _symbolic_derivative_matches(target, dependent, _symbolic_clone(independent)) /\ same(variable, independent)

_symbolic_linear_closed_form(slope:num, intercept:num, independent:symbolic) -> symbolic:
    intercept = 0?
        @: slope * independent
    slope * independent + intercept

_symbolic_second_order_surface_matches(
    value:symbolic,
    dependent:symbolic,
    independent:symbolic
) -> bit:
    operation: _symbolic_dag_operation(_symbolic_clone(value))
    operation = 18?
        target: _symbolic_left(_symbolic_clone(value))
        argument: _symbolic_right(value)
        @: _symbolic_prime_matches(target, dependent, 2) /\ same(argument, independent)
    _symbolic_second_derivative_matches(value, dependent, independent)

_symbolic_oscillator_product_facts(value:symbolic, dependent:symbolic, independent:symbolic):
    rate_matches: _symbolic_rate_product_matches(_symbolic_clone(value), _symbolic_clone(dependent)) \/ _symbolic_applied_rate_product_matches_at(_symbolic_clone(value), dependent, independent)
    ~rate_matches?
        @: (valid:false, coefficient:0)
    coefficient: _symbolic_rate_product_value(value)
    (valid:coefficient != 0, coefficient:coefficient)

_symbolic_oscillator_surface_facts(
    relation_surface:symbolic,
    dependent:symbolic,
    independent:symbolic
):
    is_binary: _symbolic_root_kind(_symbolic_clone(relation_surface)) = 3
    operation: _symbolic_root_operation(_symbolic_clone(relation_surface))
    is_additive: is_binary /\ (operation = 1 \/ operation = 2)
    ~is_additive?
        @: (valid:false, coefficient:0)
    right_sign: 1
    operation = 2?
        .right_sign: -1
    left: _symbolic_left(_symbolic_clone(relation_surface))
    right: _symbolic_right(relation_surface)
    left_is_derivative: _symbolic_second_order_surface_matches(_symbolic_clone(left), _symbolic_clone(dependent), _symbolic_clone(independent))
    right_is_derivative: _symbolic_second_order_surface_matches(_symbolic_clone(right), _symbolic_clone(dependent), _symbolic_clone(independent))
    left_is_derivative?
        product: _symbolic_oscillator_product_facts(right, dependent, independent)
        @: (valid:product.valid, coefficient:right_sign * product.coefficient)
    right_is_derivative?
        product: _symbolic_oscillator_product_facts(left, dependent, independent)
        @: (valid:product.valid, coefficient:right_sign * product.coefficient)
    (valid:false, coefficient:0)

_symbolic_oscillator_relation_facts(
    differential_equation:symbolic,
    dependent:symbolic,
    independent:symbolic
):
    ~(_symbolic_dag_operation(_symbolic_clone(differential_equation)) = 13)?
        @: (valid:false, coefficient:0)
    left: _symbolic_left(_symbolic_clone(differential_equation))
    right: _symbolic_right(differential_equation)
    _symbolic_is_raw_number(_symbolic_clone(right), 0)?
        @: _symbolic_oscillator_surface_facts(left, dependent, independent)
    _symbolic_is_raw_number(_symbolic_clone(left), 0)?
        @: _symbolic_oscillator_surface_facts(right, dependent, independent)
    (valid:false, coefficient:0)

_symbolic_second_order_linear_invalid() -> [num]:
    [num] result: [0, 0, 0, 0]
    result

_symbolic_second_order_linear_facts(
    value:symbolic,
    dependent:symbolic,
    independent:symbolic
) -> [num]:
    _symbolic_second_order_surface_matches(
        _symbolic_clone(value),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )?
        @: [1, 1, 0, 0]
    _symbolic_first_order_derivative_surface_matches(
        _symbolic_clone(value),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )?
        @: [1, 0, 1, 0]
    (_symbolic_application_matches(
        _symbolic_clone(value),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    ) \/ same(_symbolic_clone(value), _symbolic_clone(dependent)))?
        @: [1, 0, 0, 1]
    kind: _symbolic_root_kind(_symbolic_clone(value))
    kind = 2?
        _symbolic_number_value(value) = 0?
            @: [1, 0, 0, 0]
        @: _symbolic_second_order_linear_invalid()
    ~(kind = 3)?
        @: _symbolic_second_order_linear_invalid()
    operation: _symbolic_root_operation(_symbolic_clone(value))
    operation = 1 \/ operation = 2?
        additive_left: _symbolic_second_order_linear_facts(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(dependent),
            _symbolic_clone(independent)
        )
        additive_right: _symbolic_second_order_linear_facts(
            _symbolic_right(value),
            dependent,
            independent
        )
        right_scale: 1
        operation = 2?
            .right_scale: -1
        additive_left.0 = 0 \/ additive_right.0 = 0?
            @: _symbolic_second_order_linear_invalid()
        [num] additive_result: [
            1,
            additive_left.1 + right_scale * additive_right.1,
            additive_left.2 + right_scale * additive_right.2,
            additive_left.3 + right_scale * additive_right.3
        ]
        @: additive_result
    operation = 3?
        product_left: _symbolic_left(_symbolic_clone(value))
        product_right: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(product_left)) = 2?
            [num] right_product_facts: _symbolic_second_order_linear_facts(product_right, dependent, independent)
            right_product_facts.0 = 0?
                @: _symbolic_second_order_linear_invalid()
            right_scale: _symbolic_number_value(product_left)
            [num] right_product_result: [1, right_product_facts.1 * right_scale, right_product_facts.2 * right_scale, right_product_facts.3 * right_scale]
            @: right_product_result
        _symbolic_root_kind(_symbolic_clone(product_right)) = 2?
            [num] left_product_facts: _symbolic_second_order_linear_facts(product_left, dependent, independent)
            left_product_facts.0 = 0?
                @: _symbolic_second_order_linear_invalid()
            left_scale: _symbolic_number_value(product_right)
            [num] left_product_result: [1, left_product_facts.1 * left_scale, left_product_facts.2 * left_scale, left_product_facts.3 * left_scale]
            @: left_product_result
        @: _symbolic_second_order_linear_invalid()
    operation = 4?
        numerator: _symbolic_left(_symbolic_clone(value))
        denominator: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(denominator)) = 2 /\ _symbolic_number_value(_symbolic_clone(denominator)) != 0?
            [num] numerator_facts: _symbolic_second_order_linear_facts(numerator, dependent, independent)
            numerator_facts.0 = 0?
                @: _symbolic_second_order_linear_invalid()
            denominator_scale: 1 / _symbolic_number_value(denominator)
            [num] quotient_result: [1, numerator_facts.1 * denominator_scale, numerator_facts.2 * denominator_scale, numerator_facts.3 * denominator_scale]
            @: quotient_result
    _symbolic_second_order_linear_invalid()

_symbolic_second_order_relation_facts(
    differential_equation:symbolic,
    dependent:symbolic,
    independent:symbolic
):
    is_equation: _symbolic_dag_operation(_symbolic_clone(differential_equation)) = 13
    is_equation?
        left_facts: _symbolic_second_order_linear_facts(
            _symbolic_left(_symbolic_clone(differential_equation)),
            _symbolic_clone(dependent),
            _symbolic_clone(independent)
        )
        right_facts: _symbolic_second_order_linear_facts(
            _symbolic_right(_symbolic_clone(differential_equation)),
            dependent,
            independent
        )
        [num] residual_facts: [
            left_facts.0 * right_facts.0,
            left_facts.1 - right_facts.1,
            left_facts.2 - right_facts.2,
            left_facts.3 - right_facts.3
        ]
        residual_facts.0 != 0 /\ residual_facts.1 != 0?
            @: (
                valid:true,
                first_coefficient:residual_facts.2 / residual_facts.1,
                coefficient:residual_facts.3 / residual_facts.1
            )
    oscillator: _symbolic_oscillator_relation_facts(_symbolic_clone(differential_equation), _symbolic_clone(dependent), _symbolic_clone(independent))
    oscillator.valid?
        @: (valid:true, first_coefficient:0, coefficient:oscillator.coefficient)
    relation_left: _symbolic_left(_symbolic_clone(differential_equation))
    relation_right: _symbolic_right(differential_equation)
    zero_acceleration: (
        _symbolic_second_order_surface_matches(_symbolic_clone(relation_left), _symbolic_clone(dependent), _symbolic_clone(independent)) /\
        _symbolic_is_raw_number(_symbolic_clone(relation_right), 0)
    ) \/ (
        _symbolic_second_order_surface_matches(relation_right, dependent, independent) /\
        _symbolic_is_raw_number(relation_left, 0)
    )
    (valid:is_equation /\ zero_acceleration, first_coefficient:0, coefficient:0)

_symbolic_oscillator_closed_form(
    position:num,
    velocity:num,
    coefficient:num,
    independent:symbolic
) -> symbolic:
    frequency: m.sqrt(coefficient)
    position * cos(frequency * _symbolic_clone(independent)) + (velocity / frequency) * sin(frequency * independent)

_symbolic_real_root_closed_form(
    position:num,
    velocity:num,
    coefficient:num,
    independent:symbolic
) -> symbolic:
    rate: m.sqrt(0 - coefficient)
    positive_scale: (position + velocity / rate) / 2
    negative_scale: position - positive_scale
    positive_scale * exp(rate * _symbolic_clone(independent)) + negative_scale * exp(0 - rate * independent)

_symbolic_distinct_real_root_closed_form(
    position:num,
    velocity:num,
    first_rate:num,
    second_rate:num,
    independent:symbolic
) -> symbolic:
    first_scale: (velocity - second_rate * position) / (first_rate - second_rate)
    second_scale: position - first_scale
    first_scale * exp(first_rate * _symbolic_clone(independent)) + second_scale * exp(second_rate * independent)

_symbolic_repeated_real_root_closed_form(
    position:num,
    velocity:num,
    rate:num,
    independent:symbolic
) -> symbolic:
    slope: velocity - rate * position
    (position + slope * _symbolic_clone(independent)) * exp(rate * independent)

_symbolic_damped_complex_root_closed_form(
    position:num,
    velocity:num,
    first_coefficient:num,
    coefficient:num,
    independent:symbolic
) -> symbolic:
    envelope_rate: (0 - first_coefficient) / 2
    frequency: m.sqrt(4 * coefficient - first_coefficient^2) / 2
    sine_scale: (velocity - envelope_rate * position) / frequency
    exp(envelope_rate * _symbolic_clone(independent)) * (
        position * cos(frequency * _symbolic_clone(independent)) +
        sine_scale * sin(frequency * independent)
    )

_symbolic_solve_second_order_ode_unverified(
    differential_equation:symbolic,
    conditions:[symbolic:n],
    dependent:symbolic,
    independent:symbolic
) -> symbolic:
    conditions.length() != 2?
        errors.RuntimeError("native symbolic boundary-value ODE strategy requires two conditions")!
    output_independent: _symbolic_clone(independent)
    relation_left: _symbolic_left(_symbolic_clone(differential_equation))
    relation_right: _symbolic_right(differential_equation)
    relation_matches: _symbolic_second_derivative_matches(relation_left, _symbolic_clone(dependent), _symbolic_clone(independent)) /\ _symbolic_is_raw_number(relation_right, 0)
    oscillator: _symbolic_second_order_relation_facts(_symbolic_clone(differential_equation), _symbolic_clone(dependent), _symbolic_clone(independent))
    first_value_condition: _symbolic_condition_is_value(_symbolic_clone(conditions.0), _symbolic_clone(dependent), _symbolic_clone(independent))
    first_derivative_condition: _symbolic_condition_is_derivative(_symbolic_clone(conditions.0), _symbolic_clone(dependent), _symbolic_clone(independent))
    second_value_condition: _symbolic_condition_is_value(_symbolic_clone(conditions.1), _symbolic_clone(dependent), _symbolic_clone(independent))
    second_derivative_condition: _symbolic_condition_is_derivative(_symbolic_clone(conditions.1), dependent, independent)
    first_point: _symbolic_condition_point(_symbolic_clone(conditions.0))
    first_value: _symbolic_condition_value(_symbolic_clone(conditions.0))
    second_point: _symbolic_condition_point(_symbolic_clone(conditions.1))
    second_value: _symbolic_condition_value(conditions.1)
    discriminant: oscillator.first_coefficient^2 - 4 * oscillator.coefficient
    oscillator.valid /\ oscillator.first_coefficient != 0 /\ discriminant = 0 /\ first_value_condition /\ second_derivative_condition /\ first_point = 0 /\ second_point = 0?
        repeated_root: (0 - oscillator.first_coefficient) / 2
        @: _symbolic_repeated_real_root_closed_form(first_value, second_value, repeated_root, output_independent)
    oscillator.valid /\ oscillator.first_coefficient != 0 /\ discriminant = 0 /\ first_derivative_condition /\ second_value_condition /\ first_point = 0 /\ second_point = 0?
        repeated_root: (0 - oscillator.first_coefficient) / 2
        @: _symbolic_repeated_real_root_closed_form(second_value, first_value, repeated_root, output_independent)
    oscillator.valid /\ oscillator.first_coefficient != 0 /\ discriminant < 0 /\ first_value_condition /\ second_derivative_condition /\ first_point = 0 /\ second_point = 0?
        @: _symbolic_damped_complex_root_closed_form(first_value, second_value, oscillator.first_coefficient, oscillator.coefficient, output_independent)
    oscillator.valid /\ oscillator.first_coefficient != 0 /\ discriminant < 0 /\ first_derivative_condition /\ second_value_condition /\ first_point = 0 /\ second_point = 0?
        @: _symbolic_damped_complex_root_closed_form(second_value, first_value, oscillator.first_coefficient, oscillator.coefficient, output_independent)
    oscillator.valid /\ oscillator.first_coefficient != 0 /\ discriminant > 0 /\ first_value_condition /\ second_derivative_condition /\ first_point = 0 /\ second_point = 0?
        root_distance: m.sqrt(discriminant)
        first_root: (0 - oscillator.first_coefficient + root_distance) / 2
        second_root: (0 - oscillator.first_coefficient - root_distance) / 2
        @: _symbolic_distinct_real_root_closed_form(first_value, second_value, first_root, second_root, output_independent)
    oscillator.valid /\ oscillator.first_coefficient != 0 /\ discriminant > 0 /\ first_derivative_condition /\ second_value_condition /\ first_point = 0 /\ second_point = 0?
        root_distance: m.sqrt(discriminant)
        first_root: (0 - oscillator.first_coefficient + root_distance) / 2
        second_root: (0 - oscillator.first_coefficient - root_distance) / 2
        @: _symbolic_distinct_real_root_closed_form(second_value, first_value, first_root, second_root, output_independent)
    oscillator.valid /\ oscillator.first_coefficient = 0 /\ oscillator.coefficient > 0 /\ first_value_condition /\ second_derivative_condition /\ first_point = 0 /\ second_point = 0?
        @: _symbolic_oscillator_closed_form(first_value, second_value, oscillator.coefficient, output_independent)
    oscillator.valid /\ oscillator.first_coefficient = 0 /\ oscillator.coefficient > 0 /\ first_derivative_condition /\ second_value_condition /\ first_point = 0 /\ second_point = 0?
        @: _symbolic_oscillator_closed_form(second_value, first_value, oscillator.coefficient, output_independent)
    oscillator.valid /\ oscillator.first_coefficient = 0 /\ oscillator.coefficient < 0 /\ first_value_condition /\ second_derivative_condition /\ first_point = 0 /\ second_point = 0?
        @: _symbolic_real_root_closed_form(first_value, second_value, oscillator.coefficient, output_independent)
    oscillator.valid /\ oscillator.first_coefficient = 0 /\ oscillator.coefficient < 0 /\ first_derivative_condition /\ second_value_condition /\ first_point = 0 /\ second_point = 0?
        @: _symbolic_real_root_closed_form(second_value, first_value, oscillator.coefficient, output_independent)
    relation_matches /\ first_value_condition /\ second_derivative_condition?
        intercept: first_value - second_value * first_point
        @: _symbolic_linear_closed_form(second_value, intercept, output_independent)
    relation_matches /\ first_derivative_condition /\ second_value_condition?
        intercept: second_value - first_value * second_point
        @: _symbolic_linear_closed_form(first_value, intercept, output_independent)
    relation_matches /\ first_value_condition /\ second_value_condition /\ first_point != second_point?
        slope: (second_value - first_value) / (second_point - first_point)
        intercept: first_value - slope * first_point
        @: _symbolic_linear_closed_form(slope, intercept, output_independent)
    errors.RuntimeError("native symbolic ODE planner has no strategy for these constraints")!

_symbolic_dag_operation(value:symbolic) -> num:
    _symbolic_dag_node_operation(value, _symbolic_dag_root(value))

_symbolic_derivative_matches(value:symbolic, dependent:symbolic, variable:symbolic) -> bit:
    is_derivative: _symbolic_dag_operation(_symbolic_clone(value)) = 14
    derivative_dependent: _symbolic_left(_symbolic_clone(value))
    derivative_variable: _symbolic_right(value)
    is_derivative /\ same(derivative_dependent, dependent) /\ same(derivative_variable, variable)

_symbolic_prime_matches(value:symbolic, dependent:symbolic, order:num) -> bit:
    is_prime: _symbolic_dag_operation(_symbolic_clone(value)) = 24
    prime_dependent: _symbolic_left(_symbolic_clone(value))
    prime_order: _symbolic_right(value)
    is_prime /\ same(prime_dependent, dependent) /\ _symbolic_is_raw_number(prime_order, order)

_symbolic_second_derivative_matches(value:symbolic, dependent:symbolic, variable:symbolic) -> bit:
    is_derivative: _symbolic_dag_operation(_symbolic_clone(value)) = 14
    inner: _symbolic_left(_symbolic_clone(value))
    outer_variable: _symbolic_right(value)
    inner_matches: _symbolic_derivative_matches(inner, _symbolic_clone(dependent), _symbolic_clone(variable))
    is_derivative /\ inner_matches /\ same(outer_variable, variable)

_symbolic_at_constraint_matches(
    constraint:symbolic,
    dependent:symbolic,
    variable:symbolic,
    point:num
) -> bit:
    is_equation: _symbolic_dag_operation(_symbolic_clone(constraint)) = 13
    evaluation: _symbolic_left(_symbolic_clone(constraint))
    is_evaluation: _symbolic_dag_operation(_symbolic_clone(evaluation)) = 17
    location: _symbolic_left(_symbolic_clone(evaluation))
    point_value: _symbolic_right(evaluation)
    is_location: _symbolic_dag_operation(_symbolic_clone(location)) = 16
    location_dependent: _symbolic_left(_symbolic_clone(location))
    location_variable: _symbolic_right(location)
    right: _symbolic_right(constraint)
    is_equation /\ is_evaluation /\ is_location /\ same(location_dependent, dependent) /\ same(location_variable, variable) /\ _symbolic_is_raw_number(point_value, point) /\ _symbolic_is_raw_number(right, 0)

solve_pde(
    differential_equation:symbolic,
    initial_condition:symbolic,
    boundaries:[symbolic:n],
    dependent:symbolic,
    space:symbolic,
    time:symbolic
) -> symbolic:
    output_space: _symbolic_clone(space)
    output_time: _symbolic_clone(time)
    boundary_count_matches: boundaries.length() = 2
    relation_is_equation: _symbolic_dag_operation(_symbolic_clone(differential_equation)) = 13
    relation_left: _symbolic_left(_symbolic_clone(differential_equation))
    relation_right: _symbolic_right(differential_equation)
    time_derivative: _symbolic_derivative_matches(relation_left, _symbolic_clone(dependent), _symbolic_clone(time))
    space_derivative: _symbolic_second_derivative_matches(relation_right, _symbolic_clone(dependent), _symbolic_clone(space))

    initial_is_equation: _symbolic_dag_operation(_symbolic_clone(initial_condition)) = 13
    initial_evaluation: _symbolic_left(_symbolic_clone(initial_condition))
    initial_profile: _symbolic_right(initial_condition)
    initial_is_evaluation: _symbolic_dag_operation(_symbolic_clone(initial_evaluation)) = 17
    initial_location: _symbolic_left(_symbolic_clone(initial_evaluation))
    initial_point: _symbolic_right(initial_evaluation)
    initial_is_location: _symbolic_dag_operation(_symbolic_clone(initial_location)) = 16
    initial_dependent: _symbolic_left(_symbolic_clone(initial_location))
    initial_variable: _symbolic_right(initial_location)
    initial_matches: initial_is_equation /\ initial_is_evaluation /\ initial_is_location /\ same(initial_dependent, _symbolic_clone(dependent)) /\ same(initial_variable, _symbolic_clone(time)) /\ _symbolic_is_raw_number(initial_point, 0)
    profile_is_sine: _symbolic_root_kind(_symbolic_clone(initial_profile)) = 7 /\ _symbolic_root_operation(_symbolic_clone(initial_profile)) = 1 /\ same(_symbolic_argument(initial_profile), _symbolic_clone(space))

    first_boundary: _symbolic_at_constraint_matches(_symbolic_clone(boundaries.0), _symbolic_clone(dependent), _symbolic_clone(space), 0)
    second_boundary: _symbolic_at_constraint_matches(boundaries.1, dependent, space, 3.141592653589793)
    supported: boundary_count_matches /\ relation_is_equation /\ time_derivative /\ space_derivative /\ initial_matches /\ profile_is_sine /\ first_boundary /\ second_boundary
    supported?
        candidate: sin(output_space) * exp(0 - output_time)
        verify_pde_solution(
            _symbolic_clone(candidate),
            _symbolic_clone(differential_equation),
            _symbolic_clone(initial_condition),
            boundaries,
            dependent,
            space,
            time
        )?
            @: candidate
        errors.RuntimeError("native symbolic heat candidate failed residual or condition verification")!
    errors.RuntimeError("native symbolic PDE planner has no strategy for this problem")!

_symbolic_heat_relation_matches(
    differential_equation:symbolic,
    dependent:symbolic,
    space:symbolic,
    time:symbolic
) -> bit:
    ~(_symbolic_dag_operation(_symbolic_clone(differential_equation)) = 13)?
        @: false
    relation_left: _symbolic_left(_symbolic_clone(differential_equation))
    relation_right: _symbolic_right(differential_equation)
    (_symbolic_derivative_matches(relation_left, _symbolic_clone(dependent), _symbolic_clone(time)) /\
     _symbolic_second_derivative_matches(relation_right, dependent, space))

_symbolic_pde_point_constraint_satisfied(
    solution:symbolic,
    constraint:symbolic,
    dependent:symbolic,
    variable:symbolic
) -> bit:
    ~(_symbolic_dag_operation(_symbolic_clone(constraint)) = 13)?
        @: false
    evaluation: _symbolic_left(_symbolic_clone(constraint))
    ~(_symbolic_dag_operation(_symbolic_clone(evaluation)) = 17)?
        @: false
    location: _symbolic_left(_symbolic_clone(evaluation))
    ~(_symbolic_dag_operation(_symbolic_clone(location)) = 16)?
        @: false
    location_dependent: _symbolic_left(_symbolic_clone(location))
    location_variable: _symbolic_right(location)
    point: _symbolic_right(evaluation)
    invalid_constraint: (~same(_symbolic_clone(location_dependent), _symbolic_clone(dependent)) \/
        ~same(_symbolic_clone(location_variable), _symbolic_clone(variable)) \/
        ~(_symbolic_root_kind(_symbolic_clone(point)) = 2))
    invalid_constraint?
        @: false
    candidate: simplify(substitute(
        solution,
        variable,
        _symbolic_number_value(point)
    ))
    expected: simplify(_symbolic_right(constraint))
    equivalent(candidate, expected)

_symbolic_heat_sine_factor_matches(value:symbolic, space:symbolic) -> bit:
    (_symbolic_root_kind(_symbolic_clone(value)) = 7 /\
     _symbolic_root_operation(_symbolic_clone(value)) = 1 /\
     same(_symbolic_argument(value), space))

_symbolic_heat_exponential_facts(value:symbolic, time:symbolic):
    is_exponential: (
        _symbolic_root_kind(_symbolic_clone(value)) = 7 /\
        _symbolic_root_operation(_symbolic_clone(value)) = 5
    )
    ~is_exponential?
        @: (valid:false, rate:0)
    argument: _symbolic_argument(value)
    same(_symbolic_clone(argument), _symbolic_clone(time))?
        @: (valid:true, rate:1)
    argument_kind: _symbolic_root_kind(_symbolic_clone(argument))
    argument_operation: _symbolic_root_operation(_symbolic_clone(argument))
    argument_kind = 3 /\ argument_operation = 2?
        left: _symbolic_left(_symbolic_clone(argument))
        right: _symbolic_right(argument)
        _symbolic_is_raw_number(left, 0) /\ same(right, time)?
            @: (valid:true, rate:-1)
    argument_kind = 3 /\ argument_operation = 3?
        left: _symbolic_left(_symbolic_clone(argument))
        right: _symbolic_right(argument)
        _symbolic_root_kind(_symbolic_clone(left)) = 2 /\ same(_symbolic_clone(right), _symbolic_clone(time))?
            @: (valid:true, rate:_symbolic_number_value(left))
        _symbolic_root_kind(_symbolic_clone(right)) = 2 /\ same(left, time)?
            @: (valid:true, rate:_symbolic_number_value(right))
    (valid:false, rate:0)

_symbolic_heat_candidate_facts(solution:symbolic, space:symbolic, time:symbolic):
    is_product: (
        _symbolic_root_kind(_symbolic_clone(solution)) = 3 /\
        _symbolic_root_operation(_symbolic_clone(solution)) = 3
    )
    ~is_product?
        @: (valid:false, rate:0)
    left: _symbolic_left(_symbolic_clone(solution))
    right: _symbolic_right(solution)
    left_exponential: _symbolic_heat_exponential_facts(_symbolic_clone(left), _symbolic_clone(time))
    right_exponential: _symbolic_heat_exponential_facts(_symbolic_clone(right), _symbolic_clone(time))
    _symbolic_heat_sine_factor_matches(_symbolic_clone(left), _symbolic_clone(space)) /\ right_exponential.valid?
        @: right_exponential
    _symbolic_heat_sine_factor_matches(right, space) /\ left_exponential.valid?
        @: left_exponential
    (valid:false, rate:0)

verify_pde_solution(
    solution:symbolic,
    differential_equation:symbolic,
    initial_condition:symbolic,
    boundaries:[symbolic:n],
    dependent:symbolic,
    space:symbolic,
    time:symbolic
) -> bit:
    boundaries.length() != 2?
        @: false
    space_domain: _symbolic_domain(_symbolic_clone(space))
    time_domain: _symbolic_domain(_symbolic_clone(time))
    ~(_symbolic_is_continuous_domain(space_domain) /\ _symbolic_is_continuous_domain(time_domain))?
        @: false
    arity: _symbolic_function_arity(_symbolic_clone(dependent))
    dependent_domain_matches: false
    arity = 0?
        .dependent_domain_matches: _symbolic_is_continuous_domain(_symbolic_domain(_symbolic_clone(dependent)))
    arity = 2?
        .dependent_domain_matches: (
            _symbolic_function_domain_at(_symbolic_clone(dependent), 0) = space_domain /\
            _symbolic_function_domain_at(_symbolic_clone(dependent), 1) = time_domain /\
            _symbolic_is_continuous_domain(_symbolic_function_codomain(dependent))
        )
    problem_matches: (dependent_domain_matches /\
        _symbolic_heat_relation_matches(
            _symbolic_clone(differential_equation),
            _symbolic_clone(dependent),
            _symbolic_clone(space),
            _symbolic_clone(time)
        ))
    ~problem_matches?
        @: false
    # For the supported separated basis sin(x) * exp(rate*t), substituting into
    # u_t = u_xx leaves the exact residual factor rate + 1.
    candidate_facts: _symbolic_heat_candidate_facts(
        _symbolic_clone(solution),
        _symbolic_clone(space),
        _symbolic_clone(time)
    )
    ~candidate_facts.valid \/ candidate_facts.rate != -1?
        @: false
    ~_symbolic_pde_point_constraint_satisfied(
        _symbolic_clone(solution),
        _symbolic_clone(initial_condition),
        _symbolic_clone(dependent),
        _symbolic_clone(time)
    )?
        @: false
    verified: true
    boundary_index: 0
    boundary_index < boundaries.length()?>
        ~_symbolic_pde_point_constraint_satisfied(
            _symbolic_clone(solution),
            _symbolic_clone(boundaries.(boundary_index)),
            _symbolic_clone(dependent),
            _symbolic_clone(space)
        )?
            .verified: false
        .boundary_index+: 1
    verified

_symbolic_pde_application_target(value:symbolic) -> symbolic:
    result: _symbolic_clone(value)
    _symbolic_dag_operation(_symbolic_clone(result)) = 18?>
        .result: _symbolic_left(result)
    result

_symbolic_geometric_pde_relation_matches(
    differential_equation:symbolic,
    dependent:symbolic,
    first_variable:symbolic,
    second_variable:symbolic
) -> bit:
    expected_relation: equation(
        partial(_symbolic_clone(dependent), _symbolic_clone(first_variable), 2) + partial(_symbolic_clone(dependent), _symbolic_clone(second_variable), 2),
        0
    )
    relation_left: _symbolic_left(_symbolic_clone(differential_equation))
    normalized_first: _symbolic_pde_application_target(_symbolic_left(_symbolic_clone(relation_left)))
    normalized_second: _symbolic_pde_application_target(_symbolic_right(relation_left))
    normalized_relation: equation(
        normalized_first + normalized_second,
        _symbolic_right(_symbolic_clone(differential_equation))
    )
    expected_applied_dependent: at(
        _symbolic_clone(dependent),
        [_symbolic_clone(first_variable), _symbolic_clone(second_variable)]
    )
    surface_relation_matches: (
        _symbolic_second_derivative_matches(
            _symbolic_left(_symbolic_clone(_symbolic_left(_symbolic_clone(differential_equation)))),
            _symbolic_clone(expected_applied_dependent),
            _symbolic_clone(first_variable)
        ) /\
        _symbolic_second_derivative_matches(
            _symbolic_right(_symbolic_left(_symbolic_clone(differential_equation))),
            expected_applied_dependent,
            _symbolic_clone(second_variable)
        ) /\
        _symbolic_is_raw_number(_symbolic_right(_symbolic_clone(differential_equation)), 0)
    )
    same(_symbolic_clone(differential_equation), _symbolic_clone(expected_relation)) \/ same(normalized_relation, expected_relation) \/ surface_relation_matches

_symbolic_harmonic_in_two_variables(value:symbolic, first_variable:symbolic, second_variable:symbolic) -> bit:
    ~_symbolic_is_quadratic_in_two_variables(
        _symbolic_clone(value),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable)
    )?
        @: false
    polynomial: expand(value)
    first_quadratic: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        2,
        0
    )
    second_quadratic: _symbolic_two_variable_polynomial_coefficient(
        polynomial,
        first_variable,
        second_variable,
        0,
        2
    )
    first_quadratic + second_quadratic = 0

_symbolic_rewrite_exact(value:symbolic, pattern:symbolic, replacement:symbolic) -> symbolic:
    same(_symbolic_clone(value), _symbolic_clone(pattern))?
        @: _symbolic_clone(replacement)
    kind: _symbolic_root_kind(_symbolic_clone(value))
    kind = 1 \/ kind = 2 \/ kind = 4 \/ kind = 6?
        @: _symbolic_clone(value)
    kind = 7?
        operation: _symbolic_root_operation(_symbolic_clone(value))
        argument: _symbolic_rewrite_exact(_symbolic_argument(value), pattern, replacement)
        @: _symbolic_rebuild_function(argument, operation)
    ~(kind = 3)?
        @: _symbolic_clone(value)
    operation: _symbolic_root_operation(_symbolic_clone(value))
    left: _symbolic_rewrite_exact(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(pattern), _symbolic_clone(replacement))
    right: _symbolic_rewrite_exact(_symbolic_right(value), pattern, replacement)
    _symbolic_dag_binary(left, right, operation + 2)

_symbolic_reduce_under_equation(value:symbolic, constraint:symbolic) -> symbolic:
    ~(_symbolic_dag_operation(_symbolic_clone(constraint)) = 13)?
        @: _symbolic_clone(value)
    left: _symbolic_left(_symbolic_clone(constraint))
    right: _symbolic_right(constraint)
    simplify(_symbolic_rewrite_exact(value, left, right))

_symbolic_two_variable_polynomial_coefficient(
    polynomial:symbolic,
    first_variable:symbolic,
    second_variable:symbolic,
    first_exponent:num,
    second_exponent:num
) -> num:
    packed: _symbolic_as_polynomial(polynomial)
    catalog: _symbolic_catalog(_symbolic_clone(packed))
    variable_count: _symbolic_catalog_variable_count(
        _symbolic_clone_numeric_vector(catalog)
    )
    first_index: _symbolic_catalog_entry_index(
        _symbolic_clone_numeric_vector(catalog),
        _symbolic_raw_catalog(first_variable)
    )
    second_index: _symbolic_catalog_entry_index(
        catalog,
        _symbolic_raw_catalog(second_variable)
    )
    first_exponent > 0 /\ first_index < 0?
        @: 0
    second_exponent > 0 /\ second_index < 0?
        @: 0
    exponents: [0:variable_count]
    first_index >= 0?
        exponents.(first_index): first_exponent
    second_index >= 0?
        exponents.(second_index): second_exponent
    coefficient(packed, exponents)

_symbolic_is_quadratic_in_two_variables(
    value:symbolic,
    first_variable:symbolic,
    second_variable:symbolic
) -> bit:
    expanded: expand(value)
    expanded_kind: _symbolic_root_kind(_symbolic_clone(expanded))
    ~(expanded_kind = 1 \/ expanded_kind = 2 \/ expanded_kind = 4)?
        @: false
    polynomial: _symbolic_as_polynomial(expanded)
    catalog: _symbolic_catalog(_symbolic_clone(polynomial))
    variable_count: _symbolic_catalog_variable_count(_symbolic_clone_numeric_vector(catalog))
    first_present: _symbolic_catalog_has_entry(
        _symbolic_clone_numeric_vector(catalog),
        _symbolic_raw_catalog(first_variable)
    )
    second_present: _symbolic_catalog_has_entry(
        catalog,
        _symbolic_raw_catalog(second_variable)
    )
    allowed_variable_count: 0
    first_present?
        .allowed_variable_count+: 1
    second_present?
        .allowed_variable_count+: 1
    variable_count != allowed_variable_count?
        @: false
    valid: true
    terms: _symbolic_polynomial_term_count(_symbolic_clone(polynomial))
    terms > 0?
        ..terms - 1 >>
            term: $
            total_degree: 0
            variable_count > 0?
                ..variable_count - 1 >>
                    .total_degree+: _symbolic_polynomial_term_exponent(
                        _symbolic_clone(polynomial),
                        term,
                        $
                    )
            total_degree > 2?
                .valid: false
    valid

_symbolic_unit_circle_quadratic_harmonic_extension(
    value:symbolic,
    first_variable:symbolic,
    second_variable:symbolic
) -> symbolic:
    polynomial: _symbolic_as_polynomial(expand(value))
    constant_value: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        0,
        0
    )
    first_linear: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        1,
        0
    )
    second_linear: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        0,
        1
    )
    first_quadratic: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        2,
        0
    )
    mixed_quadratic: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        1,
        1
    )
    second_quadratic: _symbolic_two_variable_polynomial_coefficient(
        polynomial,
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        0,
        2
    )
    radial_constant: (first_quadratic + second_quadratic) / 2
    harmonic_quadratic: (
        (first_quadratic - second_quadratic) / 2 *
        (first_variable^2 - second_variable^2)
    )
    (
        constant_value + radial_constant +
        first_linear * first_variable +
        second_linear * second_variable +
        harmonic_quadratic +
        mixed_quadratic * first_variable * second_variable
    )

_symbolic_unit_circle_boundary_matches(
    solution:symbolic,
    boundary_value:symbolic,
    first_variable:symbolic,
    second_variable:symbolic
) -> bit:
    residual: _symbolic_clone(solution) - _symbolic_clone(boundary_value)
    ~_symbolic_is_quadratic_in_two_variables(
        _symbolic_clone(residual),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable)
    )?
        @: false
    polynomial: _symbolic_as_polynomial(expand(residual))
    first_linear: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        1,
        0
    )
    second_linear: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        0,
        1
    )
    first_quadratic: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        2,
        0
    )
    mixed_quadratic: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        1,
        1
    )
    second_quadratic: _symbolic_two_variable_polynomial_coefficient(
        _symbolic_clone(polynomial),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable),
        0,
        2
    )
    constant_number: _symbolic_two_variable_polynomial_coefficient(
        polynomial,
        first_variable,
        second_variable,
        0,
        0
    )
    (
        first_linear = 0 /\
        second_linear = 0 /\
        mixed_quadratic = 0 /\
        first_quadratic = second_quadratic /\
        constant_number + first_quadratic = 0
    )

verify_pde_solution(
    solution:symbolic,
    differential_equation:symbolic,
    boundaries:[symbolic:n],
    dependent:symbolic,
    variables:[symbolic:m]
) -> bit:
    verified: false
    boundaries.length() = 1 /\ variables.length() = 2?
        relation_is_equation: _symbolic_dag_operation(_symbolic_clone(differential_equation)) = 13
        boundary: boundaries.0
        boundary_is_where: _symbolic_dag_operation(_symbolic_clone(boundary)) = 19
        value_constraint: boundary_value(_symbolic_clone(boundary))
        domain_constraint: boundary_domain(boundary)
        value_is_equation: _symbolic_dag_operation(_symbolic_clone(value_constraint)) = 13
        domain_is_relation: _symbolic_dag_operation(_symbolic_clone(domain_constraint)) = 13
        expected_application: at(dependent, [_symbolic_clone(variables.0), _symbolic_clone(variables.1)])
        application_matches: same(_symbolic_left(_symbolic_clone(value_constraint)), expected_application)
        boundary_result: _symbolic_right(value_constraint)
        normalized_boundary_result: _symbolic_reduce_under_equation(_symbolic_clone(boundary_result), _symbolic_clone(domain_constraint))
        expected_domain: equation(variables.0^2 + variables.1^2, 1)
        domain_matches: same(_symbolic_clone(domain_constraint), expected_domain)
        boundary_matches: _symbolic_unit_circle_boundary_matches(
            _symbolic_clone(solution),
            boundary_result,
            _symbolic_clone(variables.0),
            _symbolic_clone(variables.1)
        )
        first_domain: _symbolic_domain(_symbolic_clone(variables.0))
        second_domain: _symbolic_domain(_symbolic_clone(variables.1))
        continuous_variables: _symbolic_is_continuous_domain(first_domain) /\ _symbolic_is_continuous_domain(second_domain)
        harmonic_solution: _symbolic_harmonic_in_two_variables(_symbolic_clone(solution), _symbolic_clone(variables.0), _symbolic_clone(variables.1))
        relation_matches: _symbolic_geometric_pde_relation_matches(
            differential_equation,
            dependent,
            _symbolic_clone(variables.0),
            _symbolic_clone(variables.1)
        )
        @: relation_is_equation /\ boundary_is_where /\ value_is_equation /\ domain_is_relation /\ domain_matches /\ application_matches /\ boundary_matches /\ continuous_variables /\ harmonic_solution /\ relation_matches
    verified

solve_pde(
    differential_equation:symbolic,
    boundaries:[symbolic:n],
    dependent:symbolic,
    variables:[symbolic:m]
) -> symbolic:
    boundaries.length() != 1 \/ variables.length() != 2?
        errors.RuntimeError("native geometric PDE strategy requires one boundary and two variables")!
    first_variable: _symbolic_clone(variables.0)
    second_variable: _symbolic_clone(variables.1)
    relation_matches: _symbolic_geometric_pde_relation_matches(
        _symbolic_clone(differential_equation),
        _symbolic_clone(dependent),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable)
    )
    boundary: boundaries.0
    boundary_is_where: _symbolic_dag_operation(_symbolic_clone(boundary)) = 19
    value_constraint: boundary_value(_symbolic_clone(boundary))
    domain_constraint: boundary_domain(boundary)
    value_is_equation: _symbolic_dag_operation(_symbolic_clone(value_constraint)) = 13
    applied_value: _symbolic_left(_symbolic_clone(value_constraint))
    boundary_result: _symbolic_right(value_constraint)
    expected_application: at(dependent, [_symbolic_clone(first_variable), _symbolic_clone(second_variable)])
    application_matches: same(applied_value, expected_application)
    expected_domain: equation(first_variable^2 + second_variable^2, 1)
    domain_matches: same(_symbolic_clone(domain_constraint), expected_domain)
    normalized_boundary_result: _symbolic_reduce_under_equation(boundary_result, domain_constraint)
    harmonic_boundary: _symbolic_harmonic_in_two_variables(_symbolic_clone(normalized_boundary_result), _symbolic_clone(variables.0), _symbolic_clone(variables.1))
    quadratic_boundary: _symbolic_is_quadratic_in_two_variables(
        _symbolic_clone(normalized_boundary_result),
        _symbolic_clone(first_variable),
        _symbolic_clone(second_variable)
    )
    supported: relation_matches /\ boundary_is_where /\ value_is_equation /\ application_matches /\ domain_matches /\ (harmonic_boundary \/ quadratic_boundary)
    supported?
        candidate: simplify(normalized_boundary_result)
        ~harmonic_boundary?
            .candidate: _symbolic_unit_circle_quadratic_harmonic_extension(
                normalized_boundary_result,
                _symbolic_clone(first_variable),
                _symbolic_clone(second_variable)
            )
        verify_pde_solution(_symbolic_clone(candidate), _symbolic_clone(differential_equation), boundaries, dependent, variables)?
            @: candidate
        errors.RuntimeError("native symbolic PDE candidate failed residual or boundary verification")!
    errors.RuntimeError("native symbolic geometric PDE planner has no strategy for this problem")!

verify_heat_solution(solution:symbolic, space:symbolic, time:symbolic) -> bit:
    expected: sin(space) * exp(0 - time)
    same(solution, expected)

solve_recurrence(multiplier:num, offset:num, initial:num, index:symbolic) -> symbolic:
    multiplier = 1?
        @: initial + offset * index
    shift: offset / (multiplier - 1)
    scale: initial + shift
    scale * multiplier^index - shift

_symbolic_solve_second_order_recurrence(
    first_multiplier:num,
    second_multiplier:num,
    initial_zero:num,
    initial_one:num,
    index:symbolic
) -> symbolic:
    discriminant: first_multiplier^2 + 4 * second_multiplier
    real_part: 0
    imaginary_part: 0
    radius: 0
    angle: 0
    sine_denominator: 0
    cosine_scale: 0
    sine_scale: 0
    oscillation: constant(0)
    discriminant < 0?
        .real_part: first_multiplier / 2
        .imaginary_part: m.sqrt(0 - discriminant) / 2
        .radius: m.sqrt(real_part * real_part + imaginary_part * imaginary_part)
        .angle: m.atan2(imaginary_part, real_part)
        .sine_denominator: m.sin(angle)
        m.abs(radius) < 0.000000000001 \/ m.abs(sine_denominator) < 0.000000000001?
            errors.RuntimeError("native symbolic complex-root recurrence could not construct a stable real basis")!
        .cosine_scale: initial_zero
        .sine_scale: (initial_one / radius - initial_zero * m.cos(angle)) / sine_denominator
        .oscillation: _symbolic_add_simplified(
            _symbolic_multiply_simplified(
                constant(cosine_scale),
                cos(constant(angle) * _symbolic_clone(index))
            ),
            _symbolic_multiply_simplified(
                constant(sine_scale),
                sin(constant(angle) * _symbolic_clone(index))
            )
        )
        m.abs(radius - 1) < 0.000000000001?
            @: oscillation
        @: _symbolic_multiply_simplified(
            constant(radius)^index,
            oscillation
        )
    discriminant = 0?
        repeated_root: first_multiplier / 2
        repeated_root = 0?
            errors.RuntimeError("native symbolic zero repeated-root recurrence requires a finite-support strategy")!
        slope: initial_one / repeated_root - initial_zero
        affine: _symbolic_add_simplified(
            constant(initial_zero),
            _symbolic_multiply_simplified(constant(slope), _symbolic_clone(index))
        )
        repeated_root = 1?
            @: affine
        @: _symbolic_multiply_simplified(affine, constant(repeated_root)^index)
    root_delta: sqrt(_symbolic_raw_number(discriminant))
    first_root: (_symbolic_raw_number(first_multiplier) + _symbolic_clone(root_delta)) / 2
    second_root: (_symbolic_raw_number(first_multiplier) - root_delta) / 2
    first_scale: (_symbolic_raw_number(initial_one) - initial_zero * _symbolic_clone(second_root)) / (_symbolic_clone(first_root) - _symbolic_clone(second_root))
    second_scale: _symbolic_raw_number(initial_zero) - _symbolic_clone(first_scale)
    first_scale * first_root^index + second_scale * second_root^index

_symbolic_recurrence_application_matches(
    value:symbolic,
    dependent:symbolic,
    argument:symbolic
) -> bit:
    (_symbolic_dag_operation(_symbolic_clone(value)) = 18 /\
     same(_symbolic_left(_symbolic_clone(value)), dependent) /\
     same(_symbolic_right(value), argument))

_symbolic_recurrence_application_shift(
    value:symbolic,
    dependent:symbolic,
    index:symbolic
) -> num:
    ~(_symbolic_dag_operation(_symbolic_clone(value)) = 18)?
        @: -1
    ~same(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(dependent))?
        @: -1
    argument: _symbolic_right(value)
    same(_symbolic_clone(argument), _symbolic_clone(index))?
        @: 0
    ~(_symbolic_dag_operation(_symbolic_clone(argument)) = 3)?
        @: -1
    left: _symbolic_left(_symbolic_clone(argument))
    right: _symbolic_right(argument)
    same(_symbolic_clone(left), _symbolic_clone(index)) /\ _symbolic_root_kind(_symbolic_clone(right)) = 2?
        @: _symbolic_number_value(right)
    same(_symbolic_clone(right), index) /\ _symbolic_root_kind(_symbolic_clone(left)) = 2?
        @: _symbolic_number_value(left)
    -1

_symbolic_recurrence_linear_term(
    value:symbolic,
    dependent:symbolic,
    index:symbolic
):
    direct_shift: _symbolic_recurrence_application_shift(
        _symbolic_clone(value),
        _symbolic_clone(dependent),
        _symbolic_clone(index)
    )
    direct_shift >= 0?
        @: (valid:true, coefficient:1, shift:direct_shift)
    ~(_symbolic_dag_operation(_symbolic_clone(value)) = 5)?
        @: (valid:false, coefficient:0, shift:-1)
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_is_number: _symbolic_root_kind(_symbolic_clone(left)) = 2
    right_is_number: _symbolic_root_kind(_symbolic_clone(right)) = 2
    coefficient_value: _symbolic_clone(left)
    application: _symbolic_clone(right)
    right_is_number?
        .coefficient_value: _symbolic_clone(right)
        .application: _symbolic_clone(left)
    shift: _symbolic_recurrence_application_shift(application, dependent, index)
    (valid:(left_is_number \/ right_is_number) /\ shift >= 0,
     coefficient:_symbolic_number_value(coefficient_value),
     shift:shift)

_symbolic_recurrence_initial_constraint(value:symbolic, dependent:symbolic):
    is_equation: _symbolic_dag_operation(_symbolic_clone(value)) = 13
    application: _symbolic_left(_symbolic_clone(value))
    is_at: _symbolic_dag_operation(_symbolic_clone(application)) = 15
    target_matches: same(_symbolic_left(_symbolic_clone(application)), dependent)
    point: _symbolic_right(application)
    result: _symbolic_right(value)
    point_is_number: _symbolic_root_kind(_symbolic_clone(point)) = 2
    result_is_number: _symbolic_root_kind(_symbolic_clone(result)) = 2
    (valid:is_equation /\ is_at /\ target_matches /\ point_is_number /\ result_is_number,
     point:_symbolic_number_value(point),
     initial:_symbolic_number_value(result))

_symbolic_second_order_recurrence_problem(
    recurrence:symbolic,
    initial_conditions:[symbolic:2],
    dependent:symbolic,
    index:symbolic
):
    is_equation: _symbolic_dag_operation(_symbolic_clone(recurrence)) = 13
    relation_left: _symbolic_left(_symbolic_clone(recurrence))
    relation_right: _symbolic_right(recurrence)
    left_shift: _symbolic_recurrence_application_shift(
        _symbolic_clone(relation_left),
        _symbolic_clone(dependent),
        _symbolic_clone(index)
    )
    right_shift: _symbolic_recurrence_application_shift(
        _symbolic_clone(relation_right),
        _symbolic_clone(dependent),
        _symbolic_clone(index)
    )
    following_shift: left_shift
    right: _symbolic_clone(relation_right)
    right_shift = 2?
        .following_shift: right_shift
        .right: _symbolic_clone(relation_left)
    right_operation: _symbolic_dag_operation(_symbolic_clone(right))
    is_combination: right_operation = 3 \/ right_operation = 4
    first_term: _symbolic_recurrence_linear_term(
        _symbolic_left(_symbolic_clone(right)),
        _symbolic_clone(dependent),
        _symbolic_clone(index)
    )
    second_term: _symbolic_recurrence_linear_term(
        _symbolic_right(right),
        dependent,
        index
    )
    first_multiplier: 0
    second_multiplier: 0
    found_first: false
    found_second: false
    second_sign: 1
    right_operation = 4?
        .second_sign: -1
    first_term.shift = 1?
        .first_multiplier: first_term.coefficient
        .found_first: true
    first_term.shift = 0?
        .second_multiplier: first_term.coefficient
        .found_second: true
    second_term.shift = 1?
        .first_multiplier: second_sign * second_term.coefficient
        .found_first: true
    second_term.shift = 0?
        .second_multiplier: second_sign * second_term.coefficient
        .found_second: true
    first_condition: _symbolic_recurrence_initial_constraint(
        _symbolic_clone(initial_conditions.0),
        _symbolic_clone(dependent)
    )
    second_condition: _symbolic_recurrence_initial_constraint(
        initial_conditions.1,
        dependent
    )
    initial_zero: 0
    initial_one: 0
    found_zero: false
    found_one: false
    first_condition.point = 0?
        .initial_zero: first_condition.initial
        .found_zero: true
    first_condition.point = 1?
        .initial_one: first_condition.initial
        .found_one: true
    second_condition.point = 0?
        .initial_zero: second_condition.initial
        .found_zero: true
    second_condition.point = 1?
        .initial_one: second_condition.initial
        .found_one: true
    (valid:is_equation /\ following_shift = 2 /\ is_combination /\ first_term.valid /\ second_term.valid /\ found_first /\ found_second /\ first_condition.valid /\ second_condition.valid /\ found_zero /\ found_one,
     first_multiplier:first_multiplier,
     second_multiplier:second_multiplier,
     initial_zero:initial_zero,
     initial_one:initial_one)

_symbolic_solve_recurrence_unverified(
    recurrence:symbolic,
    initial_condition:symbolic,
    dependent:symbolic,
    index:symbolic
) -> symbolic:
    recurrence_is_equation: _symbolic_dag_operation(_symbolic_clone(recurrence)) = 13
    following: _symbolic_left(_symbolic_clone(recurrence))
    following_is_application: _symbolic_dag_operation(_symbolic_clone(following)) = 18
    following_target_matches: same(_symbolic_left(_symbolic_clone(following)), _symbolic_clone(dependent))
    shifted_index: _symbolic_right(following)
    shift_is_addition: _symbolic_dag_operation(_symbolic_clone(shifted_index)) = 3
    shift_left: _symbolic_left(_symbolic_clone(shifted_index))
    shift_right: _symbolic_right(shifted_index)
    shift_matches: (same(_symbolic_clone(shift_left), _symbolic_clone(index)) /\ _symbolic_is_raw_number(_symbolic_clone(shift_right), 1)) \/ (same(shift_right, _symbolic_clone(index)) /\ _symbolic_is_raw_number(shift_left, 1))

    affine: _symbolic_right(recurrence)
    affine_is_addition: _symbolic_dag_operation(_symbolic_clone(affine)) = 3
    affine_left: _symbolic_left(_symbolic_clone(affine))
    affine_right: _symbolic_right(affine)
    affine_left_is_number: _symbolic_root_kind(_symbolic_clone(affine_left)) = 2
    affine_right_is_number: _symbolic_root_kind(_symbolic_clone(affine_right)) = 2
    product: _symbolic_clone(affine_left)
    offset_value: _symbolic_clone(affine_right)
    affine_left_is_number?
        .product: _symbolic_clone(affine_right)
        .offset_value: _symbolic_clone(affine_left)
    product_is_multiplication: _symbolic_dag_operation(_symbolic_clone(product)) = 5
    product_left: _symbolic_left(_symbolic_clone(product))
    product_right: _symbolic_right(product)
    product_left_is_number: _symbolic_root_kind(_symbolic_clone(product_left)) = 2
    product_right_is_number: _symbolic_root_kind(_symbolic_clone(product_right)) = 2
    multiplier_value: _symbolic_clone(product_left)
    current_application: _symbolic_clone(product_right)
    product_right_is_number?
        .multiplier_value: _symbolic_clone(product_right)
        .current_application: _symbolic_clone(product_left)
    current_matches: _symbolic_recurrence_application_matches(current_application, _symbolic_clone(dependent), _symbolic_clone(index))

    condition_is_equation: _symbolic_dag_operation(_symbolic_clone(initial_condition)) = 13
    condition_application: _symbolic_left(_symbolic_clone(initial_condition))
    condition_is_at: _symbolic_dag_operation(_symbolic_clone(condition_application)) = 15
    condition_target_matches: same(_symbolic_left(_symbolic_clone(condition_application)), dependent)
    condition_at_zero: _symbolic_is_raw_number(_symbolic_right(condition_application), 0)
    initial_value: _symbolic_right(initial_condition)
    initial_is_number: _symbolic_root_kind(_symbolic_clone(initial_value)) = 2

    supported: recurrence_is_equation /\ following_is_application /\ following_target_matches /\ shift_is_addition /\ shift_matches /\ affine_is_addition /\ (affine_left_is_number \/ affine_right_is_number) /\ product_is_multiplication /\ (product_left_is_number \/ product_right_is_number) /\ current_matches /\ condition_is_equation /\ condition_is_at /\ condition_target_matches /\ condition_at_zero /\ initial_is_number
    supported?
        multiplier: _symbolic_number_value(multiplier_value)
        offset: _symbolic_number_value(offset_value)
        initial: _symbolic_number_value(initial_value)
        @: solve_recurrence(multiplier, offset, initial, index)
    errors.RuntimeError("native symbolic recurrence planner has no strategy for this problem")!

_symbolic_fourier_domains_match(time:symbolic, frequency:symbolic) -> bit:
    _symbolic_domain(time) = _symbolic_domain_real /\ _symbolic_domain(frequency) = _symbolic_domain_real

_symbolic_require_fourier_domains(time:symbolic, frequency:symbolic) -> bit:
    ~_symbolic_fourier_domains_match(time, frequency)?
        errors.TypeError("symbolic Fourier transform requires time and angular-frequency domains R")!
    true

_symbolic_square_of_variable_matches(value:symbolic, variable:symbolic) -> bit:
    ~(_symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 5)?
        @: false
    same(_symbolic_left(_symbolic_clone(value)), variable) /\ _symbolic_is_raw_number(_symbolic_right(value), 2)

_symbolic_gaussian_argument_width(argument:symbolic, variable:symbolic) -> num:
    operation: _symbolic_root_operation(_symbolic_clone(argument))
    _symbolic_root_kind(_symbolic_clone(argument)) = 3 /\ operation = 4?
        numerator: _symbolic_left(_symbolic_clone(argument))
        denominator: _symbolic_right(argument)
        _symbolic_root_kind(_symbolic_clone(denominator)) = 2?
            divisor: _symbolic_number_value(denominator)
            divisor > 0?
                @: _symbolic_gaussian_argument_width(numerator, variable) / divisor
        @: 0
    ~(_symbolic_root_kind(_symbolic_clone(argument)) = 3 /\ operation = 2)?
        @: 0
    negative_left: _symbolic_left(_symbolic_clone(argument))
    negative_term: _symbolic_right(argument)
    ~_symbolic_is_raw_number(negative_left, 0)?
        @: 0
    _symbolic_square_of_variable_matches(_symbolic_clone(negative_term), _symbolic_clone(variable))?
        @: 1
    ~(_symbolic_root_kind(_symbolic_clone(negative_term)) = 3 /\ _symbolic_root_operation(_symbolic_clone(negative_term)) = 3)?
        @: 0
    left: _symbolic_left(_symbolic_clone(negative_term))
    right: _symbolic_right(negative_term)
    _symbolic_root_kind(_symbolic_clone(left)) = 2 /\ _symbolic_square_of_variable_matches(_symbolic_clone(right), _symbolic_clone(variable))?
        width: _symbolic_number_value(left)
        width > 0? @: width
    _symbolic_root_kind(_symbolic_clone(right)) = 2 /\ _symbolic_square_of_variable_matches(left, variable)?
        width: _symbolic_number_value(right)
        width > 0? @: width
    0

_symbolic_gaussian_width(value:symbolic, variable:symbolic) -> num:
    ~(_symbolic_root_kind(_symbolic_clone(value)) = 7 /\ _symbolic_root_operation(_symbolic_clone(value)) = 5)?
        @: 0
    _symbolic_gaussian_argument_width(_symbolic_argument(value), variable)

fourier(value:symbolic, time:symbolic, frequency:symbolic) -> symbolic:
    _symbolic_require_fourier_domains(_symbolic_clone(time), _symbolic_clone(frequency))
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ operation = 1?
        left: fourier(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(time), _symbolic_clone(frequency))
        right: fourier(_symbolic_right(value), time, frequency)
        @: left + right
    kind = 3 /\ operation = 2?
        left: fourier(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(time), _symbolic_clone(frequency))
        right: fourier(_symbolic_right(value), time, frequency)
        @: left - right
    kind = 3 /\ operation = 3?
        left_factor: _symbolic_left(_symbolic_clone(value))
        right_factor: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left_factor), _symbolic_clone(time))?
            @: _symbolic_transform_scale(left_factor, fourier(right_factor, time, frequency))
        ~depends_on(_symbolic_clone(right_factor), _symbolic_clone(time))?
            @: _symbolic_transform_scale(right_factor, fourier(left_factor, time, frequency))
        errors.RuntimeError("native analytic Fourier product strategy requires a time-independent factor")!
    gaussian_width: _symbolic_gaussian_width(value, time)
    gaussian_width > 0?
        @: sqrt(constant(m.pi / gaussian_width)) * exp((0 - frequency^2) / (4 * gaussian_width))
    errors.RuntimeError("native analytic Fourier strategy is not implemented for this expression")!

_symbolic_fourier_source_supported(value:symbolic, time:symbolic) -> bit:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ (operation = 1 \/ operation = 2)?
        left_supported: _symbolic_fourier_source_supported(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(time)
        )
        right_supported: _symbolic_fourier_source_supported(
            _symbolic_right(value),
            time
        )
        @: left_supported /\ right_supported
    kind = 3 /\ operation = 3?
        left: _symbolic_left(_symbolic_clone(value))
        right: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left), _symbolic_clone(time))?
            @: _symbolic_fourier_source_supported(right, time)
        ~depends_on(_symbolic_clone(right), _symbolic_clone(time))?
            @: _symbolic_fourier_source_supported(left, time)
        @: false
    _symbolic_gaussian_width(value, time) > 0

_symbolic_fourier_verification_expected(
    value:symbolic,
    time:symbolic,
    frequency:symbolic
) -> symbolic:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ operation = 1?
        left: _symbolic_fourier_verification_expected(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(time),
            _symbolic_clone(frequency)
        )
        right: _symbolic_fourier_verification_expected(
            _symbolic_right(value), time, frequency
        )
        @: left + right
    kind = 3 /\ operation = 2?
        left: _symbolic_fourier_verification_expected(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(time),
            _symbolic_clone(frequency)
        )
        right: _symbolic_fourier_verification_expected(
            _symbolic_right(value), time, frequency
        )
        @: left - right
    kind = 3 /\ operation = 3?
        left_factor: _symbolic_left(_symbolic_clone(value))
        right_factor: _symbolic_right(value)
        ~depends_on(_symbolic_clone(left_factor), _symbolic_clone(time))?
            transformed: _symbolic_fourier_verification_expected(
                right_factor, time, frequency
            )
            @: _symbolic_transform_scale(left_factor, transformed)
        transformed: _symbolic_fourier_verification_expected(
            left_factor, time, frequency
        )
        @: _symbolic_transform_scale(right_factor, transformed)
    gaussian_width: _symbolic_gaussian_width(value, time)
    sqrt(constant(m.pi / gaussian_width)) * exp((0 - frequency^2) / (4 * gaussian_width))

verify_fourier(candidate:symbolic, value:symbolic, time:symbolic, frequency:symbolic) -> bit:
    ~_symbolic_fourier_domains_match(_symbolic_clone(time), _symbolic_clone(frequency))?
        @: false
    ~_symbolic_fourier_source_supported(_symbolic_clone(value), _symbolic_clone(time))?
        @: false
    expected: _symbolic_fourier_verification_expected(value, time, frequency)
    same(candidate, expected)

_symbolic_gaussian_spectral_width(value:symbolic, frequency:symbolic) -> num:
    direct: _symbolic_gaussian_width(_symbolic_clone(value), _symbolic_clone(frequency))
    direct > 0?
        @: direct
    ~(_symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 3)?
        @: 0
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_width: _symbolic_gaussian_width(_symbolic_clone(left), _symbolic_clone(frequency))
    right_width: _symbolic_gaussian_width(_symbolic_clone(right), _symbolic_clone(frequency))
    left_width > 0 /\ ~depends_on(_symbolic_clone(right), _symbolic_clone(frequency))?
        @: left_width
    right_width > 0 /\ ~depends_on(left, frequency)?
        @: right_width
    0

_symbolic_inverse_fourier_unverified(value:symbolic, frequency:symbolic, time:symbolic) -> symbolic:
    _symbolic_require_fourier_domains(_symbolic_clone(time), _symbolic_clone(frequency))
    spectral_width: _symbolic_gaussian_spectral_width(_symbolic_clone(value), _symbolic_clone(frequency))
    spectral_width <= 0?
        errors.RuntimeError("native analytic inverse Fourier strategy is not implemented for this expression")!
    source_width: 1 / (4 * spectral_width)
    source: exp(0 - time^2)
    ~(source_width = 1)?
        .source: exp(0 - source_width * time^2)
    expected: fourier(_symbolic_clone(source), _symbolic_clone(time), frequency)
    same(value, expected)?
        @: source
    errors.RuntimeError("native analytic inverse Fourier strategy is not implemented for this expression")!

verify_inverse_fourier(candidate:symbolic, value:symbolic, frequency:symbolic, time:symbolic) -> bit:
    ~_symbolic_fourier_domains_match(_symbolic_clone(time), _symbolic_clone(frequency))?
        @: false
    transformed: fourier(candidate, time, frequency)
    _symbolic_transform_equivalent(transformed, value)

inverse_fourier(value:symbolic, frequency:symbolic, time:symbolic) -> symbolic:
    candidate: _symbolic_inverse_fourier_unverified(
        _symbolic_clone(value),
        _symbolic_clone(frequency),
        _symbolic_clone(time)
    )
    verify_inverse_fourier(
        _symbolic_clone(candidate),
        value,
        frequency,
        time
    )?
        @: candidate
    errors.RuntimeError("native analytic inverse Fourier candidate failed forward-transform verification")!

fourier(values:[num:n]) -> [num]:
    num count: values.length()
    [num] spectrum: [0:1 + 2 * count]
    spectrum.0: count
    frequency: 0
    sample: 0
    angle: 0
    frequency < count?>
        .sample: 0
        sample < count?>
            .angle: -6.283185307179586 * frequency * sample / count
            spectrum.(1 + frequency): spectrum.(1 + frequency) + values.(sample) * m.cos(angle)
            spectrum.(1 + count + frequency): spectrum.(1 + count + frequency) + values.(sample) * m.sin(angle)
            .sample+: 1
        .frequency+: 1
    spectrum

_symbolic_validate_fourier_access(length:num, count:num, frequency:num) -> bit:
    count < 0?
        errors.ValueError("symbolic Fourier spectrum shape does not match its count header")!
    ~(count % 1 = 0)?
        errors.ValueError("symbolic Fourier spectrum shape does not match its count header")!
    length != 1 + 2 * count?
        errors.ValueError("symbolic Fourier spectrum shape does not match its count header")!
    frequency < 0?
        errors.ValueError("symbolic Fourier frequency is outside the spectrum")!
    ~(frequency % 1 = 0)?
        errors.ValueError("symbolic Fourier frequency must be an integer")!
    frequency >= count?
        errors.ValueError("symbolic Fourier frequency is outside the spectrum")!
    true

fourier_real(spectrum:[num], frequency:num) -> num:
    length: spectrum.length()
    length < 1?
        errors.ValueError("symbolic Fourier spectrum requires a count header")!
    count: spectrum.0
    _symbolic_validate_fourier_access(length, count, frequency)
    spectrum.(1 + frequency)

fourier_imag(spectrum:[num], frequency:num) -> num:
    length: spectrum.length()
    length < 1?
        errors.ValueError("symbolic Fourier spectrum requires a count header")!
    count: spectrum.0
    _symbolic_validate_fourier_access(length, count, frequency)
    spectrum.(1 + count + frequency)

_symbolic_numeric_vectors_close(left:[num], right:[num], tolerance:num) -> bit:
    tolerance < 0 \/ left.length() != right.length()?
        @: false
    index: 0
    squared_error: 0
    index < left.length()?>
        difference: left.(index) - right.(index)
        .squared_error+: difference * difference
        .index+: 1
    squared_error <= tolerance * tolerance

_symbolic_fourier_spectrum_shape_matches(spectrum:[num]) -> bit:
    spectrum.length() < 1?
        @: false
    count: spectrum.0
    count >= 0 /\ count % 1 = 0 /\ spectrum.length() = 1 + 2 * count

_symbolic_inverse_fourier_samples_unverified(spectrum:[num]) -> [num]:
    num count: spectrum.0
    [num] values: [0:count]
    sample: 0
    frequency: 0
    angle: 0
    sample < count?>
        .frequency: 0
        frequency < count?>
            .angle: 6.283185307179586 * frequency * sample / count
            values.(sample): values.(sample) + (
                spectrum.(1 + frequency) * m.cos(angle) -
                spectrum.(1 + count + frequency) * m.sin(angle)
            )
            .frequency+: 1
        values.(sample): values.(sample) / count
        .sample+: 1
    values

verify_inverse_fourier(candidate:[num], spectrum:[num], tolerance:num) -> bit:
    ~_symbolic_fourier_spectrum_shape_matches(spectrum)?
        @: false
    candidate.length() != spectrum.0?
        @: false
    reconstructed: fourier(candidate)
    _symbolic_numeric_vectors_close(reconstructed, spectrum, tolerance)

verify_inverse_fourier(candidate:[num], spectrum:[num]) -> bit:
    verify_inverse_fourier(candidate, spectrum, 0.000001)

inverse_fourier(spectrum:[num]) -> [num]:
    ~_symbolic_fourier_spectrum_shape_matches(spectrum)?
        errors.ValueError("symbolic inverse Fourier spectrum shape does not match its count header")!
    candidate: _symbolic_inverse_fourier_samples_unverified(spectrum)
    verify_inverse_fourier(candidate, spectrum)?
        @: candidate
    errors.RuntimeError("native sampled inverse Fourier candidate failed forward-transform verification")!

haar_wavelet(value:symbolic, variable:symbolic, scale:num, shift:num) -> symbolic:
    _symbolic_root_kind(_symbolic_clone(variable)) != 1 \/ _symbolic_domain(_symbolic_clone(variable)) != _symbolic_domain_real?
        errors.TypeError("analytic Haar wavelet requires a real symbol variable")!
    scale < 0 \/ ~(scale % 1 = 0)?
        errors.ValueError("analytic Haar wavelet scale must be a nonnegative integer")!
    width_count: 2^scale
    shift < 0 \/ ~(shift % 1 = 0) \/ shift >= width_count?
        errors.ValueError("analytic Haar wavelet shift is outside the selected scale")!
    width: 1 / width_count
    left: shift * width
    middle: left + width / 2
    right: left + width
    antiderivative: integrate(value, _symbolic_clone(variable))
    left_value: substitute(_symbolic_clone(antiderivative), _symbolic_clone(variable), left)
    middle_value: substitute(_symbolic_clone(antiderivative), _symbolic_clone(variable), middle)
    right_value: substitute(antiderivative, variable, right)
    normalization: m.sqrt(width_count)
    simplify(normalization * (2 * middle_value - left_value - right_value))

_symbolic_integral_source_supported(value:symbolic, variable:symbolic) -> bit:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    (kind = 4 \/ kind = 6 \/ kind = 1 \/ kind = 2)?
        @: true
    kind = 7?
        operation: _symbolic_root_operation(_symbolic_clone(value))
        argument: _symbolic_argument(value)
        @: same(argument, variable) /\ (operation = 1 \/ operation = 2 \/ operation = 3 \/ operation = 5)
    ~(kind = 3)?
        @: false
    operation: _symbolic_root_operation(_symbolic_clone(value))
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    (operation = 1 \/ operation = 2)?
        left_supported: _symbolic_integral_source_supported(
            _symbolic_clone(left),
            _symbolic_clone(variable)
        )
        right_supported: _symbolic_integral_source_supported(right, variable)
        @: left_supported /\ right_supported
    operation = 3?
        ~depends_on(_symbolic_clone(left), _symbolic_clone(variable))?
            @: _symbolic_integral_source_supported(right, variable)
        ~depends_on(_symbolic_clone(right), _symbolic_clone(variable))?
            @: _symbolic_integral_source_supported(left, variable)
        @: false
    operation = 4?
        @: ~depends_on(_symbolic_clone(left), _symbolic_clone(variable)) /\ same(right, variable)
    operation = 5?
        @: same(_symbolic_clone(left), _symbolic_clone(variable)) /\ _symbolic_root_kind(right) = 2
    false

_symbolic_haar_verification_expected(
    value:symbolic,
    variable:symbolic,
    scale:num,
    shift:num
) -> symbolic:
    width_count: 2^scale
    width: 1 / width_count
    left: shift * width
    middle: left + width / 2
    right: left + width
    antiderivative: integrate(value, _symbolic_clone(variable))
    left_value: substitute(
        _symbolic_clone(antiderivative), _symbolic_clone(variable), left
    )
    middle_value: substitute(
        _symbolic_clone(antiderivative), _symbolic_clone(variable), middle
    )
    right_value: substitute(antiderivative, variable, right)
    normalization: m.sqrt(width_count)
    simplify(normalization * (2 * middle_value - left_value - right_value))

verify_haar_wavelet(candidate:symbolic, value:symbolic, variable:symbolic, scale:num, shift:num) -> bit:
    _symbolic_root_kind(_symbolic_clone(variable)) != 1 \/ _symbolic_domain(_symbolic_clone(variable)) != _symbolic_domain_real?
        @: false
    scale < 0 \/ ~(scale % 1 = 0)?
        @: false
    width_count: 2^scale
    shift < 0 \/ ~(shift % 1 = 0) \/ shift >= width_count?
        @: false
    ~_symbolic_integral_source_supported(_symbolic_clone(value), _symbolic_clone(variable))?
        @: false
    expected: _symbolic_haar_verification_expected(value, variable, scale, shift)
    same(simplify(candidate), expected)

haar_wavelet(values:[num:n]) -> [num]:
    num count: values.length()
    width_check: 1
    width_check < count?>
        .width_check *: 2
    ~(width_check = count)?
        errors.ValueError("symbolic.haar_wavelet requires a power-of-two sample count")!
    [num] output: [..count - 1 >> values.($)]
    [num] temporary: [0:count]
    width: count
    half: 0
    index: 0
    width > 1?>
        .half: width / 2
        .index: 0
        index < half?>
            temporary.(index): (output.(2 * index) + output.(2 * index + 1)) / 2
            temporary.(half + index): (output.(2 * index) - output.(2 * index + 1)) / 2
            .index+: 1
        .index: 0
        index < width?>
            output.(index): temporary.(index)
            .index+: 1
        .width: half
    output

_symbolic_inverse_haar_wavelet_unverified(coefficients:[num]) -> [num]:
    num count: coefficients.length()
    count < 1?
        errors.ValueError("symbolic.inverse_haar_wavelet requires at least one coefficient")!
    [num] output: [..count - 1 >> coefficients.($)]
    [num] temporary: [0:count]
    width: 1
    index: 0
    width < count?>
        width * 2 > count?
            errors.ValueError("symbolic.inverse_haar_wavelet requires a power-of-two coefficient count")!
        .index: 0
        index < width?>
            temporary.(2 * index): output.(index) + output.(width + index)
            temporary.(2 * index + 1): output.(index) - output.(width + index)
            .index+: 1
        .index: 0
        index < 2 * width?>
            output.(index): temporary.(index)
            .index+: 1
        .width *: 2
    output

_symbolic_power_of_two_count(value:num) -> bit:
    value < 1 \/ value % 1 != 0?
        @: false
    width: 1
    width < value?>
        .width *: 2
    width = value

verify_inverse_haar_wavelet(
    candidate:[num],
    coefficients:[num],
    tolerance:num
) -> bit:
    ~_symbolic_power_of_two_count(coefficients.length())?
        @: false
    candidate.length() != coefficients.length()?
        @: false
    reconstructed: haar_wavelet(candidate)
    _symbolic_numeric_vectors_close(reconstructed, coefficients, tolerance)

verify_inverse_haar_wavelet(candidate:[num], coefficients:[num]) -> bit:
    verify_inverse_haar_wavelet(candidate, coefficients, 0.000000001)

inverse_haar_wavelet(coefficients:[num]) -> [num]:
    candidate: _symbolic_inverse_haar_wavelet_unverified(coefficients)
    verify_inverse_haar_wavelet(candidate, coefficients)?
        @: candidate
    errors.RuntimeError("native sampled inverse Haar candidate failed forward-transform verification")!

_symbolic_empty_solution_set(variable_count:num, method:num) -> symbolic:
    # Header: kind, solution count, variable count, verified, method.
    # The ordinary symbolic trailer keeps the representation opaque and owned.
    [num] result: [_symbolic_solution_set_kind, 0, variable_count, 0, method, _symbolic_solution_set_kind, 0, 8]
    result

solution_count(solutions:symbolic) -> num:
    _symbolic_storage_kind(solutions) != _symbolic_solution_set_kind?
        errors.ValueError("invalid symbolic solution set")!
    solutions.1

solution_verified(solutions:symbolic) -> bit:
    storage_kind: _symbolic_storage_kind(solutions)
    storage_kind != _symbolic_solution_set_kind /\
    storage_kind != _symbolic_solution_family_kind /\
    storage_kind != _symbolic_solution_branches_kind?
        errors.ValueError("invalid symbolic solution set")!
    solutions.3 = 1

_symbolic_solution_value_payload_end(solutions:symbolic) -> num:
    storage_kind: _symbolic_storage_kind(solutions)
    cursor: 5
    value_count: 0
    storage_kind = _symbolic_solution_set_kind?
        .value_count: solutions.1 * solutions.2
    storage_kind = _symbolic_solution_family_kind?
        .value_count: solutions.1 * (solutions.2 + 1)
    value_count = 0 /\ storage_kind != _symbolic_solution_set_kind /\
    storage_kind != _symbolic_solution_family_kind?
        errors.ValueError("symbolic value payload requires a solution set or family")!
    index: 0
    index < value_count?>
        .cursor+: 1 + solutions.(cursor)
        .index+: 1
    cursor

solution_condition_count(solutions:symbolic) -> num:
    storage_kind: _symbolic_storage_kind(solutions)
    storage_kind != _symbolic_solution_set_kind /\
    storage_kind != _symbolic_solution_family_kind?
        @: 0
    cursor: _symbolic_solution_value_payload_end(solutions)
    cursor >= solutions.length() - 3? @: 0
    solutions.(cursor)

solution_condition(solutions:symbolic, condition_index:num) -> relation:
    count: solution_condition_count(_symbolic_clone(solutions))
    condition_index < 0 \/ condition_index >= count?
        errors.IndexError("symbolic solution condition index is out of range")!
    cursor: _symbolic_solution_value_payload_end(solutions) + 1
    index: 0
    index < condition_index?>
        .cursor+: 1 + solutions.(cursor)
        .index+: 1
    condition_length: solutions.(cursor)
    start: cursor + 1
    [start..start + condition_length - 1 >> solutions.($)]

solution_is_branched(solutions:symbolic) -> bit:
    _symbolic_storage_kind(solutions) = _symbolic_solution_branches_kind

solution_branch_count(solutions:symbolic) -> num:
    ~solution_is_branched(_symbolic_clone(solutions))?
        errors.ValueError("symbolic solution is not branch-valued")!
    solutions.1

solution_branch(solutions:symbolic, branch_index:num) -> symbolic:
    count: solution_branch_count(_symbolic_clone(solutions))
    branch_index < 0 \/ branch_index >= count?
        errors.IndexError("symbolic solution branch index is out of range")!
    cursor: 5
    index: 0
    index < branch_index?>
        .cursor+: 1 + solutions.(cursor)
        .index+: 1
    branch_length: solutions.(cursor)
    start: cursor + 1
    [start..start + branch_length - 1 >> solutions.($)]

solution_is_family(solutions:symbolic) -> bit:
    _symbolic_storage_kind(solutions) = _symbolic_solution_family_kind

solution_family_dimension(solutions:symbolic) -> num:
    ~solution_is_family(_symbolic_clone(solutions))?
        errors.ValueError("symbolic solution is not an affine family")!
    solutions.2

_symbolic_solution_family_value(solutions:symbolic, flat_index:num) -> symbolic:
    cursor: 5
    index: 0
    index < flat_index?>
        .cursor+: solutions.(cursor) + 1
        .index+: 1
    value_length: solutions.(cursor)
    start: cursor + 1
    [start..start + value_length - 1 >> solutions.($)]

solution_particular_value(solutions:symbolic, variable_index:num) -> symbolic:
    ~solution_is_family(_symbolic_clone(solutions))?
        errors.ValueError("symbolic solution is not an affine family")!
    variable_count: solutions.1
    variable_index < 0 \/ variable_index >= variable_count?
        errors.IndexError("symbolic solution variable index is out of range")!
    _symbolic_solution_family_value(solutions, variable_index)

solution_direction_value(solutions:symbolic, direction_index:num, variable_index:num) -> symbolic:
    ~solution_is_family(_symbolic_clone(solutions))?
        errors.ValueError("symbolic solution is not an affine family")!
    variable_count: solutions.1
    dimension: solutions.2
    direction_index < 0 \/ direction_index >= dimension \/ variable_index < 0 \/ variable_index >= variable_count?
        errors.IndexError("symbolic solution direction index is out of range")!
    _symbolic_solution_family_value(solutions, variable_count + direction_index * variable_count + variable_index)

_symbolic_one_solution_set(value:symbolic, method:num) -> symbolic:
    num value_length: value.length()
    num total_length: 5 + 1 + value_length + 3
    [num] result: [0:total_length]
    result.0: _symbolic_solution_set_kind
    result.1: 1
    result.2: 1
    result.3: 0
    result.4: method
    result.5: value_length
    value_length > 0?
        ..value_length - 1 >> result.(6 + $): value.($)
    result.(total_length - 3): _symbolic_solution_set_kind
    result.(total_length - 2): 0
    result.(total_length - 1): total_length
    result

_symbolic_one_conditional_solution_set(
    value:symbolic,
    condition:relation,
    method:num
) -> symbolic:
    num value_length: value.length()
    num condition_length: condition.length()
    num total_length: 5 + 1 + value_length + 1 + 1 + condition_length + 3
    [num] result: [0:total_length]
    result.0: _symbolic_solution_set_kind
    result.1: 1
    result.2: 1
    result.3: 0
    result.4: method
    result.5: value_length
    value_length > 0?
        ..value_length - 1 >> result.(6 + $): value.($)
    condition_count_index: 6 + value_length
    result.(condition_count_index): 1
    result.(condition_count_index + 1): condition_length
    condition_length > 0?
        ..condition_length - 1 >> result.(condition_count_index + 2 + $): condition.($)
    result.(total_length - 3): _symbolic_solution_set_kind
    result.(total_length - 2): 0
    result.(total_length - 1): total_length
    result

_symbolic_append_solution_condition(
    solutions:symbolic,
    condition:relation
) -> symbolic:
    num payload_end: _symbolic_solution_value_payload_end(_symbolic_clone(solutions))
    num condition_count: solution_condition_count(_symbolic_clone(solutions))
    num old_trailer_start: solutions.length() - 3
    num condition_length: condition.length()
    num extra_count_field: 0
    condition_count = 0?
        .extra_count_field: 1
    num total_length: solutions.length() + 1 + condition_length + extra_count_field
    [num] result: [0:total_length]
    old_trailer_start > 0?
        ..old_trailer_start - 1 >>
            result.($): solutions.($)
    num cursor: old_trailer_start
    condition_count = 0?
        result.(payload_end): 1
        .cursor: payload_end + 1
    condition_count > 0?
        result.(payload_end): condition_count + 1
    result.(cursor): condition_length
    condition_length > 0?
        ..condition_length - 1 >>
            result.(cursor + 1 + $): condition.($)
    num trailer_start: cursor + 1 + condition_length
    result.(trailer_start): _symbolic_storage_kind(solutions)
    result.(trailer_start + 1): 0
    result.(trailer_start + 2): total_length
    result

_symbolic_two_solution_branches(
    first:symbolic,
    second:symbolic,
    method:num,
    verified:bit
) -> symbolic:
    num first_length: first.length()
    num second_length: second.length()
    num total_length: 5 + 1 + first_length + 1 + second_length + 3
    [num] result: [0:total_length]
    result.0: _symbolic_solution_branches_kind
    result.1: 2
    result.2: 0
    result.3: verified
    result.4: method
    result.5: first_length
    first_length > 0?
        ..first_length - 1 >> result.(6 + $): first.($)
    num second_length_index: 6 + first_length
    result.(second_length_index): second_length
    second_length > 0?
        ..second_length - 1 >> result.(second_length_index + 1 + $): second.($)
    result.(total_length - 3): _symbolic_solution_branches_kind
    result.(total_length - 2): 0
    result.(total_length - 1): total_length
    result

_symbolic_two_solution_set(first:symbolic, second:symbolic, method:num) -> symbolic:
    num first_length: first.length()
    num second_length: second.length()
    num total_length: 5 + 1 + first_length + 1 + second_length + 3
    [num] result: [0:total_length]
    result.0: _symbolic_solution_set_kind
    result.1: 2
    result.2: 1
    result.3: 0
    result.4: method
    cursor: 5
    result.(cursor): first_length
    .cursor+: 1
    first_length > 0?
        ..first_length - 1 >> result.(cursor + $): first.($)
    .cursor+: first_length
    result.(cursor): second_length
    .cursor+: 1
    second_length > 0?
        ..second_length - 1 >> result.(cursor + $): second.($)
    result.(total_length - 3): _symbolic_solution_set_kind
    result.(total_length - 2): 0
    result.(total_length - 1): total_length
    result

_symbolic_numeric_solution_set(
    values:[num],
    solution_count:num,
    variable_count:num,
    method:num
) -> symbolic:
    solution_count < 0 \/ solution_count % 1 != 0 \/
    variable_count < 1 \/ variable_count % 1 != 0 \/
    values.length() < solution_count * variable_count?
        errors.ValueError("symbolic numeric solution payload shape is invalid")!
    num total_length: 8
    index: 0
    index < solution_count * variable_count?>
        value: _symbolic_raw_number(values.(index))
        .total_length+: value.length() + 1
        .index+: 1
    [num] result: [0:total_length]
    result.0: _symbolic_solution_set_kind
    result.1: solution_count
    result.2: variable_count
    result.3: 0
    result.4: method
    cursor: 5
    encoded: _symbolic_raw_number(0)
    num value_length: 0
    .index: 0
    index < solution_count * variable_count?>
        .encoded: _symbolic_raw_number(values.(index))
        .value_length: encoded.length()
        result.(cursor): value_length
        .cursor+: 1
        value_length > 0?
            ..value_length - 1 >> result.(cursor + $): encoded.($)
        .cursor+: value_length
        .index+: 1
    result.(total_length - 3): _symbolic_solution_set_kind
    result.(total_length - 2): 0
    result.(total_length - 1): total_length
    result

_symbolic_one_numeric_vector_solution_set(values:[num], method:num) -> symbolic:
    _symbolic_numeric_solution_set(values, 1, values.length(), method)

_symbolic_affine_solution_family(particular:[num], directions:[num], dimension:num, method:num) -> symbolic:
    num variable_count: particular.length()
    num value_count: variable_count * (dimension + 1)
    num total_length: 8
    index: 0
    encoded: _symbolic_raw_number(0)
    source_value: 0
    num value_length: 0
    index < value_count?>
        .source_value: 0
        index < variable_count?
            .source_value: particular.(index)
        index >= variable_count?
            .source_value: directions.(index - variable_count)
        .encoded: _symbolic_raw_number(source_value)
        .total_length+: encoded.length() + 1
        .index+: 1
    [num] result: [0:total_length]
    result.0: _symbolic_solution_family_kind
    result.1: variable_count
    result.2: dimension
    result.3: 0
    result.4: method
    cursor: 5
    .index: 0
    index < value_count?>
        .source_value: 0
        index < variable_count?
            .source_value: particular.(index)
        index >= variable_count?
            .source_value: directions.(index - variable_count)
        .encoded: _symbolic_raw_number(source_value)
        .value_length: encoded.length()
        result.(cursor): value_length
        .cursor+: 1
        value_length > 0?
            ..value_length - 1 >> result.(cursor + $): encoded.($)
        .cursor+: value_length
        .index+: 1
    result.(total_length - 3): _symbolic_solution_family_kind
    result.(total_length - 2): 0
    result.(total_length - 1): total_length
    result

_symbolic_extended_gcd(left:num, right:num):
    old_remainder: m.abs(left)
    remainder: m.abs(right)
    old_left: 1
    next_left: 0
    old_right: 0
    next_right: 1
    quotient: 0
    temporary: 0
    remainder != 0?>
        .quotient: old_remainder // remainder
        .temporary: old_remainder - quotient * remainder
        .old_remainder: remainder
        .remainder: temporary
        .temporary: old_left - quotient * next_left
        .old_left: next_left
        .next_left: temporary
        .temporary: old_right - quotient * next_right
        .old_right: next_right
        .next_right: temporary
    left < 0?
        .old_left: 0 - old_left
    right < 0?
        .old_right: 0 - old_right
    (gcd:old_remainder, left:old_left, right:old_right)

_symbolic_two_variable_integer_family(a:num, b:num, c:num) -> symbolic:
    ~(a % 1 = 0 /\ b % 1 = 0 /\ c % 1 = 0)?
        errors.RuntimeError("native symbolic integer-lattice strategy requires integer coefficients")!
    a = 0 /\ b = 0?
        c != 0?
            empty: _symbolic_empty_solution_set(2, _symbolic_solution_method_polynomial)
            empty.3: 1
            @: empty
        [num] zero_particular: [0, 0]
        [num] full_lattice: [1, 0, 0, 1]
        all: _symbolic_affine_solution_family(
            zero_particular,
            full_lattice,
            2,
            _symbolic_solution_method_polynomial
        )
        all.3: 1
        @: all
    bezout: _symbolic_extended_gcd(a, b)
    c % bezout.gcd != 0?
        empty: _symbolic_empty_solution_set(2, _symbolic_solution_method_polynomial)
        empty.3: 1
        @: empty
    scale: c / bezout.gcd
    [num] particular: [bezout.left * scale, bezout.right * scale]
    [num] direction: [b / bezout.gcd, (0 - a) / bezout.gcd]
    verified: (
        particular.0 % 1 = 0 /\ particular.1 % 1 = 0 /\
        direction.0 % 1 = 0 /\ direction.1 % 1 = 0 /\
        a * particular.0 + b * particular.1 = c /\
        a * direction.0 + b * direction.1 = 0
    )
    family: _symbolic_affine_solution_family(
        particular,
        direction,
        1,
        _symbolic_solution_method_polynomial
    )
    family.3: verified
    family

solution_value(solutions:symbolic, solution_index:num, variable_index:num = 0) -> symbolic:
    count: solution_count(_symbolic_clone(solutions))
    variable_count: solutions.2
    invalid_index: solution_index < 0 \/ solution_index >= count \/ variable_index < 0 \/ variable_index >= variable_count
    invalid_index?
        errors.IndexError("symbolic solution index is out of range")!
    wanted: solution_index * variable_count + variable_index
    cursor: 5
    index: 0
    index < wanted?>
        .cursor+: solutions.(cursor) + 1
        .index+: 1
    value_length: solutions.(cursor)
    start: cursor + 1
    [start..start + value_length - 1 >> solutions.($)]

_symbolic_real_square_solution_set(equation_value:symbolic) -> symbolic:
    radicand: _symbolic_right(equation_value)
    radicand_kind: _symbolic_root_kind(_symbolic_clone(radicand))
    radicand_value: _symbolic_number_value(_symbolic_clone(radicand))
    radicand_kind = 2 /\ radicand_value < 0?
        @: _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)
    _symbolic_is_raw_number(_symbolic_clone(radicand), 0)?
        @: _symbolic_one_solution_set(radicand, _symbolic_solution_method_polynomial)
    positive: sqrt(_symbolic_clone(radicand))
    negative: -sqrt(radicand)
    _symbolic_two_solution_set(negative, positive, _symbolic_solution_method_polynomial)

_symbolic_complex_square_solution_set(equation_value:symbolic) -> symbolic:
    radicand: _symbolic_right(equation_value)
    _symbolic_is_raw_number(_symbolic_clone(radicand), 0)?
        @: _symbolic_one_solution_set(radicand, _symbolic_solution_method_polynomial)
    positive: sqrt(_symbolic_clone(radicand))
    negative: -sqrt(radicand)
    _symbolic_two_solution_set(negative, positive, _symbolic_solution_method_polynomial)

_symbolic_equation_residual(equation_value:symbolic) -> symbolic:
    left: _symbolic_left(_symbolic_clone(equation_value))
    right: _symbolic_right(equation_value)
    expand(left - right)

_symbolic_univariate_polynomial_degree(value:symbolic) -> num:
    terms: _symbolic_polynomial_term_count(value)
    degree: 0
    term: 0
    exponent: 0
    term < terms?>
        .exponent: _symbolic_polynomial_term_exponent(value, term, 0)
        exponent > degree?
            .degree: exponent
        .term+: 1
    degree

_symbolic_rational_asymptotic(value:symbolic, variable:symbolic) -> symbolic:
    numerator: expand(_symbolic_left(_symbolic_clone(value)))
    denominator: expand(_symbolic_right(value))
    numerator_degree: _symbolic_univariate_polynomial_degree(_symbolic_clone(numerator))
    denominator_degree: _symbolic_univariate_polynomial_degree(_symbolic_clone(denominator))
    numerator_leading: coefficient(numerator, [numerator_degree])
    denominator_leading: coefficient(denominator, [denominator_degree])
    denominator_leading = 0?
        errors.ValueError("symbolic asymptotic denominator must not be the zero polynomial")!
    scale: numerator_leading / denominator_leading
    order: numerator_degree - denominator_degree
    order = 0?
        @: _symbolic_raw_number(scale)
    order > 0?
        @: scale * variable^order
    scale / variable^(0 - order)

_symbolic_growth_leading_term(
    scale:num,
    order:num,
    exponential:num,
    logarithmic:num,
    variable:symbolic
) -> symbolic:
    result: _symbolic_raw_number(scale)
    exponential != 0?
        exponent: _symbolic_multiply_simplified(
            _symbolic_raw_number(exponential),
            _symbolic_clone(variable)
        )
        .result: _symbolic_multiply_simplified(result, exp(exponent))
    order != 0?
        polynomial: _symbolic_power_simplified(
            _symbolic_clone(variable),
            _symbolic_raw_number(order)
        )
        .result: _symbolic_multiply_simplified(result, polynomial)
    logarithmic != 0?
        logarithm: _symbolic_power_simplified(
            log(variable),
            _symbolic_raw_number(logarithmic)
        )
        .result: _symbolic_multiply_simplified(result, logarithm)
    result

asymptotic(value:symbolic, variable:symbolic) -> symbolic:
    ~(_symbolic_root_kind(_symbolic_clone(variable)) = 1)?
        errors.TypeError("symbolic.asymptotic variable must be a symbol")!
    ~(_symbolic_domain(_symbolic_clone(variable)) = _symbolic_domain_real)?
        errors.TypeError("symbolic asymptotics require a real variable")!
    growth: _symbolic_asymptotic_facts(_symbolic_clone(value), _symbolic_clone(variable))
    ~growth.valid?
        errors.RuntimeError("native symbolic asymptotic strategy is not implemented for this expression")!
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 3 /\ (operation = 1 \/ operation = 2)?
        left: _symbolic_left(_symbolic_clone(value))
        right: _symbolic_right(value)
        left_growth: _symbolic_asymptotic_facts(_symbolic_clone(left), _symbolic_clone(variable))
        right_growth: _symbolic_asymptotic_facts(_symbolic_clone(right), _symbolic_clone(variable))
        left_dominates: left_growth.exponential > right_growth.exponential \/ (left_growth.exponential = right_growth.exponential /\ left_growth.order > right_growth.order) \/ (left_growth.exponential = right_growth.exponential /\ left_growth.order = right_growth.order /\ left_growth.logarithmic > right_growth.logarithmic)
        right_dominates: right_growth.exponential > left_growth.exponential \/ (right_growth.exponential = left_growth.exponential /\ right_growth.order > left_growth.order) \/ (right_growth.exponential = left_growth.exponential /\ right_growth.order = left_growth.order /\ right_growth.logarithmic > left_growth.logarithmic)
        left_dominates?
            @: asymptotic(left, variable)
        right_dominates?
            dominant: asymptotic(right, variable)
            operation = 2?
                @: -dominant
            @: dominant
        @: _symbolic_growth_leading_term(
            growth.scale,
            growth.order,
            growth.exponential,
            growth.logarithmic,
            variable
        )
    growth.exponential != 0 \/ growth.logarithmic != 0?
        @: _symbolic_clone(value)
    output_variable: _symbolic_clone(variable)
    is_quotient: _symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 4
    is_quotient?
        @: _symbolic_rational_asymptotic(value, output_variable)
    polynomial_value: expand(value)
    degree: _symbolic_univariate_polynomial_degree(_symbolic_clone(polynomial_value))
    leading_coefficient: coefficient(polynomial_value, [degree])
    leading_power: _symbolic_power_simplified(
        output_variable,
        _symbolic_raw_number(degree)
    )
    _symbolic_multiply_simplified(
        _symbolic_raw_number(leading_coefficient),
        leading_power
    )

asymptotic(variable_name:chr, value:symbolic) -> symbolic:
    asymptotic(value, _symbolic_suffix_variable(value, variable_name))

_symbolic_polynomial_asymptotic_facts(value:symbolic, variable:symbolic):
    polynomial_value: expand(value)
    variable_count: _symbolic_polynomial_variable_count(_symbolic_clone(polynomial_value))
    degree: _symbolic_univariate_polynomial_degree(_symbolic_clone(polynomial_value))
    required_variable: degree = 0 \/ depends_on(_symbolic_clone(polynomial_value), variable)
    leading: coefficient(polynomial_value, [degree])
    (valid:variable_count <= 1 /\ required_variable, scale:leading, order:degree)

_symbolic_rational_asymptotic_facts(value:symbolic, variable:symbolic):
    numerator: _symbolic_polynomial_asymptotic_facts(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(variable))
    denominator: _symbolic_polynomial_asymptotic_facts(_symbolic_right(value), variable)
    valid: numerator.valid /\ denominator.valid /\ denominator.scale != 0
    ~valid?
        @: (valid:false, scale:0, order:0, exponential:0, logarithmic:0)
    (valid:true, scale:numerator.scale / denominator.scale, order:numerator.order - denominator.order, exponential:0, logarithmic:0)

_symbolic_growth_facts(value:symbolic, variable:symbolic):
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 1?
        same(value, variable)?
            @: (valid:true, scale:1, order:1, exponential:0, logarithmic:0)
        @: (valid:false, scale:0, order:0, exponential:0, logarithmic:0)
    kind = 2?
        @: (valid:true, scale:_symbolic_number_value(value), order:0, exponential:0, logarithmic:0)
    kind = 7 /\ operation = 5?
        exponential: _symbolic_heat_exponential_facts(value, variable)
        exponential.valid?
            @: (valid:true, scale:1, order:0, exponential:exponential.rate, logarithmic:0)
        @: (valid:false, scale:0, order:0, exponential:0, logarithmic:0)
    kind = 7 /\ operation = 3?
        same(_symbolic_argument(value), variable)?
            @: (valid:true, scale:1, order:0, exponential:0, logarithmic:1)
        @: (valid:false, scale:0, order:0, exponential:0, logarithmic:0)
    kind = 7?
        @: (valid:false, scale:0, order:0, exponential:0, logarithmic:0)
    kind = 3 /\ (operation = 1 \/ operation = 2)?
        left: _symbolic_growth_facts(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(variable))
        right: _symbolic_growth_facts(_symbolic_right(value), variable)
        ~(left.valid /\ right.valid)?
            @: (valid:false, scale:0, order:0, exponential:0, logarithmic:0)
        left_dominates: left.exponential > right.exponential \/ (left.exponential = right.exponential /\ left.order > right.order) \/ (left.exponential = right.exponential /\ left.order = right.order /\ left.logarithmic > right.logarithmic)
        right_dominates: right.exponential > left.exponential \/ (right.exponential = left.exponential /\ right.order > left.order) \/ (right.exponential = left.exponential /\ right.order = left.order /\ right.logarithmic > left.logarithmic)
        left_dominates?
            @: left
        right_dominates?
            operation = 2?
                @: (valid:true, scale:0 - right.scale, order:right.order, exponential:right.exponential, logarithmic:right.logarithmic)
            @: right
        combined_scale: left.scale + right.scale
        operation = 2?
            .combined_scale: left.scale - right.scale
        combined_scale = 0?
            @: (valid:false, scale:0, order:0, exponential:0, logarithmic:0)
        @: (valid:true, scale:combined_scale, order:left.order, exponential:left.exponential, logarithmic:left.logarithmic)
    kind = 3 /\ (operation = 3 \/ operation = 4)?
        left: _symbolic_growth_facts(_symbolic_left(_symbolic_clone(value)), _symbolic_clone(variable))
        right: _symbolic_growth_facts(_symbolic_right(value), variable)
        ~(left.valid /\ right.valid)?
            @: (valid:false, scale:0, order:0, exponential:0, logarithmic:0)
        operation = 3?
            @: (
                valid:true,
                scale:left.scale * right.scale,
                order:left.order + right.order,
                exponential:left.exponential + right.exponential,
                logarithmic:left.logarithmic + right.logarithmic
            )
        right.scale = 0?
            @: (valid:false, scale:0, order:0, exponential:0, logarithmic:0)
        @: (
            valid:true,
            scale:left.scale / right.scale,
            order:left.order - right.order,
            exponential:left.exponential - right.exponential,
            logarithmic:left.logarithmic - right.logarithmic
        )
    polynomial: _symbolic_polynomial_asymptotic_facts(value, variable)
    (
        valid:polynomial.valid,
        scale:polynomial.scale,
        order:polynomial.order,
        exponential:0,
        logarithmic:0
    )

_symbolic_asymptotic_facts(value:symbolic, variable:symbolic):
    _symbolic_growth_facts(simplify(value), variable)

verify_asymptotic(candidate:symbolic, value:symbolic, variable:symbolic) -> bit:
    source: _symbolic_asymptotic_facts(value, _symbolic_clone(variable))
    proposed: _symbolic_asymptotic_facts(candidate, variable)
    (source.valid /\ proposed.valid /\
     source.exponential = proposed.exponential /\
     source.order = proposed.order /\
     source.logarithmic = proposed.logarithmic /\
     source.scale = proposed.scale)

_symbolic_is_linear_equation(equation_value:symbolic, variable:symbolic) -> bit:
    residual: _symbolic_equation_residual(equation_value)
    is_polynomial: _symbolic_storage_kind(_symbolic_clone(residual)) = 4
    variable_count: _symbolic_polynomial_variable_count(_symbolic_clone(residual))
    degree: _symbolic_univariate_polynomial_degree(_symbolic_clone(residual))
    linear_coefficient: coefficient(_symbolic_clone(residual), [1])
    has_variable: depends_on(residual, variable)
    is_polynomial /\ variable_count = 1 /\ degree = 1 /\ linear_coefficient != 0 /\ has_variable

_symbolic_is_quadratic_equation(equation_value:symbolic, variable:symbolic) -> bit:
    residual: _symbolic_equation_residual(equation_value)
    is_polynomial: _symbolic_storage_kind(_symbolic_clone(residual)) = 4
    variable_count: _symbolic_polynomial_variable_count(_symbolic_clone(residual))
    degree: _symbolic_univariate_polynomial_degree(_symbolic_clone(residual))
    quadratic_coefficient: coefficient(_symbolic_clone(residual), [2])
    has_variable: depends_on(residual, variable)
    (is_polynomial /\ variable_count = 1 /\ degree = 2 /\
     quadratic_coefficient != 0 /\ has_variable)

_symbolic_numeric_root_in_domain(root:num, domain:num) -> bit:
    domain??
        _symbolic_domain_natural => root % 1 = 0 /\ root >= 0
        _symbolic_domain_integer => root % 1 = 0
        _symbolic_domain_rational => true
        _symbolic_domain_real => true
        _symbolic_domain_complex => true
        false

_symbolic_canonical_numeric_root(root:num) -> num:
    fraction: root % 1
    m.abs(fraction) < 0.000000001?
        @: root - fraction
    fraction > 0 /\ m.abs(fraction - 1) < 0.000000001?
        @: root + 1 - fraction
    fraction < 0 /\ m.abs(fraction + 1) < 0.000000001?
        @: root - 1 - fraction
    root

_symbolic_linear_solution_set(equation_value:symbolic, domain:num) -> symbolic:
    residual: _symbolic_equation_residual(equation_value)
    linear_coefficient: coefficient(_symbolic_clone(residual), [1])
    constant_value: coefficient(residual, [0])
    root: (0 - constant_value) / linear_coefficient
    domain = _symbolic_domain_rational?
        exact_root: _symbolic_raw_number(0 - constant_value) / _symbolic_raw_number(linear_coefficient)
        @: _symbolic_one_solution_set(exact_root, _symbolic_solution_method_polynomial)
    admissible: _symbolic_numeric_root_in_domain(root, domain)
    admissible?
        @: _symbolic_one_solution_set(_symbolic_raw_number(root), _symbolic_solution_method_polynomial)
    _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)

_symbolic_quadratic_exact_root(numerator:num, denominator:num) -> symbolic:
    quotient: numerator / denominator
    quotient % 1 = 0?
        @: _symbolic_raw_number(quotient)
    gcd_result: _symbolic_extended_gcd(numerator, denominator)
    divisor: gcd_result.gcd
    reduced_numerator: numerator / divisor
    reduced_denominator: denominator / divisor
    reduced_denominator < 0?
        .reduced_numerator: 0 - reduced_numerator
        .reduced_denominator: 0 - reduced_denominator
    (_symbolic_raw_number(reduced_numerator) /
     _symbolic_raw_number(reduced_denominator))

_symbolic_quadratic_radical_root(
    linear_coefficient:num,
    discriminant:num,
    denominator:num,
    positive:bit
) -> symbolic:
    base: _symbolic_raw_number(0 - linear_coefficient)
    radical: sqrt(_symbolic_raw_number(discriminant))
    numerator: _symbolic_clone(base) - _symbolic_clone(radical)
    positive?
        .numerator: base + radical
    numerator / _symbolic_raw_number(denominator)

_symbolic_linear_root_multiset(
    equation_value:symbolic,
    variable:symbolic
) -> {num}:
    residual: _symbolic_equation_residual(equation_value)
    linear: coefficient(_symbolic_clone(residual), [1])
    constant_value: coefficient(residual, [0])
    root: _symbolic_canonical_numeric_root(
        (0 - constant_value) / linear
    )
    _symbolic_numeric_root_in_domain(root, _symbolic_domain(variable))?
        @: {[root] >> $}
    [num] no_roots: []
    {no_roots >> $}

_symbolic_quadratic_root_multiset(
    equation_value:symbolic,
    variable:symbolic
) -> {num}:
    ~_symbolic_is_quadratic_equation(
        _symbolic_clone(equation_value), _symbolic_clone(variable)
    )?
        errors.TypeError("symbolic.roots currently requires a univariate quadratic equation")!
    residual: _symbolic_equation_residual(equation_value)
    quadratic: coefficient(_symbolic_clone(residual), [2])
    linear: coefficient(_symbolic_clone(residual), [1])
    constant_value: coefficient(residual, [0])
    discriminant: linear * linear - 4 * quadratic * constant_value
    domain: _symbolic_domain(variable)
    discriminant < 0?
        domain = _symbolic_domain_complex?
            errors.TypeError(
                "symbolic.roots cannot place complex roots in a numeric multiset"
            )!
        [num] no_roots: []
        @: {no_roots >> $}
    square_root: m.sqrt(discriminant)
    denominator: 2 * quadratic
    first: _symbolic_canonical_numeric_root(
        ((0 - linear) - square_root) / denominator
    )
    second: _symbolic_canonical_numeric_root(
        ((0 - linear) + square_root) / denominator
    )
    first_admissible: _symbolic_numeric_root_in_domain(first, domain)
    second_admissible: _symbolic_numeric_root_in_domain(second, domain)
    first_admissible /\ second_admissible?
        @: {[first, second] >> $}
    first_admissible?
        @: {[first] >> $}
    second_admissible?
        @: {[second] >> $}
    [num] no_roots: []
    {no_roots >> $}

roots(equation_value:symbolic, variable:symbolic) -> {num}:
    linear: _symbolic_is_linear_equation(
        _symbolic_clone(equation_value), _symbolic_clone(variable)
    )
    linear?
        @: _symbolic_linear_root_multiset(equation_value, variable)
    quadratic: _symbolic_is_quadratic_equation(
        _symbolic_clone(equation_value), _symbolic_clone(variable)
    )
    quadratic?
        @: _symbolic_quadratic_root_multiset(equation_value, variable)
    errors.TypeError(
        "symbolic.roots currently requires a univariate linear or quadratic equation"
    )!

roots(variable_name:chr, equation_value:symbolic) -> {num}:
    roots(equation_value, _symbolic_suffix_variable(equation_value, variable_name))

_symbolic_quadratic_solution_set(equation_value:symbolic, domain:num) -> symbolic:
    residual: _symbolic_equation_residual(equation_value)
    quadratic: coefficient(_symbolic_clone(residual), [2])
    linear: coefficient(_symbolic_clone(residual), [1])
    constant_value: coefficient(residual, [0])
    discriminant: linear * linear - 4 * quadratic * constant_value
    denominator: 2 * quadratic

    discriminant < 0?
        domain != _symbolic_domain_complex?
            @: _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)
        negative: _symbolic_quadratic_radical_root(
            linear, discriminant, denominator, false
        )
        positive: _symbolic_quadratic_radical_root(
            linear, discriminant, denominator, true
        )
        @: _symbolic_two_solution_set(
            negative, positive, _symbolic_solution_method_polynomial
        )

    square_root: m.sqrt(discriminant)
    canonical_square_root: _symbolic_canonical_numeric_root(square_root)
    exact_square: m.abs(square_root - canonical_square_root) < 0.000000001
    rational_square: discriminant % 1 = 0 /\ canonical_square_root % 1 = 0
    domain = _symbolic_domain_rational /\ ~(exact_square /\ rational_square)?
        @: _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)

    minus_value: _symbolic_canonical_numeric_root(
        ((0 - linear) - square_root) / denominator
    )
    plus_value: _symbolic_canonical_numeric_root(
        ((0 - linear) + square_root) / denominator
    )
    first_value: minus_value
    second_value: plus_value
    minus_first: minus_value <= plus_value
    ~minus_first?
        .first_value: plus_value
        .second_value: minus_value

    discriminant = 0?
        _symbolic_numeric_root_in_domain(first_value, domain)?
            domain = _symbolic_domain_rational?
                exact_repeated: _symbolic_quadratic_exact_root(
                    0 - linear, denominator
                )
                @: _symbolic_one_solution_set(
                    exact_repeated, _symbolic_solution_method_polynomial
                )
            @: _symbolic_one_solution_set(
                _symbolic_raw_number(first_value),
                _symbolic_solution_method_polynomial
            )
        @: _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)

    first_admissible: _symbolic_numeric_root_in_domain(first_value, domain)
    second_admissible: _symbolic_numeric_root_in_domain(second_value, domain)
    ~(first_admissible \/ second_admissible)?
        @: _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)

    first_root: _symbolic_raw_number(first_value)
    second_root: _symbolic_raw_number(second_value)
    domain = _symbolic_domain_rational?
        minus_numerator: (0 - linear) - canonical_square_root
        plus_numerator: (0 - linear) + canonical_square_root
        .first_root: _symbolic_quadratic_exact_root(
            minus_numerator, denominator
        )
        .second_root: _symbolic_quadratic_exact_root(
            plus_numerator, denominator
        )
        ~minus_first?
            .first_root: _symbolic_quadratic_exact_root(
                plus_numerator, denominator
            )
            .second_root: _symbolic_quadratic_exact_root(
                minus_numerator, denominator
            )
    (domain = _symbolic_domain_real \/ domain = _symbolic_domain_complex) /\ ~exact_square?
        .first_root: _symbolic_quadratic_radical_root(
            linear, discriminant, denominator, ~minus_first
        )
        .second_root: _symbolic_quadratic_radical_root(
            linear, discriminant, denominator, minus_first
        )

    first_admissible /\ second_admissible?
        @: _symbolic_two_solution_set(
            first_root, second_root, _symbolic_solution_method_polynomial
        )
    first_admissible?
        @: _symbolic_one_solution_set(
            first_root, _symbolic_solution_method_polynomial
        )
    _symbolic_one_solution_set(second_root, _symbolic_solution_method_polynomial)

_symbolic_integer_square_solution_set(equation_value:symbolic) -> symbolic:
    right: _symbolic_right(equation_value)
    value: _symbolic_number_value(right)
    value < 0?
        @: _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)
    root: m.sqrt(value)
    root % 1 != 0?
        @: _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)
    root = 0?
        @: _symbolic_one_solution_set(_symbolic_raw_number(0), _symbolic_solution_method_polynomial)
    negative: _symbolic_raw_number(0 - root)
    positive: _symbolic_raw_number(root)
    _symbolic_two_solution_set(negative, positive, _symbolic_solution_method_polynomial)

_symbolic_natural_square_solution_set(equation_value:symbolic) -> symbolic:
    right: _symbolic_right(equation_value)
    value: _symbolic_number_value(right)
    value < 0?
        @: _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)
    root: m.sqrt(value)
    root % 1 != 0?
        @: _symbolic_empty_solution_set(1, _symbolic_solution_method_polynomial)
    _symbolic_one_solution_set(_symbolic_raw_number(root), _symbolic_solution_method_polynomial)

_symbolic_square_domain_strategy(domain:num) -> num:
    domain??
        _symbolic_domain_natural => 3
        _symbolic_domain_integer => 1
        _symbolic_domain_rational => 1
        _symbolic_domain_real => 2
        _symbolic_domain_complex => 4
        0

_symbolic_is_square_equation(equation_value:symbolic, variable:symbolic) -> bit:
    is_dag: _symbolic_storage_kind(_symbolic_clone(equation_value)) = 10
    root: _symbolic_dag_root(_symbolic_clone(equation_value))
    is_equation: _symbolic_dag_node_operation(_symbolic_clone(equation_value), root) = 13
    left: _symbolic_left(equation_value)
    is_power: _symbolic_root_kind(_symbolic_clone(left)) = 3
    is_square: _symbolic_root_operation(_symbolic_clone(left)) = 5
    base: _symbolic_left(_symbolic_clone(left))
    exponent: _symbolic_right(left)
    base_matches: same(base, variable)
    exponent_is_two: _symbolic_is_raw_number(exponent, 2)
    is_dag /\ is_equation /\ is_power /\ is_square /\ base_matches /\ exponent_is_two

_symbolic_integer_square_equation_has_roots(equation_value:symbolic) -> bit:
    right: _symbolic_right(equation_value)
    _symbolic_root_kind(_symbolic_clone(right)) != 2?
        @: false
    value: _symbolic_number_value(right)
    value < 0?
        @: false
    root: m.sqrt(value)
    root % 1 = 0

_symbolic_solve_unverified(equation_value:symbolic, variables:[symbolic:n]) -> symbolic:
    variables.length() != 1?
        errors.RuntimeError("native symbolic systems are not implemented yet")!
    variable: variables.0
    domain: _symbolic_domain(_symbolic_clone(variable))
    square_equation: _symbolic_is_square_equation(_symbolic_clone(equation_value), _symbolic_clone(variable))
    quadratic_equation: _symbolic_is_quadratic_equation(
        _symbolic_clone(equation_value), _symbolic_clone(variable)
    )
    linear_equation: _symbolic_is_linear_equation(_symbolic_clone(equation_value), variable)
    strategy: _symbolic_square_domain_strategy(domain)
    integer_equation: _symbolic_clone(equation_value)
    real_equation: _symbolic_clone(equation_value)
    natural_equation: _symbolic_clone(equation_value)
    complex_equation: _symbolic_clone(equation_value)
    quadratic_value: _symbolic_clone(equation_value)
    linear_value: _symbolic_clone(equation_value)
    square_equation /\ strategy = 1?
        @: _symbolic_integer_square_solution_set(integer_equation)
    square_equation /\ strategy = 2?
        @: _symbolic_real_square_solution_set(real_equation)
    square_equation /\ strategy = 3?
        @: _symbolic_natural_square_solution_set(natural_equation)
    square_equation /\ strategy = 4?
        @: _symbolic_complex_square_solution_set(complex_equation)
    quadratic_equation?
        @: _symbolic_quadratic_solution_set(quadratic_value, domain)
    linear_equation?
        @: _symbolic_linear_solution_set(linear_value, domain)
    errors.RuntimeError("native symbolic domain is not implemented for this solve form")!

_symbolic_candidate_satisfies(equation_value:symbolic, variable:symbolic, candidate:symbolic) -> bit:
    candidate_kind: _symbolic_root_kind(_symbolic_clone(candidate))
    candidate_kind = 2?
        residual: _symbolic_equation_residual(equation_value)
        value: _symbolic_number_value(candidate)
        @: evaluate(residual, [value]) = 0
    exact_quotient: candidate_kind = 3 /\ _symbolic_root_operation(_symbolic_clone(candidate)) = 4 /\ _symbolic_catalog_variable_count(_symbolic_catalog(_symbolic_clone(candidate))) = 0
    exact_quotient?
        [num] no_variables: []
        value: evaluate(candidate, no_variables)
        residual: _symbolic_equation_residual(equation_value)
        @: evaluate(residual, [value]) = 0
    square_equation: _symbolic_is_square_equation(_symbolic_clone(equation_value), variable)
    square_equation?
        right: _symbolic_right(equation_value)
        positive: sqrt(_symbolic_clone(right))
        negative: -sqrt(right)
        @: same(_symbolic_clone(candidate), positive) \/ same(candidate, negative)
    false

_symbolic_solution_set_satisfies(equation_value:symbolic, variable:symbolic, solutions:symbolic) -> bit:
    count: solution_count(_symbolic_clone(solutions))
    verified: true
    index: 0
    index < count?>
        candidate: solution_value(_symbolic_clone(solutions), index)
        candidate_verified: _symbolic_candidate_satisfies(
            _symbolic_clone(equation_value),
            _symbolic_clone(variable),
            candidate
        )
        ~candidate_verified?
            .verified: false
        .index+: 1
    verified

solve(equation_value:symbolic, variables:[symbolic:n]) -> symbolic:
    variables.length() != 1?
        errors.RuntimeError("native symbolic systems are not implemented yet")!
    verification_equation: _symbolic_clone(equation_value)
    verification_variable: _symbolic_clone(variables.0)
    solutions: _symbolic_solve_unverified(equation_value, variables)
    verified: _symbolic_solution_set_satisfies(verification_equation, verification_variable, _symbolic_clone(solutions))
    solutions.3: verified
    solutions

_symbolic_linear_coefficient_for(value:symbolic, variable:symbolic) -> num:
    catalog: _symbolic_catalog(value)
    target: _symbolic_catalog_entry_index(catalog, _symbolic_raw_catalog(variable))
    target < 0?
        @: 0
    exponents: [0:_symbolic_polynomial_variable_count(value)]
    exponents.(target): 1
    coefficient(value, exponents)

_symbolic_linear_constant(value:symbolic) -> num:
    coefficient(value, [0:_symbolic_polynomial_variable_count(value)])

_symbolic_numeric_zero(value:symbolic) -> num:
    0

_symbolic_repeat_numeric_row(
    value:symbolic,
    row:[num:v]
) -> [num:v]:
    row

_symbolic_linear_target(equation_value:symbolic) -> num:
    0 - _symbolic_linear_constant(
        _symbolic_equation_residual(_symbolic_clone(equation_value))
    )

_symbolic_canonical_numeric_vector(values:[num:n]) -> [num]:
    [num] result: []
    values.length() > 0?
        ..values.length() - 1 >>
            .result: result & [_symbolic_canonical_numeric_root(values.($))]
    result

_symbolic_unexpanded_equation_residual(equation_value:symbolic) -> symbolic:
    simplify(
        _symbolic_left(_symbolic_clone(equation_value)) -
        _symbolic_right(equation_value)
    )

_symbolic_solution_satisfies_equation(
    solutions:symbolic,
    solution_index:num,
    equation_value:symbolic,
    variables:[symbolic:v]
) -> bit:
    residual: _symbolic_unexpanded_equation_residual(equation_value)
    variable_index: 0
    variable_index < variables.length()?>
        candidate: solution_value(
            _symbolic_clone(solutions),
            solution_index,
            variable_index
        )
        .residual: simplify(substitute(
            residual,
            _symbolic_clone(variables.(variable_index)),
            candidate
        ))
        .variable_index+: 1
    _symbolic_is_raw_number(residual, 0)

_symbolic_solution_value_in_domain(candidate:symbolic, variable:symbolic) -> bit:
    catalog: _symbolic_catalog(_symbolic_clone(candidate))
    _symbolic_catalog_variable_count(catalog) != 0?
        @: false
    [num] no_variables: []
    _symbolic_numeric_root_in_domain(
        evaluate(candidate, no_variables),
        _symbolic_domain(variable)
    )

verify_solutions(
    solutions:symbolic,
    equations:[symbolic:e],
    variables:[symbolic:v]
) -> bit:
    _symbolic_storage_kind(_symbolic_clone(solutions)) != _symbolic_solution_set_kind?
        @: false
    solutions.2 != variables.length()?
        @: false
    verified: true
    solution_index: 0
    equation_index: 0
    variable_index: 0
    solution_index < solution_count(_symbolic_clone(solutions))?>
        .variable_index: 0
        verified /\ variable_index < variables.length()?>
            candidate: solution_value(
                _symbolic_clone(solutions),
                solution_index,
                variable_index
            )
            ~_symbolic_solution_value_in_domain(
                candidate,
                _symbolic_clone(variables.(variable_index))
            )?
                .verified: false
            .variable_index+: 1
        .equation_index: 0
        verified /\ equation_index < equations.length()?>
            ~_symbolic_solution_satisfies_equation(
                _symbolic_clone(solutions),
                solution_index,
                _symbolic_clone(equations.(equation_index)),
                variables
            )?
                .verified: false
            .equation_index+: 1
        .solution_index+: 1
    verified

_symbolic_parameter_triangular_roots(
    equations:[symbolic:e],
    variables:[symbolic:v]
) -> (solved:bit,verified:bit,roots:[num:v]):
    roots: _symbolic_numeric_zero(variables)
    solved_variables: roots * 0
    num variable_count: variables.length()
    num equation_count: equations.length()
    solved_count: 0
    progress: true
    row: 0
    variable_index: 0
    remaining: 0
    remaining_index: 0
    candidate: _symbolic_raw_number(0)
    coefficient_value: _symbolic_raw_number(0)
    constant_value: _symbolic_raw_number(0)
    numeric_coefficient: 0
    numeric_constant: 0
    numeric_root: 0
    progress /\ solved_count < variable_count?>
        .progress: false
        .row: 0
        row < equation_count?>
            .candidate: _symbolic_unexpanded_equation_residual(
                _symbolic_clone(equations.(row))
            )
            .variable_index: 0
            variable_index < variable_count?>
                solved_variables.(variable_index) = 1?
                    .candidate: simplify(substitute(
                        candidate,
                        _symbolic_clone(variables.(variable_index)),
                        roots.(variable_index)
                    ))
                .variable_index+: 1
            .remaining: 0
            .remaining_index: 0
            .variable_index: 0
            variable_index < variable_count?>
                solved_variables.(variable_index) = 0 /\ depends_on(
                    _symbolic_clone(candidate),
                    _symbolic_clone(variables.(variable_index))
                )?
                    .remaining+: 1
                    .remaining_index: variable_index
                .variable_index+: 1
            remaining = 1?
                .coefficient_value: simplify(differentiate(
                    _symbolic_clone(candidate),
                    _symbolic_clone(variables.(remaining_index)),
                    true
                ))
                .constant_value: simplify(substitute(
                    candidate,
                    _symbolic_clone(variables.(remaining_index)),
                    0
                ))
                _symbolic_root_kind(_symbolic_clone(coefficient_value)) = 2 /\
                _symbolic_root_kind(_symbolic_clone(constant_value)) = 2?
                    .numeric_coefficient: _symbolic_number_value(coefficient_value)
                    .numeric_constant: _symbolic_number_value(constant_value)
                    numeric_coefficient != 0?
                        .numeric_root: _symbolic_canonical_numeric_root(
                            (0 - numeric_constant) / numeric_coefficient
                        )
                        roots.(remaining_index): numeric_root
                        solved_variables.(remaining_index): 1
                        .solved_count+: 1
                        .progress: true
            .row+: 1

    verified: solved_count = variable_count
    verified?
        .row: 0
        row < equation_count?>
            .candidate: _symbolic_unexpanded_equation_residual(
                _symbolic_clone(equations.(row))
            )
            .variable_index: 0
            variable_index < variable_count?>
                .candidate: simplify(substitute(
                    candidate,
                    _symbolic_clone(variables.(variable_index)),
                    roots.(variable_index)
                ))
                .variable_index+: 1
            ~_symbolic_is_raw_number(candidate, 0)?
                .verified: false
            .row+: 1
    (solved:solved_count = variable_count, verified:verified, roots:roots)

_symbolic_polynomial_is_linear(value:symbolic) -> bit:
    variable_count: _symbolic_polynomial_variable_count(_symbolic_clone(value))
    terms: _symbolic_polynomial_term_count(_symbolic_clone(value))
    term: 0
    variable: 0
    total_degree: 0
    maximum_degree: 0
    term < terms?>
        .total_degree: 0
        .variable: 0
        variable < variable_count?>
            .total_degree+: _symbolic_polynomial_term_exponent(_symbolic_clone(value), term, variable)
            .variable+: 1
        total_degree > maximum_degree?
            .maximum_degree: total_degree
        .term+: 1
    maximum_degree <= 1

_symbolic_affine_elimination_numeric_system(
    equations:[symbolic:e],
    variables:[symbolic:v]
) -> (handled:bit,has_solution:bit,verified:bit,solution_count:num,values:[num]):
    equation_count: equations.length()
    variable_count: variables.length()
    handled: equation_count = 2 /\ variable_count = 2
    linear_row: 0 - 1
    nonlinear_row: 0 - 1
    row: 0
    [num] values: [0:0]
    handled /\ row < equation_count?>
        residual: _symbolic_equation_residual(
            _symbolic_clone(equations.(row))
        )
        _symbolic_polynomial_is_linear(_symbolic_clone(residual))?
            linear_row >= 0?
                .handled: false
            linear_row < 0?
                .linear_row: row
        ~_symbolic_polynomial_is_linear(residual)?
            nonlinear_row >= 0?
                .handled: false
            nonlinear_row < 0?
                .nonlinear_row: row
        .row+: 1
    linear_row < 0 \/ nonlinear_row < 0?
        .handled: false
    ~handled?
        @: (handled:false, has_solution:false, verified:false,
            solution_count:0, values:values)
    first_variable_index: 0
    second_variable_index: 1
    linear_residual: _symbolic_equation_residual(
        _symbolic_clone(equations.(linear_row))
    )
    first_coefficient: _symbolic_linear_coefficient_for(
        _symbolic_clone(linear_residual),
        _symbolic_clone(variables.(first_variable_index))
    )
    second_coefficient: _symbolic_linear_coefficient_for(
        _symbolic_clone(linear_residual),
        _symbolic_clone(variables.(second_variable_index))
    )
    eliminated_index: 1
    remaining_index: 0
    eliminated_coefficient: second_coefficient
    remaining_coefficient: first_coefficient
    second_coefficient = 0?
        .eliminated_index: 0
        .remaining_index: 1
        .eliminated_coefficient: first_coefficient
        .remaining_coefficient: second_coefficient
    eliminated_coefficient = 0?
        @: (handled:false, has_solution:false, verified:false,
            solution_count:0, values:values)
    target: 0 - _symbolic_linear_constant(linear_residual)
    eliminated_expression: (
        _symbolic_raw_number(target / eliminated_coefficient) -
        _symbolic_raw_number(remaining_coefficient / eliminated_coefficient) *
            _symbolic_clone(variables.(remaining_index))
    )
    nonlinear_residual: _symbolic_unexpanded_equation_residual(
        _symbolic_clone(equations.(nonlinear_row))
    )
    substituted_residual: substitute(
        nonlinear_residual,
        _symbolic_clone(variables.(eliminated_index)),
        _symbolic_clone(eliminated_expression)
    )
    reduced_equation: equation(substituted_residual, 0)
    reduced_solutions: solve(
        reduced_equation,
        [_symbolic_clone(variables.(remaining_index))]
    )
    candidate_count: solution_count(_symbolic_clone(reduced_solutions))
    candidate_count > 2?
        @: (handled:false, has_solution:false, verified:false,
            solution_count:0, values:values)
    .values: [0:int(candidate_count * 2)]

    verified: solution_verified(_symbolic_clone(reduced_solutions))
    accepted_count: 0
    candidate_index: 0
    candidate_value: 0
    eliminated_value: 0
    candidate_index < candidate_count?>
        candidate: solution_value(
            _symbolic_clone(reduced_solutions), candidate_index
        )
        candidate_catalog: _symbolic_catalog(_symbolic_clone(candidate))
        _symbolic_catalog_variable_count(candidate_catalog) != 0?
            @: (handled:false, has_solution:false, verified:false,
                solution_count:0, values:values)
        [num] candidate_inputs: []
        .candidate_value: _symbolic_canonical_numeric_root(
            evaluate(candidate, candidate_inputs)
        )
        eliminated_candidate: simplify(substitute(
            _symbolic_clone(eliminated_expression),
            _symbolic_clone(variables.(remaining_index)),
            candidate_value
        ))
        [num] eliminated_inputs: []
        .eliminated_value: _symbolic_canonical_numeric_root(
            evaluate(eliminated_candidate, eliminated_inputs)
        )
        eliminated_domain: _symbolic_domain(
            _symbolic_clone(variables.(eliminated_index))
        )
        remaining_domain: _symbolic_domain(
            _symbolic_clone(variables.(remaining_index))
        )
        admissible: (
            _symbolic_numeric_root_in_domain(eliminated_value, eliminated_domain) /\
            _symbolic_numeric_root_in_domain(candidate_value, remaining_domain)
        )
        admissible?
            first_value: candidate_value
            second_value: eliminated_value
            eliminated_index = 0?
                .first_value: eliminated_value
                .second_value: candidate_value
            values.(accepted_count * 2): first_value
            values.(accepted_count * 2 + 1): second_value
            .accepted_count+: 1
        .candidate_index+: 1

    .candidate_index: 0
    candidate_index < accepted_count?>
        .row: 0
        row < equation_count?>
            verification_residual: _symbolic_unexpanded_equation_residual(
                _symbolic_clone(equations.(row))
            )
            .verification_residual: simplify(substitute(
                verification_residual,
                _symbolic_clone(variables.(first_variable_index)),
                values.(candidate_index * 2)
            ))
            .verification_residual: simplify(substitute(
                verification_residual,
                _symbolic_clone(variables.(second_variable_index)),
                values.(candidate_index * 2 + 1)
            ))
            ~_symbolic_is_raw_number(verification_residual, 0)?
                .verified: false
            .row+: 1
        .candidate_index+: 1

    (handled:true, has_solution:accepted_count > 0, verified:verified,
     solution_count:accepted_count, values:values)

_symbolic_separable_numeric_system(
    equations:[symbolic:e],
    variables:[symbolic:v]
) -> (handled:bit,has_solution:bit,verified:bit,solution_count:num,values:[num]):
    variable_count: variables.length()
    equation_count: equations.length()
    first_roots: _symbolic_numeric_zero(variables)
    second_roots: first_roots * 0
    candidate_counts: first_roots * 0
    solved_variables: first_roots * 0
    [num] values: [0:0]
    handled: equation_count = variable_count
    has_solution: true
    verified: true
    num solution_count: 0
    num row: 0
    num solution_index: 0
    num combination: 0
    num divisor: 1
    num choice: 0
    num selected: 0
    num variable_index: 0
    num candidate_index: 0
    num dependency_count: 0
    num dependent_variable: 0
    dependency_source: _symbolic_raw_number(0)
    handled /\ row < equation_count?>
        .dependency_count: 0
        .dependent_variable: 0
        .dependency_source: _symbolic_unexpanded_equation_residual(
            _symbolic_clone(equations.(row))
        )
        .variable_index: 0
        variable_index < variable_count?>
            depends_on(
                _symbolic_clone(dependency_source),
                _symbolic_clone(variables.(variable_index))
            )?
                .dependency_count+: 1
                .dependent_variable: variable_index
            .variable_index+: 1
        dependency_count != 1 \/ solved_variables.(dependent_variable) = 1?
            .handled: false
        handled?
            candidate_solutions: solve(
                _symbolic_clone(equations.(row)),
                [_symbolic_clone(variables.(dependent_variable))]
            )
            candidate_count: solution_count(_symbolic_clone(candidate_solutions))
            candidate_count = 0?
                .has_solution: false
                ~solution_verified(candidate_solutions)?
                    .verified: false
            candidate_count > 2?
                .handled: false
            .candidate_index: 0
            handled /\ candidate_index < candidate_count?>
                candidate: solution_value(
                    _symbolic_clone(candidate_solutions),
                    candidate_index
                )
                _symbolic_root_kind(_symbolic_clone(candidate)) != 2?
                    .handled: false
                handled?
                    numeric_root: _symbolic_canonical_numeric_root(
                        _symbolic_number_value(candidate)
                    )
                    candidate_index = 0?
                        first_roots.(dependent_variable): numeric_root
                    candidate_index = 1?
                        second_roots.(dependent_variable): numeric_root
                .candidate_index+: 1
            candidate_counts.(dependent_variable): candidate_count
            ~solution_verified(candidate_solutions)?
                .verified: false
            solved_variables.(dependent_variable): 1
        .row+: 1

    handled?
        .variable_index: 0
        variable_index < variable_count?>
            solved_variables.(variable_index) != 1?
                .handled: false
            .variable_index+: 1

    handled /\ has_solution?
        .solution_count: 1
        .variable_index: 0
        variable_index < variable_count?>
            .solution_count *: candidate_counts.(variable_index)
            .variable_index+: 1

        .values: [0:int(solution_count * variable_count)]

        .combination: 0
        combination < solution_count?>
            .divisor: 1
            .variable_index: 0
            variable_index < variable_count?>
                .choice: (combination // divisor) % candidate_counts.(variable_index)
                .selected: first_roots.(variable_index)
                choice = 1?
                    .selected: second_roots.(variable_index)
                values.(combination * variable_count + variable_index): selected
                .divisor *: candidate_counts.(variable_index)
                .variable_index+: 1
            .combination+: 1

        .solution_index: 0
        solution_index < solution_count?>
            .row: 0
            row < equation_count?>
                residual: _symbolic_unexpanded_equation_residual(
                    _symbolic_clone(equations.(row))
                )
                .variable_index: 0
                variable_index < variable_count?>
                    .residual: simplify(substitute(
                        residual,
                        _symbolic_clone(variables.(variable_index)),
                        values.(solution_index * variable_count + variable_index)
                    ))
                    .variable_index+: 1
                ~_symbolic_is_raw_number(residual, 0)?
                    .verified: false
                .row+: 1
            .solution_index+: 1
        @: (handled:handled, has_solution:has_solution, verified:verified,
            solution_count:solution_count, values:values)
    (handled:handled, has_solution:has_solution, verified:verified,
     solution_count:solution_count, values:values)

_symbolic_polynomial_pair_coefficient(
    value:symbolic,
    first:symbolic,
    first_exponent:num,
    second:symbolic,
    second_exponent:num
) -> num:
    catalog: _symbolic_catalog(_symbolic_clone(value))
    first_index: _symbolic_catalog_entry_index(
        _symbolic_clone_numeric_vector(catalog),
        _symbolic_raw_catalog(first)
    )
    second_index: _symbolic_catalog_entry_index(
        catalog,
        _symbolic_raw_catalog(second)
    )
    first_index < 0 \/ second_index < 0 \/ first_index = second_index?
        @: 0
    exponents: [0:_symbolic_polynomial_variable_count(_symbolic_clone(value))]
    exponents.(first_index): first_exponent
    exponents.(second_index): second_exponent
    coefficient(value, exponents)

_symbolic_integer_sum_of_squares_points(
    target:num,
    first_nonnegative:bit,
    second_nonnegative:bit
) -> (solution_count:num,values:[num]):
    bound: m.sqrt(target) // 1
    diameter: 2 * bound + 1
    [num] values: [0:int(diameter * diameter * 2)]
    num solution_count: 0
    candidate_x: 0 - bound
    candidate_y: 0 - bound
    first_nonnegative?
        .candidate_x: 0
    candidate_x <= bound?>
        .candidate_y: 0 - bound
        second_nonnegative?
            .candidate_y: 0
        candidate_y <= bound?>
            candidate_x * candidate_x + candidate_y * candidate_y = target?
                values.(solution_count * 2): candidate_x
                values.(solution_count * 2 + 1): candidate_y
                .solution_count+: 1
            .candidate_y+: 1
        .candidate_x+: 1
    (solution_count:solution_count, values:values)

_symbolic_integer_sum_of_squares_system(
    equations:[symbolic:e],
    variables:[symbolic:v]
) -> (handled:bit,has_solution:bit,verified:bit,solution_count:num,values:[num]):
    [num] values: [0:0]
    handled: equations.length() = 1 /\ variables.length() = 2
    verified: true
    num solution_count: 0
    ~handled?
        @: (handled:false, has_solution:false, verified:true,
            solution_count:0, values:values)

    equation_index: 0
    first_variable_index: 0
    second_variable_index: 1
    first_variable: _symbolic_clone(variables.(first_variable_index))
    second_variable: _symbolic_clone(variables.(second_variable_index))
    first_domain: _symbolic_domain(_symbolic_clone(first_variable))
    second_domain: _symbolic_domain(_symbolic_clone(second_variable))
    lattice_domains: (
        _symbolic_is_discrete_domain(first_domain) /\
        _symbolic_is_discrete_domain(second_domain)
    )
    ~lattice_domains?
        @: (handled:false, has_solution:false, verified:true,
            solution_count:0, values:values)

    residual: _symbolic_equation_residual(
        _symbolic_clone(equations.(equation_index))
    )
    polynomial: _symbolic_storage_kind(_symbolic_clone(residual)) = 4
    quadratic_terms: _symbolic_polynomial_pair_coefficient(
        _symbolic_clone(residual),
        _symbolic_clone(first_variable), 2,
        _symbolic_clone(second_variable), 0
    ) = 1 /\ _symbolic_polynomial_pair_coefficient(
        _symbolic_clone(residual),
        _symbolic_clone(first_variable), 0,
        _symbolic_clone(second_variable), 2
    ) = 1
    constant_value: _symbolic_linear_constant(_symbolic_clone(residual))
    expected_terms: 2
    constant_value != 0?
        .expected_terms+: 1
    .handled: (
        polynomial /\ _symbolic_polynomial_variable_count(_symbolic_clone(residual)) = 2 /\
        quadratic_terms /\
        _symbolic_polynomial_term_count(_symbolic_clone(residual)) = expected_terms
    )
    ~handled?
        @: (handled:false, has_solution:false, verified:true,
            solution_count:0, values:values)

    target: 0 - constant_value
    target < 0 \/ target % 1 != 0?
        @: (handled:true, has_solution:false, verified:true,
            solution_count:0, values:values)
    points: _symbolic_integer_sum_of_squares_points(
        target,
        first_domain = _symbolic_domain_natural,
        second_domain = _symbolic_domain_natural
    )
    (handled:true, has_solution:points.solution_count > 0, verified:verified,
     solution_count:points.solution_count, values:points.values)

solve(equations:[symbolic:e], variables:[symbolic:v]) -> symbolic:
    num count: variables.length()
    num equation_count: equations.length()
    count = 0 \/ equation_count = 0?
        errors.ValueError("symbolic.solve requires nonempty equations and variables")!
    num width: count + 1
    [num] matrix: [0:equation_count * width]
    row: 0
    column: 0
    residual: _symbolic_raw_number(0)
    linear_system: true
    [num] equation_catalog: []
    [num] catalog_entry: []
    source_variable_count: 0
    source_variable: 0
    declared_variable: 0
    declared: false
    constant_parameter_present: false
    row < equation_count?>
        .residual: _symbolic_equation_residual(_symbolic_clone(equations.(row)))
        ~_symbolic_polynomial_is_linear(_symbolic_clone(residual))?
            .linear_system: false
        .equation_catalog: _symbolic_catalog(_symbolic_clone(residual))
        .source_variable_count: _symbolic_polynomial_variable_count(_symbolic_clone(residual))
        .source_variable: 0
        source_variable < source_variable_count?>
            .catalog_entry: _symbolic_catalog_entry(equation_catalog, source_variable)
            .declared: false
            .declared_variable: 0
            declared_variable < count?>
                _symbolic_catalog_identity_same(_symbolic_clone_numeric_vector(catalog_entry), _symbolic_raw_catalog(variables.(declared_variable)))?
                    .declared: true
                .declared_variable+: 1
            ~declared?
                catalog_entry.2 = 3?
                    .constant_parameter_present: true
                catalog_entry.2 != 3?
                    .linear_system: false
            .source_variable+: 1
        .column: 0
        column < count?>
            matrix.(row * width + column): _symbolic_linear_coefficient_for(
                _symbolic_clone(residual),
                _symbolic_clone(variables.(column))
            )
            .column+: 1
        matrix.(row * width + count): 0 - _symbolic_linear_constant(residual)
        .row+: 1

    constant_parameter_present?
        triangular: _symbolic_parameter_triangular_roots(equations, variables)
        triangular.solved?
            [num] triangular_roots: _symbolic_canonical_numeric_vector(triangular.roots)
            triangular_admissible: true
            triangular_domain: _symbolic_domain_real
            .row: 0
            row < count?>
                .triangular_domain: _symbolic_domain(_symbolic_clone(variables.(row)))
                ~_symbolic_numeric_root_in_domain(
                    triangular_roots.(row),
                    triangular_domain
                )?
                    .triangular_admissible: false
                .row+: 1
            ~triangular_admissible?
                triangular_empty: _symbolic_empty_solution_set(
                    count,
                    _symbolic_solution_method_polynomial
                )
                triangular_empty.3: triangular.verified
                @: triangular_empty
            triangular_solutions: _symbolic_one_numeric_vector_solution_set(
                triangular_roots,
                _symbolic_solution_method_polynomial
            )
            triangular_solutions.3: triangular.verified
            @: triangular_solutions
        count = 1 /\ equation_count = 1 /\
        _symbolic_is_continuous_domain(_symbolic_domain(_symbolic_clone(variables.0)))?
            exact_variable: _symbolic_clone(variables.0)
            exact_residual: _symbolic_unexpanded_equation_residual(
                _symbolic_clone(equations.0)
            )
            exact_coefficient: simplify(differentiate(
                _symbolic_clone(exact_residual),
                _symbolic_clone(exact_variable),
                true
            ))
            exact_second_derivative: simplify(differentiate(
                _symbolic_clone(exact_coefficient),
                _symbolic_clone(exact_variable),
                true
            ))
            exact_constant: simplify(substitute(
                exact_residual,
                _symbolic_clone(exact_variable),
                0
            ))
            exact_linear: (
                _symbolic_is_raw_number(exact_second_derivative, 0) /\
                ~depends_on(_symbolic_clone(exact_coefficient), _symbolic_clone(exact_variable)) /\
                ~depends_on(_symbolic_clone(exact_constant), exact_variable)
            )
            coefficient_is_numeric_zero: (
                _symbolic_root_kind(_symbolic_clone(exact_coefficient)) = 2 /\
                _symbolic_number_value(_symbolic_clone(exact_coefficient)) = 0
            )
            constant_is_numeric: _symbolic_root_kind(_symbolic_clone(exact_constant)) = 2
            exact_linear /\ ~coefficient_is_numeric_zero /\ constant_is_numeric?
                _symbolic_is_raw_number(_symbolic_clone(exact_constant), 0)?
                    nonzero_root: _symbolic_one_conditional_solution_set(
                        _symbolic_raw_number(0),
                        not_equal(_symbolic_clone(exact_coefficient), 0),
                        _symbolic_solution_method_polynomial
                    )
                    nonzero_root.3: 1
                    [num] zero_particular: [0]
                    [num] full_direction: [1]
                    zero_family: _symbolic_affine_solution_family(
                        zero_particular,
                        full_direction,
                        1,
                        _symbolic_solution_method_polynomial
                    )
                    zero_family.3: 1
                    zero_branch: _symbolic_append_solution_condition(
                        zero_family,
                        equation(exact_coefficient, 0)
                    )
                    @: _symbolic_two_solution_branches(
                        nonzero_root,
                        zero_branch,
                        _symbolic_solution_method_polynomial,
                        true
                    )
                exact_root: simplify((0 - exact_constant) / _symbolic_clone(exact_coefficient))
                exact_condition: not_equal(exact_coefficient, 0)
                conditional: _symbolic_one_conditional_solution_set(
                    exact_root,
                    exact_condition,
                    _symbolic_solution_method_polynomial
                )
                # The derivative is independent of the unknown and the value at
                # zero supplies the exact constant term.  The recorded nonzero
                # condition therefore proves the division used by this root.
                conditional.3: 1
                @: conditional
        errors.RuntimeError(
            "native symbolic exact linear strategy requires a provably nonzero pivot or an explicit condition"
        )!

    ~linear_system?
        integer_points: _symbolic_integer_sum_of_squares_system(
            equations, variables
        )
        integer_points.handled?
            ~integer_points.has_solution?
                integer_empty: _symbolic_empty_solution_set(
                    count,
                    _symbolic_solution_method_polynomial
                )
                integer_empty.3: integer_points.verified
                @: integer_empty
            integer_solutions: _symbolic_numeric_solution_set(
                _symbolic_canonical_numeric_vector(integer_points.values),
                integer_points.solution_count,
                count,
                _symbolic_solution_method_polynomial
            )
            integer_solutions.3: verify_solutions(
                _symbolic_clone(integer_solutions),
                equations,
                variables
            )
            @: integer_solutions
        separable: _symbolic_separable_numeric_system(equations, variables)
        separable.handled?
            ~separable.has_solution?
                separable_empty: _symbolic_empty_solution_set(
                    count,
                    _symbolic_solution_method_polynomial
                )
                separable_empty.3: separable.verified
                @: separable_empty
            separable_solutions: _symbolic_numeric_solution_set(
                _symbolic_canonical_numeric_vector(separable.values),
                separable.solution_count,
                count,
                _symbolic_solution_method_polynomial
            )
            separable_solutions.3: verify_solutions(
                _symbolic_clone(separable_solutions),
                equations,
                variables
            )
            @: separable_solutions
        affine: _symbolic_affine_elimination_numeric_system(
            equations, variables
        )
        affine.handled?
            ~affine.has_solution?
                affine_empty: _symbolic_empty_solution_set(
                    count,
                    _symbolic_solution_method_polynomial
                )
                affine_empty.3: affine.verified
                @: affine_empty
            affine_solutions: _symbolic_numeric_solution_set(
                _symbolic_canonical_numeric_vector(affine.values),
                affine.solution_count,
                count,
                _symbolic_solution_method_polynomial
            )
            affine_solutions.3: verify_solutions(
                _symbolic_clone(affine_solutions),
                equations,
                variables
            )
            @: affine_solutions
        errors.RuntimeError("native symbolic system planner has no nonlinear-system strategy for this problem")!

    integer_variable_count: 0
    .row: 0
    row < count?>
        _symbolic_domain(_symbolic_clone(variables.(row))) = _symbolic_domain_integer?
            .integer_variable_count+: 1
        .row+: 1
    integer_pair: (
        equation_count = 1 /\ count = 2 /\
        integer_variable_count = 2
    )
    integer_pair?
        @: _symbolic_two_variable_integer_family(matrix.0, matrix.1, matrix.2)

    zero_row: _symbolic_numeric_zero(variables)
    [[num:v]:e] coefficient_matrix: _symbolic_repeat_numeric_row(equations, zero_row)
    .row: 0
    row < equation_count?>
        .column: 0
        column < count?>
            coefficient_matrix.(row, column): matrix.(row * width + column)
            .column+: 1
        .row+: 1
    [num:e] targets: _symbolic_linear_target(equations)
    space: linalg.solution_space(coefficient_matrix, targets)
    all_directions: space.directions
    particular_values: space.particular
    [num] canonical_particular: _symbolic_canonical_numeric_vector(particular_values)
    domain: _symbolic_domain_real
    ~space.consistent?
        empty: _symbolic_empty_solution_set(count, _symbolic_solution_method_polynomial)
        empty.3: 1
        @: empty
    ~space.unique?
        family_domain_supported: true
        .row: 0
        row < count?>
            .domain: _symbolic_domain(_symbolic_clone(variables.(row)))
            domain < _symbolic_domain_rational?
                .family_domain_supported: false
            .row+: 1
        ~family_domain_supported?
            errors.RuntimeError("native symbolic integer solution families require an integer-lattice strategy")!
        [num] family_directions: [0:space.nullity * count]
        zero_targets: targets * 0
        family_verified: linalg.relative_residual(
            coefficient_matrix,
            canonical_particular,
            targets
        ) < 0.000000001
        space.nullity > 0?
            ..space.nullity - 1 >>
                direction_index: $
                direction_values: all_directions.(direction_index)
                linalg.relative_residual(
                    coefficient_matrix,
                    direction_values,
                    zero_targets
                ) >= 0.000000001?
                    .family_verified: false
                ..count - 1 >>
                    family_directions.(direction_index * count + $): (
                        _symbolic_canonical_numeric_root(direction_values.($))
                    )
        family: _symbolic_affine_solution_family(
            canonical_particular,
            family_directions,
            space.nullity,
            _symbolic_solution_method_polynomial
        )
        family.3: family_verified
        @: family

    admissible: true
    .domain: _symbolic_domain_real
    .row: 0
    row < count?>
        .domain: _symbolic_domain(_symbolic_clone(variables.(row)))
        ~_symbolic_numeric_root_in_domain(canonical_particular.(row), domain)?
            .admissible: false
        .row+: 1
    ~admissible?
        empty: _symbolic_empty_solution_set(count, _symbolic_solution_method_polynomial)
        empty.3: 1
        @: empty

    solutions: _symbolic_one_numeric_vector_solution_set(
        canonical_particular,
        _symbolic_solution_method_polynomial
    )
    solutions.3: linalg.relative_residual(
        coefficient_matrix,
        canonical_particular,
        targets
    ) < 0.000000001
    solutions

_symbolic_empty_numeric_vector() -> [num]:
    [num] result: []
    result

_symbolic_clone_numeric_vector(value:[num]) -> [num]:
    [num] result: []
    value.length() > 0?
        ..value.length() - 1 >>
            .result: result & [value.($)]
    result

_symbolic_numeric_vector_same(left:[num], right:[num]) -> bit:
    left.length() != right.length()?
        @: false
    equal: true
    left.length() > 0?
        ..left.length() - 1 >>
            left.($) != right.($)?
                .equal: false
    equal

# Catalog domain/kind/name/signature establish mathematical identity.
# LaTeX is presentation carried by the immutable value snapshot, not a new
# algebraic variable. This adapter validates entry framing and compared ranges;
# domain/signature validity remains the responsibility of the existing issuers.
# Change presentation on the actual symbol snapshot. Catalog identity fields
# and the complete function-domain signature tail are copied without decoding.
_symbolic_with_latex(value:symbolic, latex:[num]) -> symbol:
    _symbolic_root_kind(value) != 1?
        errors.TypeError("symbolic .latex expects a symbol, function, or constant")!
    entry: _symbolic_raw_catalog(value)
    ~_symbolic_catalog_identity_same(entry, entry)?
        errors.TypeError("symbolic .latex received invalid catalog framing")!
    name_length: entry.3
    latex_index: 4 + name_length
    old_latex_length: entry.(latex_index)
    tail: latex_index + 1 + old_latex_length
    tail >= entry.length()?
        errors.TypeError("symbolic .latex received incomplete signature framing")!
    arity: entry.(tail)
    arity < 0 \/ arity % 1 != 0 \/ tail + 3 + 2*arity != entry.length()?
        errors.TypeError("symbolic .latex received incomplete signature framing")!
    [num] replacement: [0, entry.1, entry.2, name_length]
    name_length > 0?
        ..name_length - 1 >>
            .replacement: replacement & [entry.(4 + $)]
    .replacement: replacement & [latex.length()]
    latex.length() > 0?
        ..latex.length() - 1 >>
            .replacement: replacement & [latex.($)]
    tail < entry.length()?
        tail..entry.length() - 1 >>
            .replacement: replacement & [entry.($)]
    replacement.0: replacement.length() - 1
    [num] result: [1] & replacement & [1, 0, replacement.length() + 4]
    result

_symbolic_catalog_identity_same(left:[num], right:[num]) -> bit:
    left.length() < 5 \/ right.length() < 5?
        @: false
    left.0 != left.length() - 1 \/ right.0 != right.length() - 1?
        @: false
    left.1 != right.1 \/ left.2 != right.2 \/ left.3 != right.3?
        @: false
    name_length: left.3
    name_length < 0 \/ name_length % 1 != 0?
        @: false
    latex_index: 4 + name_length
    latex_index >= left.length() \/ latex_index >= right.length()?
        @: false
    left_latex: left.(latex_index)
    right_latex: right.(latex_index)
    left_latex < 0 \/ right_latex < 0 \/ left_latex % 1 != 0 \/ right_latex % 1 != 0?
        @: false
    left_tail: latex_index + 1 + left_latex
    right_tail: latex_index + 1 + right_latex
    left_tail > left.length() \/ right_tail > right.length()?
        @: false
    left.length() - left_tail != right.length() - right_tail?
        @: false
    equal: true
    name_length > 0?
        ..name_length - 1 >>
            left.(4 + $) != right.(4 + $)?
                .equal: false
    tail_length: left.length() - left_tail
    tail_length > 0?
        ..tail_length - 1 >>
            left.(left_tail + $) != right.(right_tail + $)?
                .equal: false
    equal

_symbolic_dag_catalog_length(value:symbolic) -> num:
    value.(1)

_symbolic_dag_variable_count(value:symbolic) -> num:
    value.(2)

_symbolic_dag_node_count(value:symbolic) -> num:
    value.(3)

_symbolic_dag_root(value:symbolic) -> num:
    value.(4)

_symbolic_dag_node_start(value:symbolic) -> num:
    5 + _symbolic_dag_catalog_length(value)

_symbolic_dag_node_offset(value:symbolic, node:num) -> num:
    _symbolic_dag_node_start(value) + node * 4

_symbolic_dag_node_operation(value:symbolic, node:num) -> num:
    value.(_symbolic_dag_node_offset(value, node))

_symbolic_dag_node_left(value:symbolic, node:num) -> num:
    value.(_symbolic_dag_node_offset(value, node) + 1)

_symbolic_dag_node_right(value:symbolic, node:num) -> num:
    value.(_symbolic_dag_node_offset(value, node) + 2)

_symbolic_dag_node_value(value:symbolic, node:num) -> num:
    value.(_symbolic_dag_node_offset(value, node) + 3)

_symbolic_dag_catalog(value:symbolic) -> [num]:
    length: _symbolic_dag_catalog_length(value)
    length < 1?
        @: _symbolic_empty_numeric_vector()
    [5..length + 4 >> value.($)]

_symbolic_dag_catalog_entry(value:symbolic, wanted:num) -> [num]:
    _symbolic_catalog_entry(_symbolic_dag_catalog(value), wanted)

_symbolic_dag_raw_catalog(value:symbolic, node:num) -> [num]:
    operation: _symbolic_dag_node_operation(value, node)
    [num] left: []
    [num] right: []
    [num] result: []
    operation = 1?
        @: _symbolic_dag_catalog_entry(value, _symbolic_dag_node_left(value, node))
    operation = 2?
        @: _symbolic_empty_numeric_vector()
    (operation >= 3 /\ operation <= 7) \/ (operation >= 13 /\ operation <= 24) \/ operation = 27?
        .left: _symbolic_dag_raw_catalog(value, _symbolic_dag_node_left(value, node))
        .right: _symbolic_dag_raw_catalog(value, _symbolic_dag_node_right(value, node))
        .result: left & right
        @: result
    (operation >= 8 /\ operation <= 12) \/ operation = 25 \/ operation = 26?
        @: _symbolic_dag_raw_catalog(value, _symbolic_dag_node_left(value, node))
    _symbolic_empty_numeric_vector()

_symbolic_dag_make(catalog:[num], nodes:[num], root:num) -> symbolic:
    node_count: nodes.length() / 4
    total_length: 5 + catalog.length() + nodes.length() + 3
    [num] header: [10, catalog.length(), _symbolic_catalog_variable_count(catalog), node_count, root]
    [num] trailer: [10, 0, total_length]
    [num] result: header & catalog & nodes & trailer
    result

_symbolic_dag_with_root(value:symbolic, root:num) -> symbolic:
    [num] result: [..value.length() - 1 >> value.($)]
    result.4: root
    result

_symbolic_dag_append_node(value:symbolic, operation:num, left:num, right:num, data:num) -> symbolic:
    [num] prefix: [..value.length() - 4 >> value.($)]
    [num] node: [operation, left, right, data]
    new_count: _symbolic_dag_node_count(value) + 1
    total_length: prefix.length() + node.length() + 3
    [num] trailer: [10, 0, total_length]
    [num] result: prefix & node & trailer
    result.3: new_count
    result.4: new_count - 1
    result

_symbolic_dag_catalog_prefix(prefix:symbolic, value:symbolic) -> bit:
    prefix_length: _symbolic_dag_catalog_length(prefix)
    prefix_length > _symbolic_dag_catalog_length(value)?
        @: false
    equal: true
    prefix_length > 0?
        ..prefix_length - 1 >>
            prefix.(5 + $) != value.(5 + $)?
                .equal: false
    equal

_symbolic_dag_node_prefix(prefix:symbolic, value:symbolic) -> bit:
    prefix_count: _symbolic_dag_node_count(prefix)
    prefix_count > _symbolic_dag_node_count(value)?
        @: false
    prefix_start: _symbolic_dag_node_start(prefix)
    value_start: _symbolic_dag_node_start(value)
    equal: true
    width: prefix_count * 4
    width > 0?
        ..width - 1 >>
            prefix.(prefix_start + $) != value.(value_start + $)?
                .equal: false
    equal

_symbolic_dag_is_prefix(prefix:symbolic, value:symbolic) -> bit:
    _symbolic_dag_catalog_prefix(prefix, value) /\ _symbolic_dag_node_prefix(prefix, value)

_symbolic_dag_same_nodes(left:symbolic, left_node:num, right:symbolic, right_node:num) -> bit:
    left_operation: _symbolic_dag_node_operation(left, left_node)
    right_operation: _symbolic_dag_node_operation(right, right_node)
    left_operation != right_operation?
        @: false
    left_operation = 1?
        left_entry: _symbolic_dag_catalog_entry(left, _symbolic_dag_node_left(left, left_node))
        right_entry: _symbolic_dag_catalog_entry(right, _symbolic_dag_node_left(right, right_node))
        @: _symbolic_catalog_identity_same(left_entry, right_entry)
    left_operation = 2?
        @: _symbolic_dag_node_value(left, left_node) = _symbolic_dag_node_value(right, right_node)
    (left_operation >= 3 /\ left_operation <= 7) \/ (left_operation >= 13 /\ left_operation <= 24) \/ left_operation = 27?
        left_equal: _symbolic_dag_same_nodes(
            left,
            _symbolic_dag_node_left(left, left_node),
            right,
            _symbolic_dag_node_left(right, right_node)
        )
        ~left_equal?
            @: false
        @: _symbolic_dag_same_nodes(
            left,
            _symbolic_dag_node_right(left, left_node),
            right,
            _symbolic_dag_node_right(right, right_node)
        )
    (left_operation >= 8 /\ left_operation <= 12) \/ left_operation = 25 \/ left_operation = 26?
        @: _symbolic_dag_same_nodes(
            left,
            _symbolic_dag_node_left(left, left_node),
            right,
            _symbolic_dag_node_left(right, right_node)
        )
    false

_symbolic_dag_same(left:symbolic, right:symbolic) -> bit:
    _symbolic_dag_same_nodes(left, _symbolic_dag_root(left), right, _symbolic_dag_root(right))

_symbolic_as_dag(value:symbolic) -> symbolic:
    _symbolic_storage_kind(value) = 10?
        @: _symbolic_clone(value)
    kind: _symbolic_root_kind(value)
    kind = 1?
        catalog: _symbolic_raw_catalog(value)
        [num] nodes: [1, 0, 0, 0]
        @: _symbolic_dag_make(catalog, nodes, 0)
    kind = 2?
        [num] empty: []
        [num] nodes: [2, 0, 0, value.(1)]
        @: _symbolic_dag_make(empty, nodes, 0)
    kind = 3?
        @: _symbolic_dag_binary(
            _symbolic_left(value),
            _symbolic_right(value),
            _symbolic_root_operation(value) + 2
        )
    kind = 7?
        @: _symbolic_rebuild_function(_symbolic_argument(value), _symbolic_root_operation(value))
    _symbolic_as_dag(_symbolic_raw_number(0))

_symbolic_dag_copy_nodes(
    target:[num],
    source:symbolic,
    catalog_map:[num],
    target_node_offset:num
) -> [num]:
    count: _symbolic_dag_node_count(source)
    node: 0
    operation: 0
    left: 0
    right: 0
    data: 0
    output: 0
    node < count?>
        .operation: _symbolic_dag_node_operation(source, node)
        .left: _symbolic_dag_node_left(source, node)
        .right: _symbolic_dag_node_right(source, node)
        .data: _symbolic_dag_node_value(source, node)
        operation = 1?
            .left: catalog_map.(left)
        operation >= 3?
            .left+: target_node_offset
        (operation >= 3 /\ operation <= 7) \/ (operation >= 13 /\ operation <= 24) \/ operation = 27?
            .right+: target_node_offset
        .output: (target_node_offset + node) * 4
        target.(output): operation
        target.(output + 1): left
        target.(output + 2): right
        target.(output + 3): data
        .node+: 1
    target

_symbolic_dag_binary_general(left:symbolic, right:symbolic, operation:num) -> symbolic:
    left_catalog: _symbolic_dag_catalog(left)
    right_catalog: _symbolic_dag_catalog(right)
    catalog: _symbolic_merge_catalogs(left_catalog, right_catalog)
    left_map: _symbolic_catalog_index_map(left_catalog, catalog)
    right_map: _symbolic_catalog_index_map(right_catalog, catalog)
    left_count: _symbolic_dag_node_count(left)
    right_count: _symbolic_dag_node_count(right)
    nodes: [0:(left_count + right_count) * 4]
    .nodes: _symbolic_dag_copy_nodes(nodes, left, left_map, 0)
    .nodes: _symbolic_dag_copy_nodes(nodes, right, right_map, left_count)
    merged: _symbolic_dag_make(catalog, nodes, _symbolic_dag_root(left))
    _symbolic_dag_append_node(
        merged,
        operation,
        _symbolic_dag_root(left),
        left_count + _symbolic_dag_root(right),
        0
    )

_symbolic_dag_binary_ordered(left:symbolic, right:symbolic, operation:num) -> symbolic:
    _symbolic_dag_is_prefix(left, right)?
        @: _symbolic_dag_append_node(
            right,
            operation,
            _symbolic_dag_root(left),
            _symbolic_dag_root(right),
            0
        )
    _symbolic_dag_is_prefix(right, left)?
        @: _symbolic_dag_append_node(
            left,
            operation,
            _symbolic_dag_root(left),
            _symbolic_dag_root(right),
            0
        )
    _symbolic_dag_binary_general(left, right, operation)

_symbolic_dag_binary(left_value:symbolic, right_value:symbolic, operation:num) -> symbolic:
    left: _symbolic_as_dag(left_value)
    right: _symbolic_as_dag(right_value)
    commutative: operation = 3 \/ operation = 5
    commutative /\ _symbolic_dag_node_count(left) < _symbolic_dag_node_count(right)?
        @: _symbolic_dag_binary_ordered(right, left, operation)
    _symbolic_dag_binary_ordered(left, right, operation)

_symbolic_dag_unary(value:symbolic, operation:num) -> symbolic:
    dag: _symbolic_as_dag(value)
    _symbolic_dag_append_node(dag, operation, _symbolic_dag_root(dag), 0, 0)

_symbolic_dag_term_count(value:symbolic, node:num) -> num:
    operation: _symbolic_dag_node_operation(value, node)
    operation = 3 \/ operation = 4?
        @: _symbolic_dag_term_count(value, _symbolic_dag_node_left(value, node)) + _symbolic_dag_term_count(value, _symbolic_dag_node_right(value, node))
    1

_symbolic_raw_catalog(value:symbolic) -> [num]:
    _symbolic_storage_kind(value) = 10?
        @: _symbolic_dag_raw_catalog(value, _symbolic_dag_root(value))
    kind: _symbolic_root_kind(value)
    kind = 1?
        name_length: value.(1)
        @: [1..name_length + 1 >> value.($)]
    kind = 2?
        @: _symbolic_empty_numeric_vector()
    kind = 4?
        catalog_length: value.(1)
        catalog_length < 1?
            @: _symbolic_empty_numeric_vector()
        @: [3..catalog_length + 2 >> value.($)]
    kind = 6?
        catalog_length: value.(1)
        @: [3..catalog_length + 2 >> value.($)]
    kind = 3?
        @: _symbolic_raw_catalog(_symbolic_left(value)) & _symbolic_raw_catalog(_symbolic_right(value))
    kind = 7?
        @: _symbolic_raw_catalog(_symbolic_argument(value))
    _symbolic_empty_numeric_vector()

_symbolic_catalog_has_entry(catalog:[num], entry:[num]) -> bit:
    _symbolic_catalog_entry_index(catalog, entry) >= 0

_symbolic_catalog(value:symbolic) -> [num]:
    raw: _symbolic_raw_catalog(value)
    [num] result: []
    [num] entry: []
    cursor: 0
    cursor < raw.length()?>
        name_length: raw.(cursor)
        .entry: [cursor..cursor + name_length >> raw.($)]
        ~_symbolic_catalog_has_entry(result, entry)?
            .result: result & entry
        .cursor+: name_length + 1
    result

_symbolic_catalog_variable_count(catalog:[num]) -> num:
    count: 0
    cursor: 0
    cursor < catalog.length()?>
        .cursor+: catalog.(cursor) + 1
        .count+: 1
    count

_symbolic_is_distinct_symbol_sum(value:symbolic) -> bit:
    kind: _symbolic_root_kind(value)
    kind = 1?
        @: true
    ~(kind = 3)?
        @: false
    ~(_symbolic_root_operation(value) = 1)?
        @: false
    leaf_count: _symbolic_symbol_leaf_count(_symbolic_clone(value))
    leaf_count < 1?
        @: false
    catalog: _symbolic_catalog(_symbolic_clone(value))
    @: _symbolic_catalog_variable_count(catalog) = leaf_count

_symbolic_symbol_leaf_count(value:symbolic) -> num:
    _symbolic_root_kind(value) = 1?
        @: 1
    _symbolic_root_kind(value) = 3 /\ _symbolic_root_operation(value) = 1?
        left: _symbolic_symbol_leaf_count(_symbolic_left(_symbolic_clone(value)))
        right: _symbolic_symbol_leaf_count(_symbolic_right(_symbolic_clone(value)))
        left < 0 \/ right < 0?
            @: -1
        @: left + right
    -1

_symbolic_choose(n:num, k:num) -> num:
    k < 0 \/ k > n?
        @: 0
    reduced: k
    k > n - k?
        .reduced: n - k
    result: 1
    reduced > 0?
        ..reduced - 1 >>
            .result: result * (n - $) / ($ + 1)
    result

_symbolic_factorial(value:num) -> num:
    result: 1
    value >= 2?
        2..value >>
            .result *: $
    result

_symbolic_multinomial_coefficient(exponents:[num], factorials:[num], degree:num) -> num:
    result: factorials.(degree)
    index: 0
    index < exponents.length()?>
        .result /: factorials.(exponents.(index))
        .index+: 1
    result

_symbolic_advance_composition(exponents:[num]) -> [num]:
    index: exponents.length() - 2
    index >= 0?>
        exponents.(index) > 0?
            pool: 1
            (index + 1)..exponents.length() - 1 >>
                .pool+: exponents.($)
            exponents.(index): exponents.(index) - 1
            exponents.(index + 1): pool
            index + 2 <= exponents.length() - 1?
                (index + 2)..exponents.length() - 1 >>
                    exponents.($): 0
            @: exponents
        .index -: 1
    exponents

_symbolic_expand_distinct_sum_power(base:symbolic, degree:num) -> symbolic:
    catalog: _symbolic_catalog(base)
    variable_count: _symbolic_catalog_variable_count(catalog)
    term_count: _symbolic_choose(degree + variable_count - 1, variable_count - 1)
    term_width: variable_count + 1
    payload_length: term_count * term_width
    total_length: 3 + catalog.length() + 1 + payload_length + 3
    [num] header: [4, catalog.length(), variable_count]
    [num] count_header: [term_count]
    [num] terms: [0:payload_length]
    [num] trailer: [4, 0, total_length]
    result: header & catalog & count_header & terms & trailer
    exponents: [0:variable_count]
    exponents.(0): degree
    factorials: [1:degree + 1]
    degree >= 1?
        1..degree >>
            factorials.($): factorials.($ - 1) * $
    term_start: 4 + catalog.length()
    ..term_count - 1 >>
        offset: term_start + $ * term_width
        result.(offset): _symbolic_multinomial_coefficient(exponents, factorials, degree)
        ..variable_count - 1 >>
            result.(offset + $ + 1): exponents.($)
        .exponents: _symbolic_advance_composition(exponents)
    result

_symbolic_polynomial_term_count(value:symbolic) -> num:
    catalog_length: value.(1)
    value.(catalog_length + 3)

_symbolic_polynomial_variable_count(value:symbolic) -> num:
    value.(2)

_symbolic_catalog_entry(catalog:[num], wanted:num) -> [num]:
    cursor: 0
    index: 0
    cursor < catalog.length()?>
        name_length: catalog.(cursor)
        index = wanted?
            @: [cursor..cursor + name_length >> catalog.($)]
        .cursor+: name_length + 1
        .index+: 1
    [num] empty: []
    empty

_symbolic_catalog_entry_index(catalog:[num], entry:[num]) -> num:
    cursor: 0
    index: 0
    cursor < catalog.length()?>
        name_length: catalog.(cursor)
        candidate: [cursor..cursor + name_length >> catalog.($)]
        _symbolic_catalog_identity_same(candidate, entry)?
            @: index
        .cursor+: name_length + 1
        .index+: 1
    -1

_symbolic_merge_catalogs(left:[num], right:[num]) -> [num]:
    result: _symbolic_clone_numeric_vector(left)
    [num] entry: []
    cursor: 0
    cursor < right.length()?>
        name_length: right.(cursor)
        .entry: [cursor..cursor + name_length >> right.($)]
        _symbolic_catalog_entry_index(result, entry) < 0?
            .result: result & entry
        .cursor+: name_length + 1
    result

_symbolic_catalog_index_map(source:[num], target:[num]) -> [num]:
    num count: _symbolic_catalog_variable_count(source)
    result: [0:count]
    count > 0?
        ..count - 1 >>
            result.($): _symbolic_catalog_entry_index(target, _symbolic_catalog_entry(source, $))
    result

_symbolic_pack_symbol(value:symbolic) -> symbolic:
    catalog: _symbolic_raw_catalog(value)
    total_length: 3 + catalog.length() + 1 + 2 + 3
    [num] header: [4, catalog.length(), 1]
    [num] payload: [1, 1, 1, 4, 0, total_length]
    result: header & catalog & payload
    result

_symbolic_pack_constant(value:num) -> symbolic:
    [num] result: [4, 0, 0, 1, value, 4, 0, 8]
    result

_symbolic_zero_polynomial() -> symbolic:
    [num] result: [4, 0, 0, 0, 4, 0, 7]
    result

polynomial(variable:symbolic, requested_capacity:num = 4096) -> symbolic:
    ~(_symbolic_root_kind(variable) = 1)?
        errors.TypeError("symbolic.polynomial variable must be a symbol")!
    requested_capacity < 0 \/ ~(requested_capacity % 1 = 0)?
        errors.ValueError("symbolic.polynomial capacity must be a nonnegative integer")!
    catalog: _symbolic_raw_catalog(variable)
    capacity: requested_capacity
    capacity < 2?
        .capacity: 2
    coefficients: [0:capacity]
    coefficients.1: 1
    total_length: 3 + catalog.length() + 2 + capacity + 3
    [num] header: [6, catalog.length(), 1]
    [num] metadata: [capacity, 1]
    [num] trailer: [6, 0, total_length]
    result: header & catalog & metadata & coefficients & trailer
    result

polynomial(variable_name:chr, requested_capacity:num = 4096) -> symbolic:
    polynomial(_symbolic_suffix_domain_variable(variable_name, _symbolic_domain_real), requested_capacity)

_symbolic_univariate_capacity(value:symbolic) -> num:
    value.(value.(1) + 3)

_symbolic_univariate_count_index(value:symbolic) -> num:
    value.(1) + 4

_symbolic_univariate_coefficient_start(value:symbolic) -> num:
    value.(1) + 5

_symbolic_univariate_grow(value:symbolic, exponent:num) -> symbolic:
    capacity: _symbolic_univariate_capacity(value)
    new_capacity: capacity
    new_capacity <= exponent?>
        .new_capacity *: 2
    coefficient_start: _symbolic_univariate_coefficient_start(value)
    prefix_end: coefficient_start + capacity - 1
    prefix: [..prefix_end >> value.($)]
    padding: [0:new_capacity - capacity]
    total_length: prefix.length() + padding.length() + 3
    [num] trailer: [6, 0, total_length]
    result: prefix & padding & trailer
    result.(value.(1) + 3): new_capacity
    result

add_term(value:symbolic, coefficient_value:num, exponent:num) -> symbolic:
    ~(_symbolic_root_kind(value) = 6)?
        errors.TypeError("symbolic.add_term expects a univariate polynomial")!
    exponent < 0 \/ ~(exponent % 1 = 0)?
        errors.ValueError("symbolic.add_term exponent must be a nonnegative integer")!
    exponent >= _symbolic_univariate_capacity(value)?
        grown: _symbolic_univariate_grow(value, exponent)
        @: add_term(grown, coefficient_value, exponent)
    count_index: _symbolic_univariate_count_index(value)
    coefficient_index: _symbolic_univariate_coefficient_start(value) + exponent
    before: value.(coefficient_index)
    after: before + coefficient_value
    before = 0 /\ ~(after = 0)?
        value.(count_index): value.(count_index) + 1
    ~(before = 0) /\ after = 0?
        value.(count_index): value.(count_index) - 1
    value.(coefficient_index): after
    value

_symbolic_as_polynomial(value:symbolic) -> symbolic:
    kind: _symbolic_root_kind(value)
    kind = 4?
        @: _symbolic_clone(value)
    kind = 1?
        @: _symbolic_pack_symbol(value)
    kind = 2?
        @: _symbolic_pack_constant(_symbolic_number_value(value))
    _symbolic_zero_polynomial()

_symbolic_polynomial_term_coefficient(value:symbolic, term:num) -> num:
    variable_count: _symbolic_polynomial_variable_count(value)
    start: value.(1) + 4
    value.(start + term * (variable_count + 1))

_symbolic_polynomial_term_exponent(value:symbolic, term:num, variable:num) -> num:
    variable_count: _symbolic_polynomial_variable_count(value)
    start: value.(1) + 4
    value.(start + term * (variable_count + 1) + variable + 1)

_symbolic_polynomial_max_exponents(value:symbolic, mapping:[num], common_count:num) -> [num]:
    maxima: [0:common_count]
    source_count: _symbolic_polynomial_variable_count(value)
    terms: _symbolic_polynomial_term_count(value)
    term: 0
    variable: 0
    common: 0
    exponent: 0
    term < terms?>
        .variable: 0
        variable < source_count?>
            .common: mapping.(variable)
            .exponent: _symbolic_polynomial_term_exponent(value, term, variable)
            exponent > maxima.(common)?
                maxima.(common): exponent
            .variable+: 1
        .term+: 1
    maxima

_symbolic_polynomial_term_keys(value:symbolic, mapping:[num], strides:[num]) -> [num]:
    num terms: _symbolic_polynomial_term_count(value)
    source_count: _symbolic_polynomial_variable_count(value)
    keys: [0:terms]
    term: 0
    key: 0
    variable: 0
    term < terms?>
        .key: 0
        .variable: 0
        variable < source_count?>
            .key+: _symbolic_polynomial_term_exponent(value, term, variable) * strides.(mapping.(variable))
            .variable+: 1
        keys.(term): key
        .term+: 1
    keys

_symbolic_polynomial_accumulate(
    coefficients:[num],
    value:symbolic,
    mapping:[num],
    strides:[num],
    scale:num
) -> [num]:
    keys: _symbolic_polynomial_term_keys(value, mapping, strides)
    term: 0
    key: 0
    term < keys.length()?>
        .key: keys.(term)
        coefficients.(key): coefficients.(key) + _symbolic_polynomial_term_coefficient(value, term) * scale
        .term+: 1
    coefficients

_symbolic_polynomial_from_dense(
    catalog:[num],
    radices:[num],
    strides:[num],
    coefficients:[num]
) -> symbolic:
    num nonzero: 0
    key: 0
    key < coefficients.length()?>
        ~(coefficients.(key) = 0)?
            .nonzero+: 1
        .key+: 1
    num variable_count: radices.length()
    num width: variable_count + 1
    terms: [0:nonzero * width]
    output: 0
    coefficient: 0
    offset: 0
    variable: 0
    .key: 0
    key < coefficients.length()?>
        .coefficient: coefficients.(key)
        ~(coefficient = 0)?
            .offset: output * width
            terms.(offset): coefficient
            .variable: 0
            variable < variable_count?>
                terms.(offset + variable + 1): (key // strides.(variable)) % radices.(variable)
                .variable+: 1
            .output+: 1
        .key+: 1
    total_length: 3 + catalog.length() + 1 + terms.length() + 3
    [num] header: [4, catalog.length(), variable_count]
    [num] count_header: [nonzero]
    [num] trailer: [4, 0, total_length]
    result: header & catalog & count_header & terms & trailer
    result

_symbolic_polynomial_combine(left:symbolic, right:symbolic, operation:num) -> symbolic:
    left_polynomial: _symbolic_as_polynomial(left)
    right_polynomial: _symbolic_as_polynomial(right)
    left_catalog: _symbolic_catalog(left_polynomial)
    right_catalog: _symbolic_catalog(right_polynomial)
    catalog: _symbolic_merge_catalogs(left_catalog, right_catalog)
    left_mapping: _symbolic_catalog_index_map(left_catalog, catalog)
    right_mapping: _symbolic_catalog_index_map(right_catalog, catalog)
    num variable_count: _symbolic_catalog_variable_count(catalog)
    left_maxima: _symbolic_polynomial_max_exponents(left_polynomial, left_mapping, variable_count)
    right_maxima: _symbolic_polynomial_max_exponents(right_polynomial, right_mapping, variable_count)
    radices: [0:variable_count]
    strides: [0:variable_count]
    num dense_size: 1
    variable: 0
    maximum: 0
    variable < variable_count?>
        strides.(variable): dense_size
        .maximum: left_maxima.(variable)
        operation = 3?
            .maximum+: right_maxima.(variable)
        ~(operation = 3) /\ right_maxima.(variable) > maximum?
            .maximum: right_maxima.(variable)
        radices.(variable): maximum + 1
        .dense_size *: maximum + 1
        .variable+: 1
    coefficients: [0:dense_size]
    [num] left_keys: []
    [num] right_keys: []
    left_term: 0
    left_coefficient: 0
    right_term: 0
    key: 0
    scale: 1
    operation = 3?
        .left_keys: _symbolic_polynomial_term_keys(left_polynomial, left_mapping, strides)
        .right_keys: _symbolic_polynomial_term_keys(right_polynomial, right_mapping, strides)
        .left_term: 0
        left_term < left_keys.length()?>
            .left_coefficient: _symbolic_polynomial_term_coefficient(left_polynomial, left_term)
            .right_term: 0
            right_term < right_keys.length()?>
                .key: left_keys.(left_term) + right_keys.(right_term)
                coefficients.(key): coefficients.(key) + left_coefficient * _symbolic_polynomial_term_coefficient(right_polynomial, right_term)
                .right_term+: 1
            .left_term+: 1
    ~(operation = 3)?
        .coefficients: _symbolic_polynomial_accumulate(coefficients, left_polynomial, left_mapping, strides, 1)
        .scale: 1
        operation = 2?
            .scale: -1
        .coefficients: _symbolic_polynomial_accumulate(coefficients, right_polynomial, right_mapping, strides, scale)
    _symbolic_polynomial_from_dense(catalog, radices, strides, coefficients)

_symbolic_polynomial_add(left:symbolic, right:symbolic) -> symbolic:
    _symbolic_polynomial_combine(left, right, 1)

_symbolic_polynomial_subtract(left:symbolic, right:symbolic) -> symbolic:
    _symbolic_polynomial_combine(left, right, 2)

_symbolic_polynomial_multiply(left:symbolic, right:symbolic) -> symbolic:
    _symbolic_polynomial_combine(left, right, 3)

_symbolic_polynomial_power(base:symbolic, exponent:num) -> symbolic:
    result: _symbolic_pack_constant(1)
    factor: _symbolic_as_polynomial(base)
    remaining: exponent
    remaining > 0?>
        remaining % 2 = 1?
            .result: _symbolic_polynomial_multiply(result, factor)
        .remaining: remaining // 2
        remaining > 0?
            .factor: _symbolic_polynomial_multiply(factor, factor)
    result

coefficient(value:symbolic, exponents:[num]) -> num:
    exponents.length() > 0?
        ..exponents.length() - 1 >>
            exponents.($) < 0 \/ ~(exponents.($) % 1 = 0)?
                errors.ValueError("symbolic.coefficient exponents must be nonnegative integers")!
    _symbolic_root_kind(value) = 6?
        exponents.length() != 1?
            errors.ValueError("symbolic.coefficient expected one exponent")!
        exponent: exponents.0
        exponent < 0 \/ exponent >= _symbolic_univariate_capacity(value)?
            @: 0
        @: value.(_symbolic_univariate_coefficient_start(value) + exponent)
    ~(_symbolic_root_kind(value) = 4)?
        errors.TypeError("symbolic.coefficient expects an expanded polynomial")!
    variable_count: _symbolic_polynomial_variable_count(value)
    exponents.length() != variable_count?
        errors.ValueError("symbolic.coefficient exponent count does not match polynomial")!
    catalog_length: value.(1)
    terms: _symbolic_polynomial_term_count(value)
    width: variable_count + 1
    start: catalog_length + 4
    term: 0
    term < terms?>
        matches: true
        variable_count > 0?
            ..variable_count - 1 >>
                value.(start + term * width + $ + 1) != exponents.($)?
                    .matches: false
        matches?
            @: value.(start + term * width)
        .term+: 1
    0

_symbolic_is_raw_number(value:symbolic, expected:num) -> bit:
    _symbolic_root_kind(value) = 2 /\ _symbolic_number_value(value) = expected

# Mathematical totality is a conditional fact of the existing scalar domains.
# It does not establish IEEE-equivalent executable replacement. Inspection
# execution below retains the original source view and its binding catalog.
_symbolic_is_finite_raw_number(value:symbolic) -> bit:
    ~(_symbolic_root_kind(value) = 2)? @: false
    numeric: _symbolic_number_value(value)
    numeric - numeric = 0

_symbolic_mathematical_total(value:symbolic) -> bit:
    kind: _symbolic_root_kind(value)
    kind = 2? @: _symbolic_is_finite_raw_number(value)
    kind = 1?
        entry: _symbolic_raw_catalog(value)
        ~_symbolic_catalog_identity_same(entry, entry)? @: false
        tail: _symbolic_function_signature_index(value)
        # Scalar-variable framing, not just the base tag of a vector domain.
        tail + 3 != entry.length()? @: false
        entry.(tail) != 0? @: false
        entry.(tail + 1) != entry.1 \/ entry.(tail + 2) != 1? @: false
        @: entry.2 = 1 /\ entry.1 >= 1 /\ entry.1 <= 5
    kind = 7?
        operation: _symbolic_root_operation(value)
        operation = 6 \/ operation = 7?
            @: _symbolic_mathematical_total(_symbolic_argument(value))
        @: false
    kind = 3?
        left: _symbolic_left(value)
        right: _symbolic_right(value)
        operation: _symbolic_root_operation(value)
        operation >= 1 /\ operation <= 3?
            @: _symbolic_mathematical_total(left) /\ _symbolic_mathematical_total(right)
        operation = 4 /\ _symbolic_is_finite_raw_number(right)?
            @: _symbolic_number_value(right) != 0 /\ _symbolic_mathematical_total(left)
        operation = 5 /\ _symbolic_is_finite_raw_number(right)?
            exponent: _symbolic_number_value(right)
            exponent = m.abs(exponent)?
                exponent % 1 = 0?
                    @: _symbolic_mathematical_total(left)
            _symbolic_is_finite_raw_number(left)?
                @: _symbolic_number_value(left) != 0
    kind = 7?
        operation: _symbolic_root_operation(value)
        argument: _symbolic_argument(value)
        (operation = 1 \/ operation = 2 \/ operation = 5)?
            @: _symbolic_mathematical_total(argument)
        (operation = 3 \/ operation = 4) /\ _symbolic_is_finite_raw_number(argument)?
            number: _symbolic_number_value(argument)
            @: number = m.abs(number) /\ number > 0
    # Expanded polynomial/univariate and opaque operation views remain outside
    # this narrow totality proof. Their established leaf algorithms are retained.
    false

_symbolic_inspection_binary_source(left:symbolic, right:symbolic, operation:num, ordinal:num) -> symbolic:
    ordinal < 0? @: _symbolic_raw_number(0)
    [num] left_stream: [..left.length() - 1 >> left.($)]
    [num] right_stream: [..right.length() - 1 >> right.($)]
    [num] result: left_stream & right_stream & [3, operation, left.length() + right.length() + 3]
    result

_symbolic_inspection_unary_source(argument:symbolic, operation:num, ordinal:num) -> symbolic:
    ordinal < 0? @: _symbolic_raw_number(0)
    [num] argument_stream: [..argument.length() - 1 >> argument.($)]
    [num] result: argument_stream & [7, operation, argument.length() + 3]
    result

_symbolic_inspection_step(source:symbolic, result:symbolic, rule_id:str, status:str,
                          obligation_kind:str, obligation_operand:symbolic, ordinal:num) -> (ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit):
    (ordinal:ordinal, rule_id:rule_id, status:status,
     input:_symbolic_clone(source), output:_symbolic_clone(result),
     assumption:(kind:obligation_kind, operand:_symbolic_clone(obligation_operand),
                 scope:"conditional mathematical domain; no executable replacement proof"),
     numerical_requirement:"exact_algebra", execution_authority:false)

_symbolic_inspection_rule(source:symbolic, result:symbolic, rule_id:str, status:str,
                          obligation_kind:str, obligation_operand:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    ordinal < 0? @: (expression:result, steps:[])
    step: _symbolic_inspection_step(source, result, rule_id, status, obligation_kind, obligation_operand, ordinal)
    (expression:_symbolic_clone(result), steps:[step])

_symbolic_add_inspection(left:symbolic, right:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    source: _symbolic_inspection_binary_source(left, right, 1, ordinal)
    _symbolic_is_finite_raw_number(left) /\ _symbolic_is_finite_raw_number(right)?
        result: _symbolic_raw_number(_symbolic_number_value(left) + _symbolic_number_value(right))
        _symbolic_is_finite_raw_number(result)?
            @: _symbolic_inspection_rule(source, result, "known_numeric_add", "applied", "finite_literal_region", source, ordinal)
    _symbolic_is_raw_number(left, 0)?
        @: _symbolic_inspection_rule(source, _symbolic_clone(right), "additive_left_identity", "applied", "operand_source_domain_retained", right, ordinal)
    _symbolic_is_raw_number(right, 0)?
        @: _symbolic_inspection_rule(source, _symbolic_clone(left), "additive_right_identity", "applied", "operand_source_domain_retained", left, ordinal)
    _symbolic_inspection_rule(source, left + right, "add_unchanged", "unchanged", "source_domain_retained", source, ordinal)

_symbolic_add_simplified(left:symbolic, right:symbolic) -> symbolic:
    _symbolic_add_inspection(left, right, -1).expression

_symbolic_subtract_inspection(left:symbolic, right:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    source: _symbolic_inspection_binary_source(left, right, 2, ordinal)
    _symbolic_is_finite_raw_number(left) /\ _symbolic_is_finite_raw_number(right)?
        result: _symbolic_raw_number(_symbolic_number_value(left) - _symbolic_number_value(right))
        _symbolic_is_finite_raw_number(result)?
            @: _symbolic_inspection_rule(source, result, "known_numeric_subtract", "applied", "finite_literal_region", source, ordinal)
    _symbolic_is_raw_number(right, 0)?
        @: _symbolic_inspection_rule(source, _symbolic_clone(left), "subtractive_identity", "applied", "operand_source_domain_retained", left, ordinal)
    same(left, right) /\ _symbolic_mathematical_total(left)?
        @: _symbolic_inspection_rule(source, _symbolic_raw_number(0), "self_difference", "applied", "total_scalar_domain", left, ordinal)
    _symbolic_inspection_rule(source, left - right, "subtract_unchanged", "unchanged", "source_domain_retained", source, ordinal)

_symbolic_subtract_simplified(left:symbolic, right:symbolic) -> symbolic:
    _symbolic_subtract_inspection(left, right, -1).expression

_symbolic_multiply_inspection(left:symbolic, right:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    source: _symbolic_inspection_binary_source(left, right, 3, ordinal)
    _symbolic_is_finite_raw_number(left) /\ _symbolic_is_finite_raw_number(right)?
        result: _symbolic_raw_number(_symbolic_number_value(left) * _symbolic_number_value(right))
        _symbolic_is_finite_raw_number(result)?
            @: _symbolic_inspection_rule(source, result, "known_numeric_multiply", "applied", "finite_literal_region", source, ordinal)
    _symbolic_is_finite_raw_number(left) /\ _symbolic_root_kind(_symbolic_clone(right)) = 3 /\ _symbolic_root_operation(_symbolic_clone(right)) = 4?
        denominator: _symbolic_right(_symbolic_clone(right))
        _symbolic_is_finite_raw_number(denominator) /\ _symbolic_number_value(denominator) != 0?
            numerator: _symbolic_left(right)
            _symbolic_mathematical_total(numerator)?
                scale: _symbolic_raw_number(_symbolic_number_value(left) / _symbolic_number_value(denominator))
                _symbolic_is_finite_raw_number(scale)?
                    nested: _symbolic_multiply_inspection(scale, numerator, ordinal)
                    ordinal < 0? @: nested
                    step: _symbolic_inspection_step(source, nested.expression, "constant_quotient_scale", "applied", "finite_nonzero_denominator_and_total_numerator", source, ordinal + nested.steps.length())
                    @: (expression:nested.expression, steps:nested.steps & [step])
    _symbolic_is_finite_raw_number(right) /\ _symbolic_root_kind(_symbolic_clone(left)) = 3 /\ _symbolic_root_operation(_symbolic_clone(left)) = 4?
        denominator: _symbolic_right(_symbolic_clone(left))
        _symbolic_is_finite_raw_number(denominator) /\ _symbolic_number_value(denominator) != 0?
            numerator: _symbolic_left(left)
            _symbolic_mathematical_total(numerator)?
                scale: _symbolic_raw_number(_symbolic_number_value(right) / _symbolic_number_value(denominator))
                _symbolic_is_finite_raw_number(scale)?
                    nested: _symbolic_multiply_inspection(scale, numerator, ordinal)
                    ordinal < 0? @: nested
                    step: _symbolic_inspection_step(source, nested.expression, "constant_quotient_scale", "applied", "finite_nonzero_denominator_and_total_numerator", source, ordinal + nested.steps.length())
                    @: (expression:nested.expression, steps:nested.steps & [step])
    _symbolic_is_raw_number(_symbolic_clone(left), 0) /\ _symbolic_mathematical_total(right)?
        @: _symbolic_inspection_rule(source, _symbolic_raw_number(0), "zero_product", "applied", "total_scalar_domain", right, ordinal)
    _symbolic_is_raw_number(_symbolic_clone(right), 0) /\ _symbolic_mathematical_total(left)?
        @: _symbolic_inspection_rule(source, _symbolic_raw_number(0), "zero_product", "applied", "total_scalar_domain", left, ordinal)
    _symbolic_is_raw_number(left, 1)?
        @: _symbolic_inspection_rule(source, _symbolic_clone(right), "multiplicative_left_identity", "applied", "operand_source_domain_retained", right, ordinal)
    _symbolic_is_raw_number(right, 1)?
        @: _symbolic_inspection_rule(source, _symbolic_clone(left), "multiplicative_right_identity", "applied", "operand_source_domain_retained", left, ordinal)
    _symbolic_inspection_rule(source, left * right, "multiply_unchanged", "unchanged", "source_domain_retained", source, ordinal)

_symbolic_multiply_simplified(left:symbolic, right:symbolic) -> symbolic:
    _symbolic_multiply_inspection(left, right, -1).expression

_symbolic_divide_inspection(left:symbolic, right:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    source: _symbolic_inspection_binary_source(left, right, 4, ordinal)
    _symbolic_is_finite_raw_number(left) /\ _symbolic_is_finite_raw_number(right)?
        _symbolic_number_value(right) != 0?
            result: _symbolic_raw_number(_symbolic_number_value(left) / _symbolic_number_value(right))
            _symbolic_is_finite_raw_number(result)?
                @: _symbolic_inspection_rule(source, result, "known_numeric_divide", "applied", "finite_nonzero_denominator", right, ordinal)
    _symbolic_is_raw_number(left, 0) /\ _symbolic_is_finite_raw_number(right)?
        _symbolic_number_value(right) != 0?
            @: _symbolic_inspection_rule(source, _symbolic_raw_number(0), "zero_quotient", "applied", "finite_nonzero_denominator", right, ordinal)
    _symbolic_is_raw_number(right, 1)?
        @: _symbolic_inspection_rule(source, _symbolic_clone(left), "division_unit_identity", "applied", "operand_source_domain_retained", left, ordinal)
    _symbolic_inspection_rule(source, left / right, "divide_unchanged", "unchanged", "nonzero_denominator_retained", source, ordinal)

_symbolic_divide_simplified(left:symbolic, right:symbolic) -> symbolic:
    _symbolic_divide_inspection(left, right, -1).expression

_symbolic_power_inspection(base:symbolic, exponent:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    source: _symbolic_inspection_binary_source(base, exponent, 5, ordinal)
    _symbolic_is_finite_raw_number(base) /\ _symbolic_is_finite_raw_number(exponent)?
        _symbolic_number_value(base) != 0 \/ _symbolic_number_value(exponent) = 0 \/ (_symbolic_number_value(exponent) = m.abs(_symbolic_number_value(exponent)) /\ _symbolic_number_value(exponent) > 0)?
            result: _symbolic_raw_number(_symbolic_number_value(base) ^ _symbolic_number_value(exponent))
            _symbolic_is_finite_raw_number(result)?
                @: _symbolic_inspection_rule(source, result, "known_numeric_power", "applied", "literal_power_domain", source, ordinal)
    _symbolic_is_raw_number(exponent, 0) /\ _symbolic_mathematical_total(base)?
        @: _symbolic_inspection_rule(source, _symbolic_raw_number(1), "zero_exponent", "applied", "total_scalar_domain", base, ordinal)
    _symbolic_is_raw_number(exponent, 1)?
        @: _symbolic_inspection_rule(source, _symbolic_clone(base), "power_unit_identity", "applied", "operand_source_domain_retained", base, ordinal)
    _symbolic_inspection_rule(source, base ^ exponent, "power_unchanged", "unchanged", "power_domain_retained", source, ordinal)

_symbolic_power_simplified(base:symbolic, exponent:symbolic) -> symbolic:
    _symbolic_power_inspection(base, exponent, -1).expression

depends_on(value:symbolic, variable:symbolic) -> bit:
    ~(_symbolic_root_kind(variable) = 1)?
        errors.TypeError("symbolic.depends_on variable must be a symbol")!
    catalog: _symbolic_catalog(value)
    _symbolic_catalog_entry_index(catalog, _symbolic_raw_catalog(variable)) >= 0

depends_on(variable_name:chr, value:symbolic) -> bit:
    depends_on(value, _symbolic_suffix_variable(value, variable_name))

_symbolic_univariate_as_polynomial(value:symbolic) -> symbolic:
    catalog: _symbolic_catalog(value)
    count: value.(_symbolic_univariate_count_index(value))
    width: 2
    terms: [0:count * width]
    coefficient_start: _symbolic_univariate_coefficient_start(value)
    capacity: _symbolic_univariate_capacity(value)
    output: 0
    ..capacity - 1 >>
        coefficient_value: value.(coefficient_start + $)
        ~(coefficient_value = 0)?
            terms.(output * width): coefficient_value
            terms.(output * width + 1): $
            .output+: 1
    total_length: 3 + catalog.length() + 1 + terms.length() + 3
    [num] header: [4, catalog.length(), 1]
    [num] count_header: [count]
    [num] trailer: [4, 0, total_length]
    result: header & catalog & count_header & terms & trailer
    result

# Real-part differentiation is a real-direction rule. A complex selected
# formal cannot receive it merely because a numeric operand happens tobereal.
_symbolic_differentiation_real_formal(variable:symbolic) -> bit:
    domain:_symbolic_domain(variable)
    domain=_symbolic_domain_natural \/ domain=_symbolic_domain_integer \/ domain=_symbolic_domain_rational \/ domain=_symbolic_domain_real

# This bounded proof uses actual catalogue domains and finite real constants.
# It establishes real values where the source is defined, never nonzero values
# or permission to evaluate a partial expression. Existing source guards remain.
_symbolic_magnitude_real_inner(value:symbolic) -> bit:
    dag: _symbolic_as_dag(value)
    count: _symbolic_dag_node_count(dag)
    count < 1 \/ count > 4096? @: false
    [num] real_nodes: [..count - 1 >> 0]
    ..count - 1 >>
        node: $
        operation: _symbolic_dag_node_operation(dag,node)
        operation = 1?
            _symbolic_differentiation_real_formal(_symbolic_dag_with_root(dag,node))? real_nodes.(node):1
        operation = 2?
            constant:_symbolic_dag_with_root(dag,node)
            numeric:_symbolic_number_value(constant)
            _symbolic_is_finite_raw_number(constant) /\ m.real_part(numeric)=numeric? real_nodes.(node):1
        operation >= 3 /\ operation <= 6?
            left:_symbolic_dag_node_left(dag,node)
            right:_symbolic_dag_node_right(dag,node)
            left >= 0 /\ right >= 0 /\ left < node /\ right < node?
                real_nodes.(left)=1 /\ real_nodes.(right)=1? real_nodes.(node):1
    real_nodes.(_symbolic_dag_root(dag))=1

# Executed calculus branch snapshots, not domain or execution proofs.
_symbolic_calculus_next(ordinal:num, size:num) -> num:
    ordinal < 0? @: -1
    ordinal + size

_symbolic_calculus_finish(source:symbolic, result:symbolic, rule:str, steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)], variable:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    ordinal < 0? @: (expression:result, steps:[])
    receipt: _symbolic_inspection_rule(source, result, rule, "represented", "original_source_domain_retained", variable, ordinal + steps.length())
    (expression:receipt.expression, steps:steps & receipt.steps)

_symbolic_calculus_polynomial_single_term(catalog:[num], variables:num, cells:[num]) -> symbolic:
    [num] result: [4, catalog.length(), variables] & catalog & [1] & cells & [4, 0, catalog.length() + cells.length() + 7]
    result

_symbolic_calculus_polynomial_term_snapshot(value:symbolic, term:num) -> symbolic:
    catalog: _symbolic_catalog(value)
    variables: _symbolic_polynomial_variable_count(value)
    start: 4 + value.1 + term * (variables + 1)
    [num] cells: [..variables >> value.(start + $)]
    _symbolic_calculus_polynomial_single_term(catalog, variables, cells)

_symbolic_integrate_polynomial_inspection(value:symbolic, variable:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    catalog: _symbolic_catalog(value)
    target: _symbolic_catalog_entry_index(catalog, _symbolic_raw_catalog(variable))
    target < 0?
        @: _symbolic_calculus_finish(value, _symbolic_polynomial_multiply(value, _symbolic_pack_symbol(variable)), "integrate_polynomial_variable_absent", steps, variable, ordinal)
    variable_count: _symbolic_polynomial_variable_count(value)
    source_terms: _symbolic_polynomial_term_count(value)
    ordinal >= 0 /\ (source_terms + 1 > 4096 \/ (source_terms + 1) * (value.length() + variable.length() + catalog.length() + 2 * variable_count + 16) > 1048576)?
        errors.ValueError("symbolic calculus inspection snapshot budget exceeded")!
    width: variable_count + 1
    terms: [0:source_terms * width]
    ..source_terms - 1 >>
        source: $
        exponent: _symbolic_polynomial_term_exponent(value, source, target)
        offset: source * width
        terms.(offset): _symbolic_polynomial_term_coefficient(value, source) / (exponent + 1)
        ..variable_count - 1 >>
            terms.(offset + $ + 1): _symbolic_polynomial_term_exponent(value, source, $)
        terms.(offset + target + 1): exponent + 1
        ordinal >= 0?
            source_snapshot: _symbolic_calculus_polynomial_term_snapshot(value, source)
            term_cells: [..width - 1 >> terms.(offset + $)]
            result_snapshot: _symbolic_calculus_polynomial_single_term(catalog, variable_count, term_cells)
            receipt: _symbolic_inspection_rule(source_snapshot, result_snapshot, "integrate_polynomial_term_write", "represented", "original_source_domain_retained", variable, ordinal + steps.length())
            .steps: steps & receipt.steps
    total_length: 3 + catalog.length() + 1 + terms.length() + 3
    [num] header: [4, catalog.length(), variable_count]
    [num] count_header: [source_terms]
    [num] trailer: [4, 0, total_length]
    result: _symbolic_owned_cells(header & catalog & count_header & terms & trailer)
    _symbolic_calculus_finish(value, result, "integrate_polynomial_result", steps, variable, ordinal)

_symbolic_integrate_polynomial(value:symbolic, variable:symbolic) -> symbolic:
    _symbolic_integrate_polynomial_inspection(value, variable, -1).expression

_symbolic_integrate_raw_inspection(value:symbolic, variable:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    kind: _symbolic_root_kind(value)
    kind = 1?
        same(_symbolic_clone(value), _symbolic_clone(variable))?
            arithmetic_view_0: _symbolic_power_inspection(variable, _symbolic_raw_number(2), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_0.steps
            square: arithmetic_view_0.expression
            arithmetic_view_1: _symbolic_divide_inspection(square, _symbolic_raw_number(2), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_1.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_1.expression, "integrate_symbol_self", steps, variable, ordinal)
        arithmetic_view_2: _symbolic_multiply_inspection(value, variable, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_2.steps
        @: _symbolic_calculus_finish(value, arithmetic_view_2.expression, "integrate_symbol_other", steps, variable, ordinal)
    kind = 2?
        arithmetic_view_3: _symbolic_multiply_inspection(value, variable, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_3.steps
        @: _symbolic_calculus_finish(value, arithmetic_view_3.expression, "integrate_constant", steps, variable, ordinal)
    kind = 7?
        operation: _symbolic_root_operation(_symbolic_clone(value))
        argument: _symbolic_argument(value)
        ~same(_symbolic_clone(argument), _symbolic_clone(variable))?
            errors.TypeError("symbolic.integrate does not support this function argument")!
        operation = 1?
            arithmetic_view_4: _symbolic_multiply_inspection(_symbolic_raw_number(-1), cos(variable), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_4.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_4.expression, "integrate_sine", steps, variable, ordinal)
        operation = 2?
            @: _symbolic_calculus_finish(value, sin(variable), "integrate_cosine", steps, variable, ordinal)
        operation = 3?
            arithmetic_view_5: _symbolic_multiply_inspection(variable, log(variable), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_5.steps
            product: arithmetic_view_5.expression
            arithmetic_view_6: _symbolic_subtract_inspection(product, variable, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_6.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_6.expression, "integrate_log", steps, variable, ordinal)
        operation = 4 /\ _symbolic_differentiation_real_formal(variable)?
            # Original sqrt source/role is retained by this invocation. The
            # actual existing power integrator executes once on the scoped view.
            power_view: _symbolic_power_inspection(variable, _symbolic_raw_number(0.5), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & power_view.steps
            power_integral: _symbolic_integrate_raw_inspection(power_view.expression, variable, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & power_integral.steps
            @: _symbolic_calculus_finish(value, power_integral.expression, "integrate_real_sqrt_power_bridge", steps, variable, ordinal)
        operation = 5?
            @: _symbolic_calculus_finish(value, exp(variable), "integrate_exp", steps, variable, ordinal)
        errors.TypeError("symbolic.integrate does not support this function")!
    ~(kind = 3)?
        errors.TypeError("symbolic.integrate received an unsupported expression kind")!
    operation: _symbolic_root_operation(_symbolic_clone(value))
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    operation = 1?
        left_view: _symbolic_integrate_raw_inspection(left, variable, ordinal)
        right_view: _symbolic_integrate_raw_inspection(right, variable, _symbolic_calculus_next(ordinal, left_view.steps.length()))
        .steps: left_view.steps & right_view.steps
        arithmetic_view_7: _symbolic_add_inspection(left_view.expression, right_view.expression, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_7.steps
        @: _symbolic_calculus_finish(value, arithmetic_view_7.expression, "integrate_add", steps, variable, ordinal)
    operation = 2?
        left_view: _symbolic_integrate_raw_inspection(left, variable, ordinal)
        right_view: _symbolic_integrate_raw_inspection(right, variable, _symbolic_calculus_next(ordinal, left_view.steps.length()))
        .steps: left_view.steps & right_view.steps
        arithmetic_view_8: _symbolic_subtract_inspection(left_view.expression, right_view.expression, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_8.steps
        @: _symbolic_calculus_finish(value, arithmetic_view_8.expression, "integrate_subtract", steps, variable, ordinal)
    operation = 3?
        ~depends_on(_symbolic_clone(left), _symbolic_clone(variable))?
            child_view: _symbolic_integrate_raw_inspection(right, variable, ordinal)
            .steps: child_view.steps
            arithmetic_view_9: _symbolic_multiply_inspection(left, child_view.expression, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_9.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_9.expression, "integrate_left_constant_product", steps, variable, ordinal)
        ~depends_on(_symbolic_clone(right), _symbolic_clone(variable))?
            child_view: _symbolic_integrate_raw_inspection(left, variable, ordinal)
            .steps: child_view.steps
            arithmetic_view_10: _symbolic_multiply_inspection(right, child_view.expression, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_10.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_10.expression, "integrate_right_constant_product", steps, variable, ordinal)
        errors.TypeError("symbolic.integrate does not support products with two variable-dependent factors")!
    operation = 4?
        ~depends_on(_symbolic_clone(left), _symbolic_clone(variable)) /\ same(_symbolic_clone(right), _symbolic_clone(variable))?
            arithmetic_view_11: _symbolic_multiply_inspection(left, log(variable), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_11.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_11.expression, "integrate_reciprocal_scale", steps, variable, ordinal)
        errors.TypeError("symbolic.integrate does not support this quotient")!
    operation = 5?
        same(_symbolic_clone(left), _symbolic_clone(variable)) /\ _symbolic_root_kind(_symbolic_clone(right)) = 2?
            exponent: _symbolic_number_value(_symbolic_clone(right))
            exponent = -1?
                @: _symbolic_calculus_finish(value, log(variable), "integrate_negative_unit_power", steps, variable, ordinal)
            arithmetic_view_12: _symbolic_power_inspection(variable, _symbolic_raw_number(exponent + 1), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_12.steps
            raised: arithmetic_view_12.expression
            arithmetic_view_13: _symbolic_divide_inspection(raised, _symbolic_raw_number(exponent + 1), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_13.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_13.expression, "integrate_numeric_power", steps, variable, ordinal)
        errors.TypeError("symbolic.integrate does not support this power")!
    errors.TypeError("symbolic.integrate received an unsupported operation")!

_symbolic_integrate_raw(value:symbolic, variable:symbolic) -> symbolic:
    _symbolic_integrate_raw_inspection(value, variable, -1).expression

_symbolic_integrate_inspection(value:symbolic, variable:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    ~(_symbolic_root_kind(variable) = 1)?
        errors.TypeError("symbolic.integrate variable must be a symbol")!
    kind: _symbolic_root_kind(value)
    kind = 4?
        @: _symbolic_integrate_polynomial_inspection(value, variable, ordinal)
    kind = 6?
        polynomial_value: _symbolic_univariate_as_polynomial(value)
        ordinal >= 0?
            receipt: _symbolic_inspection_rule(value, polynomial_value, "integrate_univariate_to_polynomial", "represented", "original_source_domain_retained", variable, ordinal)
            .steps: receipt.steps
        child_view: _symbolic_integrate_polynomial_inspection(polynomial_value, variable, _symbolic_calculus_next(ordinal, steps.length()))
        @: (expression:child_view.expression, steps:steps & child_view.steps)
    _symbolic_integrate_raw_inspection(value, variable, ordinal)

integrate(value:symbolic, variable:symbolic) -> symbolic:
    _symbolic_integrate_inspection(value, variable, -1).expression

inspect_integrate(value:symbolic, variable:symbolic) -> (source:symbolic,expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)],domain:(scope:str,execution_checked:bit),ordinal_scope:str,numerical_requirement:str,execution_authority:bit):
    view: _symbolic_integrate_inspection(value, variable, 0)
    (source:_symbolic_clone(value), expression:view.expression, steps:view.steps,
     domain:(scope:"original source obligations retained; calculus is conditional on declared domains and operator admissibility", execution_checked:false),
     ordinal_scope:"local to this owned inspection invocation", numerical_requirement:"exact_algebra", execution_authority:false)

integrate(variable_name:chr, value:symbolic) -> symbolic:
    integrate(value, _symbolic_suffix_variable(value, variable_name))

integ(variable_name:chr, value:symbolic) -> symbolic:
    integrate(value, _symbolic_suffix_variable(value, variable_name))

integ(variable_names:[chr], value:symbolic) -> symbolic:
    result: _symbolic_clone(value)
    index: 0
    index < variable_names.length()?>
        .result: integrate(
            result,
            _symbolic_suffix_variable(_symbolic_clone(result), variable_names.(index))
        )
        .index+: 1
    result

_sum(variable_name:chr,
    value:symbolic,
    from:num,
    to:num,
    step:num = 1
) -> symbolic:
    step != 0?! "stat.sum symbolic step must be non-zero"
    ((step > 0 /\ from > to) \/ (step < 0 /\ from < to))? @: constant(0)
    raw_count: (to - from) / step
    count: raw_count // 1
    raw_count >= 0?
        .count: (raw_count + 0.5) // 1
    raw_count < 0?
        .count: (raw_count - 0.5) // 1
    m.abs(raw_count - count) < 0.000000001?! "stat.sum symbolic bounds must differ by an integral number of steps"
    variable: _symbolic_suffix_variable(_symbolic_clone(value), variable_name)
    result: constant(0)
    index: 0
    index <= count?>
        point: constant(from + index * step)
        term: substitute(_symbolic_clone(value), _symbolic_clone(variable), point)
        .result: _symbolic_add_simplified(result, term)
        .index+: 1
    result

_symbolic_numerical_integ_index_bounds(
    values:[num:n],
    spacing:num = 1,
    lower:num = 0,
    upper:num = -1
) -> num:
    count: values.length()
    count < 2? @: 0
    spacing > 0?! "symbolic.integ spacing must be positive"
    upper < 0?
        .upper: count - 1
    (lower % 1 = 0 /\ upper % 1 = 0)?! "symbolic.integ index bounds must be integers"
    (lower >= 0 /\ lower < count /\ upper >= 0 /\ upper < count)?! "symbolic.integ index bounds are out of range"
    start: lower
    end: upper
    orientation: 1
    lower > upper?
        .start: upper
        .end: lower
        .orientation: -1
    total: 0
    index: start
    index < end?>
        .total+: (values.(index) + values.(index + 1)) * spacing / 2
        .index+: 1
    total * orientation

integ(axis:chr, values:[num:n], spacing:num = 1) -> num:
    _symbolic_numerical_integ_index_bounds(values, spacing)

_symbolic_numerical_integ_indices(axis:chr,
    values:[num:n],
    spacing:num = 1,
    lower:num = 0,
    upper:num = -1
) -> num:
    _symbolic_numerical_integ_index_bounds(values, spacing, lower, upper)

_symbolic_numerical_trapezoid_clipped(
    source_coordinate:num,
    source_value:num,
    target_coordinate:num,
    target_value:num,
    lower:num,
    upper:num
) -> num:
    segment_lower: source_coordinate
    segment_upper: target_coordinate
    source_coordinate > target_coordinate?
        .segment_lower: target_coordinate
        .segment_upper: source_coordinate
    segment_lower < lower?
        .segment_lower: lower
    segment_upper > upper?
        .segment_upper: upper
    segment_lower >= segment_upper? @: 0
    slope: (target_value - source_value) / (target_coordinate - source_coordinate)
    lower_value: source_value + slope * (segment_lower - source_coordinate)
    upper_value: source_value + slope * (segment_upper - source_coordinate)
    (lower_value + upper_value) * (segment_upper - segment_lower) / 2

_symbolic_numerical_integ_coordinate_bounds(
    values:[num:n],
    coordinates:[num:m],
    lower:num,
    upper:num
) -> num:
    count: values.length()
    (count = coordinates.length())?! "symbolic.integ coordinate count must match values"
    count < 2? @: 0
    direction: coordinates.1 - coordinates.0
    direction != 0?! "symbolic.integ coordinates must be strictly monotonic"
    index: 1
    index < count - 1?>
        step: coordinates.(index + 1) - coordinates.(index)
        (step != 0 /\ step * direction > 0)?! "symbolic.integ coordinates must be strictly monotonic"
        .index+: 1
    coordinate_min: coordinates.0
    coordinate_max: coordinates.(count - 1)
    direction < 0?
        .coordinate_min: coordinates.(count - 1)
        .coordinate_max: coordinates.0
    (lower >= coordinate_min /\ lower <= coordinate_max /\ upper >= coordinate_min /\ upper <= coordinate_max)?! "symbolic.integ coordinate bounds are outside the coordinate range"
    start: lower
    end: upper
    orientation: 1
    lower > upper?
        .start: upper
        .end: lower
        .orientation: -1
    total: 0
    .index: 0
    index < count - 1?>
        .total+: _symbolic_numerical_trapezoid_clipped(
            coordinates.(index),
            values.(index),
            coordinates.(index + 1),
            values.(index + 1),
            start,
            end
        )
        .index+: 1
    total * orientation

integ(axis:chr, values:[num:n], coordinates:[num:m]) -> num:
    count: coordinates.length()
    count < 2? @: 0
    first: coordinates.0
    last: coordinates.(count - 1)
    first <= last?
        @: _symbolic_numerical_integ_coordinate_bounds(values, coordinates, first, last)
    _symbolic_numerical_integ_coordinate_bounds(values, coordinates, last, first)

_symbolic_numerical_integ_coordinates_lower(axis:chr,
    values:[num:n],
    coordinates:[num:m],
    lower:num
) -> num:
    count: coordinates.length()
    count < 2? @: 0
    upper: coordinates.0
    coordinates.(count - 1) > upper?
        .upper: coordinates.(count - 1)
    _symbolic_numerical_integ_coordinate_bounds(values, coordinates, lower, upper)

_symbolic_numerical_integ_coordinates_upper(axis:chr,
    values:[num:n],
    coordinates:[num:m],
    upper:num
) -> num:
    count: coordinates.length()
    count < 2? @: 0
    lower: coordinates.0
    coordinates.(count - 1) < lower?
        .lower: coordinates.(count - 1)
    _symbolic_numerical_integ_coordinate_bounds(values, coordinates, lower, upper)

_symbolic_numerical_integ_coordinates_bounds(axis:chr,
    values:[num:n],
    coordinates:[num:m],
    lower:num,
    upper:num
) -> num:
    _symbolic_numerical_integ_coordinate_bounds(values, coordinates, lower, upper)

_symbolic_differentiate_polynomial_inspection(value:symbolic, variable:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    catalog: _symbolic_catalog(value)
    target_entry: _symbolic_raw_catalog(variable)
    target: _symbolic_catalog_entry_index(catalog, target_entry)
    variable_count: _symbolic_polynomial_variable_count(value)
    source_terms: _symbolic_polynomial_term_count(value)
    ordinal >= 0 /\ (source_terms * 2 + 1 > 4096 \/ (source_terms * 2 + 1) * (value.length() + variable.length() + catalog.length() + 2 * variable_count + 16) > 1048576)?
        errors.ValueError("symbolic calculus inspection snapshot budget exceeded")!
    kept: 0
    target >= 0?
        ..source_terms - 1 >>
            _symbolic_polynomial_term_exponent(value, $, target) > 0?
                .kept+: 1
            ordinal >= 0?
                source_snapshot: _symbolic_calculus_polynomial_term_snapshot(value, $)
                branch: "differentiate_polynomial_term_constant"
                _symbolic_polynomial_term_exponent(value, $, target) > 0?
                    .branch: "differentiate_polynomial_term_selected"
                receipt: _symbolic_inspection_rule(source_snapshot, source_snapshot, branch, "represented", "original_source_domain_retained", variable, ordinal + steps.length())
                .steps: steps & receipt.steps
    width: variable_count + 1
    terms: [0:kept * width]
    output: 0
    source: 0
    exponent: 0
    offset: 0
    target >= 0?
        ..source_terms - 1 >>
            .source: $
            .exponent: _symbolic_polynomial_term_exponent(value, source, target)
            exponent > 0?
                .offset: output * width
                terms.(offset): _symbolic_polynomial_term_coefficient(value, source) * exponent
                ..variable_count - 1 >>
                    terms.(offset + $ + 1): _symbolic_polynomial_term_exponent(value, source, $)
                terms.(offset + target + 1): exponent - 1
                ordinal >= 0?
                    source_snapshot: _symbolic_calculus_polynomial_term_snapshot(value, source)
                    term_cells: [..width - 1 >> terms.(offset + $)]
                    result_snapshot: _symbolic_calculus_polynomial_single_term(catalog, variable_count, term_cells)
                    receipt: _symbolic_inspection_rule(source_snapshot, result_snapshot, "differentiate_polynomial_term_write", "represented", "original_source_domain_retained", variable, ordinal + steps.length())
                    .steps: steps & receipt.steps
                .output+: 1
    total_length: 3 + catalog.length() + 1 + terms.length() + 3
    [num] header: [4, catalog.length(), variable_count]
    [num] count_header: [kept]
    [num] trailer: [4, 0, total_length]
    result: _symbolic_owned_cells(header & catalog & count_header & terms & trailer)
    branch: "differentiate_polynomial_result"
    target < 0? .branch: "differentiate_polynomial_variable_absent"
    _symbolic_calculus_finish(value, result, branch, steps, variable, ordinal)

_symbolic_differentiate_polynomial(value:symbolic, variable:symbolic) -> symbolic:
    _symbolic_differentiate_polynomial_inspection(value, variable, -1).expression

_symbolic_differentiate_univariate_inspection(value:symbolic, variable:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    result: _symbolic_clone(value)
    capacity: _symbolic_univariate_capacity(value)
    count_index: _symbolic_univariate_count_index(value)
    coefficient_start: _symbolic_univariate_coefficient_start(value)
    result.(count_index): 0
    ..capacity - 1 >>
        result.(coefficient_start + $): 0
    target: _symbolic_catalog_entry_index(_symbolic_catalog(value), _symbolic_raw_catalog(variable))
    ordinal >= 0 /\ (capacity > 4096 \/ capacity * (value.length() + variable.length() + 16) > 1048576)?
        errors.ValueError("symbolic calculus inspection snapshot budget exceeded")!
    target < 0?
        @: _symbolic_calculus_finish(value, result, "differentiate_univariate_variable_absent", steps, variable, ordinal)
    exponent: 1
    exponent < capacity?>
        differentiated: value.(coefficient_start + exponent) * exponent
        result.(coefficient_start + exponent - 1): differentiated
        ~(differentiated = 0)?
            result.(count_index): result.(count_index) + 1
        ordinal >= 0?
            source_snapshot: _symbolic_inspection_binary_source(_symbolic_raw_number(value.(coefficient_start + exponent)), _symbolic_raw_number(exponent), 3, ordinal)
            receipt: _symbolic_inspection_rule(source_snapshot, _symbolic_raw_number(differentiated), "differentiate_univariate_coefficient_write", "represented", "original_source_domain_retained", variable, ordinal + steps.length())
            .steps: steps & receipt.steps
        .exponent+: 1
    _symbolic_calculus_finish(value, result, "differentiate_univariate_result", steps, variable, ordinal)

_symbolic_differentiate_univariate(value:symbolic, variable:symbolic) -> symbolic:
    _symbolic_differentiate_univariate_inspection(value, variable, -1).expression

_symbolic_calculus_dag_emission_receipt(nodes:[num], catalog:[num], cursor:num, index:num, next:num, operation:num, left:num, right:num, rule:str, ordinal:num) -> (index:num,next:num,nodes:[num],steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    ordinal < 0? @: (index:index, next:next, nodes:nodes, steps:[])
    [num] prefix: [..cursor * 4 - 1 >> nodes.($)]
    source: _symbolic_raw_number(0)
    operation = 2?
        .source: _symbolic_raw_number(nodes.(cursor * 4 + 3))
    operation >= 3 /\ operation <= 7?
        left_source: _symbolic_dag_make(catalog, prefix, left)
        right_source: _symbolic_dag_make(catalog, prefix, right)
        .source: _symbolic_inspection_binary_source(left_source, right_source, operation - 2, ordinal)
    operation >= 8?
        argument: _symbolic_dag_make(catalog, prefix, left)
        unary: operation - 7
        operation = 25? .unary: 6
        operation = 26? .unary: 7
        .source: _symbolic_inspection_unary_source(argument, unary, ordinal)
    [num] used: [..next * 4 - 1 >> nodes.($)]
    result: _symbolic_dag_make(catalog, used, index)
    receipt: _symbolic_inspection_rule(source, result, rule, "represented", "original_source_domain_retained", source, ordinal)
    (index:index, next:next, nodes:nodes, steps:receipt.steps)

_symbolic_dag_emit_constant_inspection(nodes:[num], cursor:num, value:num, catalog:[num], ordinal:num) -> (index:num,next:num,nodes:[num],steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    offset: cursor * 4
    nodes.(offset): 2
    nodes.(offset + 1): 0
    nodes.(offset + 2): 0
    nodes.(offset + 3): value
    _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, cursor, cursor + 1, 2, 0, 0, "dag_constant_emit", ordinal)

_symbolic_dag_erasure_operand(nodes:[num],cursor:num,catalog:[num],index:num) -> symbolic:
    # A proof view is allocated only for an actual candidate that would erase
    # this operand. Ordinary addition/unit identity/emission needs no view.
    [num] used: [..cursor * 4 - 1 >> nodes.($)]
    _symbolic_dag_make(catalog,used,index)

_symbolic_dag_emit_binary_inspection(
    nodes:[num],
    cursor:num,
    operation:num,
    left:num,
    right:num,
    zero:num,
    one:num,
    catalog:[num],
    ordinal:num
) -> (index:num,next:num,nodes:[num],steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    operation = 3?
        left = zero? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, right, cursor, operation, left, right, "dag_additive_left_identity", ordinal)
        right = zero? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, left, cursor, operation, left, right, "dag_additive_right_identity", ordinal)
    operation = 4?
        right = zero? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, left, cursor, operation, left, right, "dag_subtractive_identity", ordinal)
        left = right?
            left_obligation: _symbolic_dag_erasure_operand(nodes,cursor,catalog,left)
            _symbolic_mathematical_total(left_obligation)? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, zero, cursor, operation, left, right, "dag_self_difference", ordinal)
    operation = 5?
        left = zero?
            right_obligation: _symbolic_dag_erasure_operand(nodes,cursor,catalog,right)
            _symbolic_mathematical_total(right_obligation)? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, zero, cursor, operation, left, right, "dag_zero_product", ordinal)
        right = zero?
            left_obligation: _symbolic_dag_erasure_operand(nodes,cursor,catalog,left)
            _symbolic_mathematical_total(left_obligation)? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, zero, cursor, operation, left, right, "dag_zero_product", ordinal)
        left = one? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, right, cursor, operation, left, right, "dag_multiplicative_left_identity", ordinal)
        right = one? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, left, cursor, operation, left, right, "dag_multiplicative_right_identity", ordinal)
    operation = 6?
        left = zero?
            right_obligation: _symbolic_dag_erasure_operand(nodes,cursor,catalog,right)
            _symbolic_is_finite_raw_number(right_obligation)?
                _symbolic_number_value(right_obligation) != 0? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, zero, cursor, operation, left, right, "dag_zero_quotient", ordinal)
        right = one? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, left, cursor, operation, left, right, "dag_division_unit_identity", ordinal)
    operation = 7?
        right = zero?
            left_obligation: _symbolic_dag_erasure_operand(nodes,cursor,catalog,left)
            _symbolic_mathematical_total(left_obligation)? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, one, cursor, operation, left, right, "dag_zero_exponent", ordinal)
        right = one? @: _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, left, cursor, operation, left, right, "dag_power_unit_identity", ordinal)
    offset: cursor * 4
    nodes.(offset): operation
    nodes.(offset + 1): left
    nodes.(offset + 2): right
    nodes.(offset + 3): 0
    _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, cursor, cursor + 1, operation, left, right, "dag_binary_emit", ordinal)

_symbolic_dag_emit_unary_inspection(nodes:[num], cursor:num, operation:num, argument:num, catalog:[num], ordinal:num) -> (index:num,next:num,nodes:[num],steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    offset: cursor * 4
    nodes.(offset): operation
    nodes.(offset + 1): argument
    nodes.(offset + 2): 0
    nodes.(offset + 3): 0
    _symbolic_calculus_dag_emission_receipt(nodes, catalog, cursor, cursor, cursor + 1, operation, argument, 0, "dag_unary_emit", ordinal)

_symbolic_dag_emit_constant(nodes:[num], cursor:num, value:num):
    result: _symbolic_dag_emit_constant_inspection(nodes, cursor, value, [], -1)
    (index:result.index, next:result.next, nodes:result.nodes)

_symbolic_dag_emit_binary(nodes:[num], cursor:num, operation:num, left:num, right:num, zero:num, one:num):
    result: _symbolic_dag_emit_binary_inspection(nodes, cursor, operation, left, right, zero, one, [], -1)
    (index:result.index, next:result.next, nodes:result.nodes)

_symbolic_dag_emit_unary(nodes:[num], cursor:num, operation:num, argument:num):
    result: _symbolic_dag_emit_unary_inspection(nodes, cursor, operation, argument, [], -1)
    (index:result.index, next:result.next, nodes:result.nodes)

_symbolic_differentiate_dag_inspection(value:symbolic, variable:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    catalog: _symbolic_dag_catalog(value)
    variable_count: _symbolic_catalog_variable_count(catalog)
    identity: [0:variable_count]
    variable_count > 0?
        ..variable_count - 1 >> identity.($): $
    source_count: _symbolic_dag_node_count(value)
    capacity: source_count * 7 + 8
    nodes: [0:capacity * 4]
    source_start: _symbolic_dag_node_start(value)
    source_width: source_count * 4
    source_width > 0?
        ..source_width - 1 >> nodes.($): value.(source_start + $)
    cursor: source_count
    ordinal >= 0 /\ (8 * source_count + 5 > 4096 \/ (8 * source_count + 5) * (value.length() + variable.length() + 6 * (catalog.length() + capacity * 4 + 8)) > 1048576)?
        errors.ValueError("symbolic calculus inspection snapshot budget exceeded")!
    emitted: _symbolic_dag_emit_constant_inspection(nodes, cursor, 0, catalog, _symbolic_calculus_next(ordinal, steps.length()))
    .nodes: emitted.nodes
    .steps: steps & emitted.steps
    zero: emitted.index
    .cursor: emitted.next
    .emitted: _symbolic_dag_emit_constant_inspection(nodes, cursor, 1, catalog, _symbolic_calculus_next(ordinal, steps.length()))
    .nodes: emitted.nodes
    .steps: steps & emitted.steps
    one: emitted.index
    .cursor: emitted.next
    .emitted: _symbolic_dag_emit_constant_inspection(nodes, cursor, -1, catalog, _symbolic_calculus_next(ordinal, steps.length()))
    .nodes: emitted.nodes
    .steps: steps & emitted.steps
    negative_one: emitted.index
    .cursor: emitted.next
    .emitted: _symbolic_dag_emit_constant_inspection(nodes, cursor, 2, catalog, _symbolic_calculus_next(ordinal, steps.length()))
    .nodes: emitted.nodes
    .steps: steps & emitted.steps
    two: emitted.index
    .cursor: emitted.next
    derivatives: [0:source_count]
    target_entry: _symbolic_raw_catalog(variable)
    node: 0
    operation: 0
    left: 0
    right: 0
    left_derivative: 0
    right_derivative: 0
    first: 0
    second: 0
    third: 0
    fourth: 0
    fifth: 0
    exponent_value: 0
    node < source_count?>
        source_offset: source_start + node * 4
        .operation: value.(source_offset)
        .left: value.(source_offset + 1)
        .right: value.(source_offset + 2)
        operation = 1?
            symbol_entry: _symbolic_dag_catalog_entry(value, left)
            derivatives.(node): zero
            _symbolic_catalog_identity_same(symbol_entry, target_entry)?
                derivatives.(node): one
        operation = 2?
            derivatives.(node): zero
        operation >= 3 /\ operation <= 7?
            .left_derivative: derivatives.(left)
            .right_derivative: derivatives.(right)
        operation = 3 \/ operation = 4?
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, operation, left_derivative, right_derivative, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            derivatives.(node): emitted.index
            .cursor: emitted.next
        operation = 5?
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, left_derivative, right, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .first: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, left, right_derivative, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .second: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 3, first, second, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            derivatives.(node): emitted.index
            .cursor: emitted.next
        operation = 6?
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, left_derivative, right, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .first: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, left, right_derivative, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .second: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 4, first, second, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .third: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 7, right, two, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .fourth: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 6, third, fourth, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            derivatives.(node): emitted.index
            .cursor: emitted.next
        operation = 7?
            _symbolic_dag_node_operation(value, right) = 2?
                .exponent_value: _symbolic_dag_node_value(value, right)
                .emitted: _symbolic_dag_emit_constant_inspection(nodes, cursor, exponent_value - 1, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                .first: emitted.index
                .cursor: emitted.next
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 7, left, first, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                .second: emitted.index
                .cursor: emitted.next
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, right, second, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                .third: emitted.index
                .cursor: emitted.next
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, third, left_derivative, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                derivatives.(node): emitted.index
                .cursor: emitted.next
            ~(_symbolic_dag_node_operation(value, right) = 2)?
                .emitted: _symbolic_dag_emit_unary_inspection(nodes, cursor, 10, left, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                .first: emitted.index
                .cursor: emitted.next
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, right_derivative, first, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                .second: emitted.index
                .cursor: emitted.next
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 6, left_derivative, left, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                .third: emitted.index
                .cursor: emitted.next
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, right, third, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                .fourth: emitted.index
                .cursor: emitted.next
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 3, second, fourth, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                .fifth: emitted.index
                .cursor: emitted.next
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, node, fifth, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                derivatives.(node): emitted.index
                .cursor: emitted.next
        operation = 8?
            .emitted: _symbolic_dag_emit_unary_inspection(nodes, cursor, 9, left, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .first: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, first, derivatives.(left), zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            derivatives.(node): emitted.index
            .cursor: emitted.next
        operation = 9?
            .emitted: _symbolic_dag_emit_unary_inspection(nodes, cursor, 8, left, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .first: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, negative_one, first, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .second: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, second, derivatives.(left), zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            derivatives.(node): emitted.index
            .cursor: emitted.next
        operation = 10?
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 6, derivatives.(left), left, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            derivatives.(node): emitted.index
            .cursor: emitted.next
        operation = 11?
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, two, node, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            .first: emitted.index
            .cursor: emitted.next
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 6, derivatives.(left), first, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            derivatives.(node): emitted.index
            .cursor: emitted.next
        operation = 12?
            .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, node, derivatives.(left), zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            derivatives.(node): emitted.index
            .cursor: emitted.next
        operation = 25?
            ~_symbolic_differentiation_real_formal(variable) /\ derivatives.(left)!=zero?
                errors.TypeError("symbolic real_part has no complex derivative on this selected formal; real-direction or constant-inner-derivative proof required")!
            .emitted: _symbolic_dag_emit_unary_inspection(nodes, cursor, 25, derivatives.(left), catalog, _symbolic_calculus_next(ordinal, steps.length()))
            .nodes: emitted.nodes
            .steps: steps & emitted.steps
            derivatives.(node): emitted.index
            .cursor: emitted.next
        operation = 26?
            derivatives.(left) = zero?
                derivatives.(node): zero
            derivatives.(left) != zero?
                ~_symbolic_differentiation_real_formal(variable) \/ ~_symbolic_magnitude_real_inner(_symbolic_dag_with_root(value,left))?
                    errors.TypeError("symbolic magnitude derivative requires this actual real selected symbol and nonzero result domain")!
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 6, left, node, zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                .first: emitted.index
                .cursor: emitted.next
                .emitted: _symbolic_dag_emit_binary_inspection(nodes, cursor, 5, first, derivatives.(left), zero, one, catalog, _symbolic_calculus_next(ordinal, steps.length()))
                .nodes: emitted.nodes
                .steps: steps & emitted.steps
                derivatives.(node): emitted.index
                .cursor: emitted.next
        ordinal >= 0?
            branch: "differentiate_dag_unhandled_operation"
            operation = 1? .branch: "differentiate_dag_symbol"
            operation = 2? .branch: "differentiate_dag_constant"
            operation = 26?
                .branch: "differentiate_dag_magnitude_real_selected"
                derivatives.(left) = zero? .branch: "differentiate_dag_magnitude_constant_inner"
            operation = 3? .branch: "differentiate_dag_add"
            operation = 4? .branch: "differentiate_dag_subtract"
            operation = 5? .branch: "differentiate_dag_product"
            operation = 6? .branch: "differentiate_dag_quotient"
            operation = 7?
                .branch: "differentiate_dag_general_power"
                _symbolic_dag_node_operation(value, right) = 2?
                    .branch: "differentiate_dag_numeric_power"
            operation = 8? .branch: "differentiate_dag_sine"
            operation = 9? .branch: "differentiate_dag_cosine"
            operation = 10? .branch: "differentiate_dag_log"
            operation = 11? .branch: "differentiate_dag_sqrt"
            operation = 12? .branch: "differentiate_dag_exp"
            operation = 25? .branch: "differentiate_dag_real_part"
            source_snapshot: _symbolic_dag_with_root(value, node)
            used_snapshot_nodes: [..cursor * 4 - 1 >> nodes.($)]
            result_snapshot: _symbolic_dag_make(catalog, used_snapshot_nodes, derivatives.(node))
            receipt: _symbolic_inspection_rule(source_snapshot, result_snapshot, branch, "represented", "original_source_domain_retained", variable, ordinal + steps.length())
            .steps: steps & receipt.steps
        .node+: 1
    used_nodes: [..cursor * 4 - 1 >> nodes.($)]
    result: _symbolic_dag_make(catalog, used_nodes, derivatives.(_symbolic_dag_root(value)))
    _symbolic_calculus_finish(value, result, "differentiate_dag_result", steps, variable, ordinal)

_symbolic_differentiate_dag(value:symbolic, variable:symbolic) -> symbolic:
    _symbolic_differentiate_dag_inspection(value, variable, -1).expression

_symbolic_differentiate_raw_inspection(value:symbolic, variable:symbolic, cache:bit, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    kind: _symbolic_root_kind(value)
    kind = 1?
        same(value, variable)?
            @: _symbolic_calculus_finish(value, _symbolic_raw_number(1), "differentiate_symbol_self", steps, variable, ordinal)
        @: _symbolic_calculus_finish(value, _symbolic_raw_number(0), "differentiate_symbol_other", steps, variable, ordinal)
    kind = 2?
        @: _symbolic_calculus_finish(value, _symbolic_raw_number(0), "differentiate_constant", steps, variable, ordinal)
    kind = 7?
        argument: _symbolic_argument(value)
        child: _symbolic_differentiate_raw_inspection(argument, variable, cache, ordinal)
        derivative: child.expression
        .steps: child.steps
        operation: _symbolic_root_operation(value)
        operation = 1?
            arithmetic_view_0: _symbolic_multiply_inspection(cos(argument), derivative, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_0.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_0.expression, "differentiate_sine", steps, variable, ordinal)
        operation = 2?
            arithmetic_view_1: _symbolic_multiply_inspection(_symbolic_raw_number(-1), sin(argument), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_1.steps
            negative_sine: arithmetic_view_1.expression
            arithmetic_view_2: _symbolic_multiply_inspection(negative_sine, derivative, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_2.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_2.expression, "differentiate_cosine", steps, variable, ordinal)
        operation = 3?
            arithmetic_view_3: _symbolic_divide_inspection(derivative, argument, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_3.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_3.expression, "differentiate_log", steps, variable, ordinal)
        operation = 4?
            arithmetic_view_4: _symbolic_multiply_inspection(_symbolic_raw_number(2), sqrt(argument), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_4.steps
            denominator: arithmetic_view_4.expression
            arithmetic_view_5: _symbolic_divide_inspection(derivative, denominator, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_5.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_5.expression, "differentiate_sqrt", steps, variable, ordinal)
        operation = 5?
            arithmetic_view_6: _symbolic_multiply_inspection(exp(argument), derivative, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_6.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_6.expression, "differentiate_exp", steps, variable, ordinal)
        operation = 6?
            ~_symbolic_differentiation_real_formal(variable) /\ ~_symbolic_is_raw_number(derivative,0)?
                errors.TypeError("symbolic real_part has no complex derivative on this selected formal; real-direction or constant-inner-derivative proof required")!
            @: _symbolic_calculus_finish(value, real_part(derivative), "differentiate_real_part", steps, variable, ordinal)
        operation = 7 /\ _symbolic_is_raw_number(derivative,0)?
            @: _symbolic_calculus_finish(value, derivative, "differentiate_magnitude_constant_inner", steps, variable, ordinal)
        operation = 7 /\ _symbolic_differentiation_real_formal(variable) /\ _symbolic_magnitude_real_inner(argument)?
            magnitude_view: _symbolic_divide_inspection(argument, magnitude(argument), _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & magnitude_view.steps
            chain_view: _symbolic_multiply_inspection(magnitude_view.expression, derivative, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & chain_view.steps
            @: _symbolic_calculus_finish(value, chain_view.expression, "differentiate_magnitude_real_selected", steps, variable, ordinal)
        errors.TypeError("symbolic magnitude is not differentiable without real/complex assumptions")!
    ~(kind = 3)?
        errors.TypeError("symbolic.differentiate source is not an established numeric expression")!
    left: _symbolic_left(value)
    right: _symbolic_right(value)
    left_view: _symbolic_differentiate_raw_inspection(left, variable, cache, ordinal)
    left_derivative: left_view.expression
    .steps: left_view.steps
    right_derivative: _symbolic_raw_number(0)
    reused: false
    cache /\ same(left, right)?
        .right_derivative: _symbolic_clone(left_derivative)
        ordinal >= 0?
            reuse: _symbolic_inspection_rule(right, right_derivative, "differentiate_cache_equal_reuse", "represented", "original_source_domain_retained", variable, ordinal + steps.length())
            .steps: steps & reuse.steps
        .reused: true
    cache /\ ~reused /\ _symbolic_root_kind(right) = 3 /\ _symbolic_root_operation(right) = 1?
        common: _symbolic_right(right)
        same(left, common)?
            other: _symbolic_left(right)
            other_view: _symbolic_differentiate_raw_inspection(other, variable, cache, _symbolic_calculus_next(ordinal, steps.length()))
            other_derivative: other_view.expression
            .steps: steps & other_view.steps
            arithmetic_view_7: _symbolic_add_inspection(other_derivative, left_derivative, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_7.steps
            .right_derivative: arithmetic_view_7.expression
            ordinal >= 0?
                reuse: _symbolic_inspection_rule(right, right_derivative, "differentiate_cache_common_reuse", "represented", "original_source_domain_retained", variable, ordinal + steps.length())
                .steps: steps & reuse.steps
            .reused: true
    ~reused?
        right_view: _symbolic_differentiate_raw_inspection(right, variable, cache, _symbolic_calculus_next(ordinal, steps.length()))
        .right_derivative: right_view.expression
        .steps: steps & right_view.steps
    operation: _symbolic_root_operation(value)
    operation = 1?
        arithmetic_view_8: _symbolic_add_inspection(left_derivative, right_derivative, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_8.steps
        @: _symbolic_calculus_finish(value, arithmetic_view_8.expression, "differentiate_add", steps, variable, ordinal)
    operation = 2?
        arithmetic_view_9: _symbolic_subtract_inspection(left_derivative, right_derivative, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_9.steps
        @: _symbolic_calculus_finish(value, arithmetic_view_9.expression, "differentiate_subtract", steps, variable, ordinal)
    operation = 3?
        arithmetic_view_10: _symbolic_multiply_inspection(left_derivative, right, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_10.steps
        first: arithmetic_view_10.expression
        arithmetic_view_11: _symbolic_multiply_inspection(left, right_derivative, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_11.steps
        second: arithmetic_view_11.expression
        arithmetic_view_12: _symbolic_add_inspection(first, second, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_12.steps
        @: _symbolic_calculus_finish(value, arithmetic_view_12.expression, "differentiate_product", steps, variable, ordinal)
    operation = 4?
        arithmetic_view_13: _symbolic_multiply_inspection(left_derivative, right, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_13.steps
        first: arithmetic_view_13.expression
        arithmetic_view_14: _symbolic_multiply_inspection(left, right_derivative, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_14.steps
        second: arithmetic_view_14.expression
        arithmetic_view_15: _symbolic_subtract_inspection(first, second, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_15.steps
        numerator: arithmetic_view_15.expression
        arithmetic_view_16: _symbolic_power_inspection(right, _symbolic_raw_number(2), _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_16.steps
        denominator: arithmetic_view_16.expression
        arithmetic_view_17: _symbolic_divide_inspection(numerator, denominator, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_17.steps
        @: _symbolic_calculus_finish(value, arithmetic_view_17.expression, "differentiate_quotient", steps, variable, ordinal)
    operation = 5?
        _symbolic_root_kind(right) = 2?
            lowered_exponent: _symbolic_raw_number(_symbolic_number_value(right) - 1)
            arithmetic_view_18: _symbolic_power_inspection(left, lowered_exponent, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_18.steps
            power: arithmetic_view_18.expression
            arithmetic_view_19: _symbolic_multiply_inspection(right, power, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_19.steps
            scale: arithmetic_view_19.expression
            arithmetic_view_20: _symbolic_multiply_inspection(scale, left_derivative, _symbolic_calculus_next(ordinal, steps.length()))
            .steps: steps & arithmetic_view_20.steps
            @: _symbolic_calculus_finish(value, arithmetic_view_20.expression, "differentiate_numeric_power", steps, variable, ordinal)
        arithmetic_view_21: _symbolic_multiply_inspection(right_derivative, log(left), _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_21.steps
        log_term: arithmetic_view_21.expression
        arithmetic_view_22: _symbolic_divide_inspection(left_derivative, left, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_22.steps
        quotient: arithmetic_view_22.expression
        arithmetic_view_23: _symbolic_multiply_inspection(right, quotient, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_23.steps
        exponent_term: arithmetic_view_23.expression
        arithmetic_view_24: _symbolic_add_inspection(log_term, exponent_term, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_24.steps
        sum: arithmetic_view_24.expression
        arithmetic_view_25: _symbolic_multiply_inspection(value, sum, _symbolic_calculus_next(ordinal, steps.length()))
        .steps: steps & arithmetic_view_25.steps
        @: _symbolic_calculus_finish(value, arithmetic_view_25.expression, "differentiate_general_power", steps, variable, ordinal)
    operation = 14 \/ operation = 18 \/ operation = 24?
        @: _symbolic_calculus_finish(value, derivative(value, variable), "differentiate_formal_operator", steps, variable, ordinal)
    errors.TypeError("symbolic.differentiate operation has no established numeric rule or formal operator representation")!

_symbolic_differentiate_raw(value:symbolic, variable:symbolic, cache:bit) -> symbolic:
    _symbolic_differentiate_raw_inspection(value, variable, cache, -1).expression

_symbolic_differentiate_inspection(value:symbolic, variable:symbolic, cache:bit, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    ~(_symbolic_root_kind(variable) = 1)?
        errors.TypeError("symbolic.differentiate variable must be a symbol")!
    symbol_is_constant(_symbolic_clone(variable))?
        @: _symbolic_calculus_finish(value, _symbolic_raw_number(0), "differentiate_constant_variable", steps, variable, ordinal)
    _symbolic_storage_kind(value) = 10?
        operation: _symbolic_dag_operation(value)
        operation = 14 \/ operation = 18 \/ operation = 24?
            @: _symbolic_calculus_finish(value, derivative(value, variable), "differentiate_formal_operator", steps, variable, ordinal)
    kind: _symbolic_root_kind(value)
    kind = 4?
        @: _symbolic_differentiate_polynomial_inspection(value, variable, ordinal)
    kind = 6?
        @: _symbolic_differentiate_univariate_inspection(value, variable, ordinal)
    kind = 3?
        operation: _symbolic_root_operation(value)
        operation = 3?
            source_left: _symbolic_left(value)
            source_right: _symbolic_right(value)
            (_symbolic_is_raw_number(source_left,0) /\ _symbolic_mathematical_total(source_right)) \/ (_symbolic_is_raw_number(source_right,0) /\ _symbolic_mathematical_total(source_left))?
                # Establish the actual existing total-source zero identity
                # before entering any derivative primitive of the other side.
                identity: _symbolic_multiply_inspection(source_left,source_right,ordinal)
                constant_derivative: _symbolic_differentiate_raw_inspection(identity.expression,variable,cache,_symbolic_calculus_next(ordinal,identity.steps.length()))
                .steps: identity.steps & constant_derivative.steps
                @: _symbolic_calculus_finish(value,constant_derivative.expression,"differentiate_total_zero_product_source",steps,variable,ordinal)
        operation = 14 \/ operation = 18 \/ operation = 24?
            @: _symbolic_calculus_finish(value, derivative(value, variable), "differentiate_formal_operator", steps, variable, ordinal)
    _symbolic_storage_kind(value) = 10 /\ cache?
        @: _symbolic_differentiate_dag_inspection(value, variable, ordinal)
    _symbolic_differentiate_raw_inspection(value, variable, cache, ordinal)

differentiate(value:symbolic, variable:symbolic, cache:bit = true) -> symbolic:
    _symbolic_differentiate_inspection(value, variable, cache, -1).expression

inspect_differentiate(value:symbolic, variable:symbolic, cache:bit = true) -> (source:symbolic,expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)],domain:(scope:str,execution_checked:bit),ordinal_scope:str,numerical_requirement:str,execution_authority:bit):
    view: _symbolic_differentiate_inspection(value, variable, cache, 0)
    (source:_symbolic_clone(value), expression:view.expression, steps:view.steps,
     domain:(scope:"original source obligations retained; calculus is conditional on declared domains and operator admissibility", execution_checked:false),
     ordinal_scope:"local to this owned inspection invocation", numerical_requirement:"exact_algebra", execution_authority:false)

_symbolic_differentiate_suffix_entry(value:symbolic, variable_name:chr, cache:bit) -> symbolic:
    variable: _symbolic_suffix_variable(value, variable_name)
    ~(_symbolic_root_kind(variable) = 1)?
        errors.TypeError("symbolic.differentiate variable must be a symbol")!
    symbol_is_constant(_symbolic_clone(variable))?
        @: _symbolic_raw_number(0)
    _symbolic_storage_kind(value) = 10?
        operation: _symbolic_dag_operation(value)
        operation = 14 \/ operation = 18 \/ operation = 24?
            @: derivative(value, variable)
    kind: _symbolic_root_kind(value)
    kind = 4?
        @: _symbolic_differentiate_polynomial(value, variable)
    kind = 6?
        @: _symbolic_differentiate_univariate(value, variable)
    kind = 3?
        operation: _symbolic_root_operation(value)
        operation = 14 \/ operation = 18 \/ operation = 24?
            @: derivative(value, variable)
    _symbolic_storage_kind(value) = 10 /\ cache?
        @: _symbolic_differentiate_dag(value, variable)
    _symbolic_differentiate_raw(value, variable, cache)

differentiate(variable_name:chr, value:symbolic, cache:bit = true) -> symbolic:
    _symbolic_differentiate_suffix_entry(value, variable_name, cache)

deriv(variable_name:chr, value:symbolic, cache:bit = true) -> symbolic:
    _symbolic_differentiate_suffix_entry(value, variable_name, cache)

deriv(axis:chr, values:[num:n], spacing:num = 1) -> [num:n]:
    count: values.length()
    spacing != 0?! "symbolic.deriv spacing must be nonzero"
    result: values >> 0
    count < 2? @: result
    result.0: (values.1 - values.0) / spacing
    index: 1
    index < count - 1?>
        result.(index): (values.(index + 1) - values.(index - 1)) / (2 * spacing)
        .index+: 1
    result.(count - 1): (values.(count - 1) - values.(count - 2)) / spacing
    result

_symbolic_deriv_coordinates(axis:chr, values:[num:n], coordinates:[num:m]) -> [num:n]:
    count: values.length()
    (count = coordinates.length())?! "symbolic.deriv coordinate count must match values"
    result: values >> 0
    count < 2? @: result
    direction: coordinates.1 - coordinates.0
    direction != 0?! "symbolic.deriv coordinates must be strictly monotonic"
    index: 1
    index < count - 1?>
        step: coordinates.(index + 1) - coordinates.(index)
        (step != 0 /\ step * direction > 0)?! "symbolic.deriv coordinates must be strictly monotonic"
        .index+: 1
    result.0: (values.1 - values.0) / (coordinates.1 - coordinates.0)
    .index: 1
    index < count - 1?>
        result.(index): (
            (values.(index + 1) - values.(index - 1)) /
            (coordinates.(index + 1) - coordinates.(index - 1))
        )
        .index+: 1
    result.(count - 1): (
        (values.(count - 1) - values.(count - 2)) /
        (coordinates.(count - 1) - coordinates.(count - 2))
    )
    result

diff(value:symbolic, variable:symbolic, cache:bit = true) -> symbolic:
    differentiate(value, variable, cache)

diff(variable_name:chr, value:symbolic, cache:bit = true) -> symbolic:
    _symbolic_differentiate_suffix_entry(value, variable_name, cache)

_symbolic_univariate_basis_invalid() -> [num]:
    [num] result: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    result

_symbolic_univariate_basis_constant(value:num) -> [num]:
    [num] result: [1, value, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    result

_symbolic_univariate_basis_linear() -> [num]:
    [num] result: [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    result

_symbolic_univariate_basis_exponential(rate:num) -> [num]:
    [num] result: [1, 0, 0, 1, rate, 1, 0, 0, 0, 0, 0, 0]
    result

_symbolic_univariate_basis_sine(frequency:num) -> [num]:
    [num] result: [1, 0, 0, 0, 0, 0, 1, frequency, 1, 0, 0, 0]
    result

_symbolic_univariate_basis_cosine(frequency:num) -> [num]:
    [num] result: [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, frequency, 1]
    result

_symbolic_linear_argument_facts(argument:symbolic, variable:symbolic):
    same(_symbolic_clone(argument), _symbolic_clone(variable))?
        @: (valid:true, rate:1)
    kind: _symbolic_root_kind(_symbolic_clone(argument))
    operation: _symbolic_root_operation(_symbolic_clone(argument))
    kind = 3 /\ operation = 2?
        left: _symbolic_left(_symbolic_clone(argument))
        right: _symbolic_right(argument)
        _symbolic_is_raw_number(left, 0)?
            right_argument: _symbolic_linear_argument_facts(right, variable)
            right_argument.valid?
                @: (valid:true, rate:0 - right_argument.rate)
        @: (valid:false, rate:0)
    kind = 3 /\ operation = 3?
        left: _symbolic_left(_symbolic_clone(argument))
        right: _symbolic_right(argument)
        _symbolic_root_kind(_symbolic_clone(left)) = 2 /\ same(_symbolic_clone(right), _symbolic_clone(variable))?
            @: (valid:true, rate:_symbolic_number_value(left))
        _symbolic_root_kind(_symbolic_clone(right)) = 2 /\ same(left, variable)?
            @: (valid:true, rate:_symbolic_number_value(right))
    (valid:false, rate:0)

_symbolic_univariate_basis_scale(facts:[num], scale:num) -> [num]:
    [num] result: [
        facts.0,
        facts.1 * scale,
        facts.2 * scale,
        facts.3 * scale,
        facts.4,
        facts.5,
        facts.6 * scale,
        facts.7,
        facts.8,
        facts.9 * scale,
        facts.10,
        facts.11
    ]
    result

_symbolic_univariate_basis_combine(left:[num], right:[num], right_scale:num) -> [num]:
    valid: left.0 * right.0
    left.5 != 0 /\ right.5 != 0 /\ left.4 != right.4?
        .valid: 0
    left.8 != 0 /\ right.8 != 0 /\ left.7 != right.7?
        .valid: 0
    left.11 != 0 /\ right.11 != 0 /\ left.10 != right.10?
        .valid: 0
    exponential_rate: left.4 + (1 - left.5) * right.4
    sine_frequency: left.7 + (1 - left.8) * right.7
    cosine_frequency: left.10 + (1 - left.11) * right.10
    has_exponential: left.5 + right.5 - left.5 * right.5
    has_sine: left.8 + right.8 - left.8 * right.8
    has_cosine: left.11 + right.11 - left.11 * right.11
    [num] result: [
        valid,
        left.1 + right_scale * right.1,
        left.2 + right_scale * right.2,
        left.3 + right_scale * right.3,
        exponential_rate,
        has_exponential,
        left.6 + right_scale * right.6,
        sine_frequency,
        has_sine,
        left.9 + right_scale * right.9,
        cosine_frequency,
        has_cosine
    ]
    result

_symbolic_univariate_basis_facts(value:symbolic, variable:symbolic) -> [num]:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: 0
    kind = 3 \/ kind = 7?
        .operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 1?
        same(value, variable)?
            @: _symbolic_univariate_basis_linear()
        @: _symbolic_univariate_basis_invalid()
    kind = 2?
        @: _symbolic_univariate_basis_constant(_symbolic_number_value(value))
    kind = 7?
        argument: _symbolic_linear_argument_facts(
            _symbolic_argument(_symbolic_clone(value)),
            variable
        )
        ~argument.valid?
            @: _symbolic_univariate_basis_invalid()
        operation = 5?
            @: _symbolic_univariate_basis_exponential(argument.rate)
        operation = 1?
            @: _symbolic_univariate_basis_sine(argument.rate)
        operation = 2?
            @: _symbolic_univariate_basis_cosine(argument.rate)
        @: _symbolic_univariate_basis_invalid()
    ~(kind = 3)?
        @: _symbolic_univariate_basis_invalid()
    operation = 1 \/ operation = 2?
        additive_left: _symbolic_univariate_basis_facts(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(variable)
        )
        additive_right: _symbolic_univariate_basis_facts(
            _symbolic_right(value),
            variable
        )
        right_scale: 1
        operation = 2?
            .right_scale: -1
        @: _symbolic_univariate_basis_combine(additive_left, additive_right, right_scale)
    operation = 3?
        product_left: _symbolic_left(_symbolic_clone(value))
        product_right: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(product_left)) = 2?
            @: _symbolic_univariate_basis_scale(
                _symbolic_univariate_basis_facts(product_right, variable),
                _symbolic_number_value(product_left)
            )
        _symbolic_root_kind(_symbolic_clone(product_right)) = 2?
            @: _symbolic_univariate_basis_scale(
                _symbolic_univariate_basis_facts(product_left, variable),
                _symbolic_number_value(product_right)
            )
        @: _symbolic_univariate_basis_invalid()
    operation = 4?
        numerator: _symbolic_left(_symbolic_clone(value))
        denominator: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(denominator)) = 2 /\ _symbolic_number_value(_symbolic_clone(denominator)) != 0?
            @: _symbolic_univariate_basis_scale(
                _symbolic_univariate_basis_facts(numerator, variable),
                1 / _symbolic_number_value(denominator)
            )
    _symbolic_univariate_basis_invalid()

_symbolic_univariate_basis_value(facts:[num], point:num) -> num:
    value: facts.1 + facts.2 * point
    facts.5 != 0?
        .value+: facts.3 * m.exp(facts.4 * point)
    facts.8 != 0?
        .value+: facts.6 * m.sin(facts.7 * point)
    facts.11 != 0?
        .value+: facts.9 * m.cos(facts.10 * point)
    value

_symbolic_univariate_basis_derivative_value(facts:[num], point:num) -> num:
    value: facts.2
    facts.5 != 0?
        .value+: facts.3 * facts.4 * m.exp(facts.4 * point)
    facts.8 != 0?
        .value+: facts.6 * facts.7 * m.cos(facts.7 * point)
    facts.11 != 0?
        .value-: facts.9 * facts.10 * m.sin(facts.10 * point)
    value

_symbolic_affine_exponential_candidate_shape(
    value:symbolic,
    variable:symbolic
) -> bit:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    kind = 1?
        @: same(value, variable)
    kind = 2?
        @: true
    kind = 7?
        ~(_symbolic_root_operation(_symbolic_clone(value)) = 5)?
            @: false
        exponential_argument: _symbolic_linear_argument_facts(
            _symbolic_argument(value),
            variable
        )
        @: exponential_argument.valid
    ~(kind = 3)?
        @: false
    operation: _symbolic_root_operation(_symbolic_clone(value))
    operation = 1 \/ operation = 2?
        @: (
            _symbolic_affine_exponential_candidate_shape(
                _symbolic_left(_symbolic_clone(value)),
                _symbolic_clone(variable)
            ) /\
            _symbolic_affine_exponential_candidate_shape(
                _symbolic_right(value),
                variable
            )
        )
    operation = 3?
        left: _symbolic_left(_symbolic_clone(value))
        right: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(left)) = 2?
            @: _symbolic_affine_exponential_candidate_shape(right, variable)
        _symbolic_root_kind(_symbolic_clone(right)) = 2?
            @: _symbolic_affine_exponential_candidate_shape(left, variable)
        @: false
    operation = 4?
        numerator: _symbolic_left(_symbolic_clone(value))
        denominator: _symbolic_right(value)
        @: (
            _symbolic_root_kind(_symbolic_clone(denominator)) = 2 /\
            _symbolic_number_value(_symbolic_clone(denominator)) != 0 /\
            _symbolic_affine_exponential_candidate_shape(numerator, variable)
        )
    false

_symbolic_first_order_derivative_surface_matches(
    derivative_value:symbolic,
    dependent:symbolic,
    independent:symbolic
) -> bit:
    derivative_operation: _symbolic_dag_operation(_symbolic_clone(derivative_value))
    derivative_operation = 14?
        @: same(_symbolic_left(_symbolic_clone(derivative_value)), dependent) /\ same(_symbolic_right(derivative_value), independent)
    ~(derivative_operation = 18)?
        @: false
    derivative_target: _symbolic_left(_symbolic_clone(derivative_value))
    derivative_argument: _symbolic_right(derivative_value)
    (_symbolic_dag_operation(_symbolic_clone(derivative_target)) = 24 /\
     same(_symbolic_left(_symbolic_clone(derivative_target)), dependent) /\
     _symbolic_is_raw_number(_symbolic_right(derivative_target), 1) /\
     same(derivative_argument, independent))

_symbolic_first_order_ode_derivative_matches(
    differential_equation:symbolic,
    dependent:symbolic,
    independent:symbolic
) -> bit:
    ~(_symbolic_dag_operation(_symbolic_clone(differential_equation)) = 13)?
        @: false
    _symbolic_first_order_derivative_surface_matches(
        _symbolic_left(differential_equation),
        dependent,
        independent
    )

_symbolic_affine_ode_product_facts(
    rate_product:symbolic,
    dependent:symbolic,
    offset:num
):
    rate_matches: _symbolic_rate_product_matches(_symbolic_clone(rate_product), _symbolic_clone(dependent)) \/ _symbolic_applied_rate_product_matches(_symbolic_clone(rate_product), dependent)
    ~rate_matches?
        @: (valid:false, rate:0, offset:0)
    (valid:true, rate:_symbolic_rate_product_value(rate_product), offset:offset)

_symbolic_affine_ode_expression_facts(
    affine:symbolic,
    dependent:symbolic
):
    addition: _symbolic_root_kind(_symbolic_clone(affine)) = 3 /\ _symbolic_root_operation(_symbolic_clone(affine)) = 1
    ~addition?
        @: _symbolic_affine_ode_product_facts(affine, dependent, 0)
    left: _symbolic_left(_symbolic_clone(affine))
    right: _symbolic_right(affine)
    left_is_number: _symbolic_root_kind(_symbolic_clone(left)) = 2
    right_is_number: _symbolic_root_kind(_symbolic_clone(right)) = 2
    left_is_number?
        @: _symbolic_affine_ode_product_facts(right, dependent, _symbolic_number_value(left))
    right_is_number?
        @: _symbolic_affine_ode_product_facts(left, dependent, _symbolic_number_value(right))
    (valid:false, rate:0, offset:0)

_symbolic_affine_ode_rhs_facts(
    differential_equation:symbolic,
    dependent:symbolic
):
    _symbolic_affine_ode_expression_facts(
        _symbolic_right(differential_equation),
        dependent
    )

_symbolic_affine_ode_relation_facts(
    differential_equation:symbolic,
    dependent:symbolic,
    independent:symbolic
):
    ~(_symbolic_dag_operation(_symbolic_clone(differential_equation)) = 13)?
        @: (valid:false, rate:0, offset:0)
    left: _symbolic_left(_symbolic_clone(differential_equation))
    right: _symbolic_right(differential_equation)
    _symbolic_first_order_derivative_surface_matches(
        _symbolic_clone(left),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )?
        @: _symbolic_affine_ode_expression_facts(right, dependent)
    _symbolic_first_order_derivative_surface_matches(right, dependent, independent)?
        @: _symbolic_affine_ode_expression_facts(left, dependent)
    (valid:false, rate:0, offset:0)

_symbolic_affine_ode_condition_facts(
    initial_condition:symbolic,
    dependent:symbolic
):
    ~(_symbolic_dag_operation(_symbolic_clone(initial_condition)) = 13)?
        @: (valid:false, initial:0)
    evaluation: _symbolic_left(_symbolic_clone(initial_condition))
    ~(_symbolic_dag_operation(_symbolic_clone(evaluation)) = 15)?
        @: (valid:false, initial:0)
    target_matches: same(_symbolic_left(_symbolic_clone(evaluation)), dependent)
    point_matches: _symbolic_is_raw_number(_symbolic_right(evaluation), 0)
    initial_value: _symbolic_right(initial_condition)
    initial_is_number: _symbolic_root_kind(_symbolic_clone(initial_value)) = 2
    ~(target_matches /\ point_matches /\ initial_is_number)?
        @: (valid:false, initial:0)
    (valid:true, initial:_symbolic_number_value(initial_value))

verify_ode_solution(
    solution:symbolic,
    differential_equation:symbolic,
    initial_condition:symbolic,
    dependent:symbolic,
    independent:symbolic,
    checks:num = 16
) -> bit:
    checks < 1?
        @: false
    independent_domain: _symbolic_domain(_symbolic_clone(independent))
    ~(_symbolic_is_continuous_domain(independent_domain) /\ _symbolic_dependent_accepts_domain(_symbolic_clone(dependent), independent_domain))?
        @: false
    relation_is_equation: _symbolic_dag_operation(_symbolic_clone(differential_equation)) = 13
    relation_left: _symbolic_left(_symbolic_clone(differential_equation))
    relation_right: _symbolic_right(_symbolic_clone(differential_equation))
    left_is_derivative: _symbolic_first_order_derivative_surface_matches(_symbolic_clone(relation_left), _symbolic_clone(dependent), _symbolic_clone(independent))
    right_is_derivative: _symbolic_first_order_derivative_surface_matches(_symbolic_clone(relation_right), _symbolic_clone(dependent), _symbolic_clone(independent))
    variable_rate_expression: _symbolic_clone(relation_right)
    right_is_derivative /\ ~left_is_derivative?
        .variable_rate_expression: _symbolic_clone(relation_left)
    variable_rate_matches: relation_is_equation /\ (left_is_derivative \/ right_is_derivative) /\ _symbolic_variable_rate_product_matches(_symbolic_clone(variable_rate_expression), _symbolic_clone(dependent), _symbolic_clone(independent))
    variable_condition: _symbolic_first_order_value_condition_facts(_symbolic_clone(initial_condition), _symbolic_clone(dependent))
    variable_rate_matches /\ variable_condition.valid?
        coefficient: _symbolic_variable_rate_product_coefficient(variable_rate_expression, _symbolic_clone(dependent), _symbolic_clone(independent))
        antiderivative: integrate(_symbolic_clone(coefficient), _symbolic_clone(independent))
        recovered_rate: simplify(differentiate(_symbolic_clone(antiderivative), _symbolic_clone(independent), true))
        anchor: evaluate(_symbolic_clone(antiderivative), [variable_condition.point])
        expected: variable_condition.initial * exp(simplify(_symbolic_clone(antiderivative) - anchor))
        rate_residual: same(recovered_rate, simplify(coefficient))
        solution_residual: same(simplify(_symbolic_clone(solution)), simplify(expected))
        initial_residual: evaluate(solution, [variable_condition.point]) = variable_condition.initial
        @: rate_residual /\ solution_residual /\ initial_residual
    affine: _symbolic_affine_ode_relation_facts(
        _symbolic_clone(differential_equation),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    condition: _symbolic_affine_ode_condition_facts(initial_condition, dependent)
    ~(affine.valid /\ condition.valid)?
        @: false
    ~_symbolic_affine_exponential_candidate_shape(
        _symbolic_clone(solution),
        _symbolic_clone(independent)
    )?
        @: false
    basis: _symbolic_univariate_basis_facts(solution, _symbolic_clone(independent))
    ~(basis.0 != 0 /\ basis.8 = 0 /\ basis.11 = 0)?
        @: false
    exponential_residual: true
    basis.5 != 0?
        .exponential_residual: (
            basis.3 * basis.4 =
            affine.rate * basis.3
        )
    linear_residual: affine.rate * basis.2 = 0
    constant_residual: basis.2 = affine.rate * basis.1 + affine.offset
    initial_value: basis.1
    basis.5 != 0?
        .initial_value+: basis.3
    (
        exponential_residual /\
        linear_residual /\
        constant_residual /\
        initial_value = condition.initial
    )

solve_ode(
    differential_equation:symbolic,
    initial_condition:symbolic,
    dependent:symbolic,
    independent:symbolic
) -> symbolic:
    candidate: _symbolic_solve_ode_unverified(
        _symbolic_clone(differential_equation),
        _symbolic_clone(initial_condition),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    verify_ode_solution(
        _symbolic_clone(candidate),
        differential_equation,
        initial_condition,
        dependent,
        independent
    )?
        @: candidate
    errors.RuntimeError("native symbolic ODE candidate failed residual or initial-condition verification")!

_symbolic_univariate_basis_condition_satisfied(
    basis:[num],
    condition:symbolic,
    dependent:symbolic,
    independent:symbolic
) -> bit:
    value_condition: _symbolic_condition_is_value(
        _symbolic_clone(condition),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    derivative_condition: _symbolic_condition_is_derivative(
        _symbolic_clone(condition),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    ~(value_condition \/ derivative_condition)?
        @: false
    point: _symbolic_condition_point(_symbolic_clone(condition))
    expected: _symbolic_condition_value(condition)
    value_condition?
        @: _symbolic_univariate_basis_value(basis, point) = expected
    _symbolic_univariate_basis_derivative_value(basis, point) = expected

_symbolic_ode_condition_numeric_facts(
    condition:symbolic,
    dependent:symbolic,
    independent:symbolic
) :
    is_value: _symbolic_condition_is_value(
        _symbolic_clone(condition),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    is_derivative: _symbolic_condition_is_derivative(
        _symbolic_clone(condition),
        dependent,
        independent
    )
    valid: is_value \/ is_derivative
    ~valid?
        @: (valid:false, derivative:false, point:0, expected:0)
    (
        valid:true,
        derivative:is_derivative,
        point:_symbolic_condition_point(_symbolic_clone(condition)),
        expected:_symbolic_condition_value(condition)
    )

_symbolic_affine_candidate_invalid():
    (valid:false, constant:0, linear:0)

_symbolic_affine_candidate_facts(value:symbolic, variable:symbolic):
    kind: _symbolic_root_kind(_symbolic_clone(value))
    operation: 0
    kind = 3?
        .operation: _symbolic_root_operation(_symbolic_clone(value))
    kind = 1?
        same(value, variable)?
            @: (valid:true, constant:0, linear:1)
        @: _symbolic_affine_candidate_invalid()
    kind = 2?
        @: (valid:true, constant:_symbolic_number_value(value), linear:0)
    ~(kind = 3)?
        @: _symbolic_affine_candidate_invalid()
    operation = 1 \/ operation = 2?
        additive_left: _symbolic_affine_candidate_facts(
            _symbolic_left(_symbolic_clone(value)),
            _symbolic_clone(variable)
        )
        additive_right: _symbolic_affine_candidate_facts(
            _symbolic_right(value),
            variable
        )
        sign: 1
        operation = 2?
            .sign: -1
        @: (
            valid:additive_left.valid /\ additive_right.valid,
            constant:additive_left.constant + sign * additive_right.constant,
            linear:additive_left.linear + sign * additive_right.linear
        )
    operation = 3?
        product_left: _symbolic_left(_symbolic_clone(value))
        product_right: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(product_left)) = 2?
            product_facts: _symbolic_affine_candidate_facts(product_right, variable)
            scale: _symbolic_number_value(product_left)
            @: (
                valid:product_facts.valid,
                constant:scale * product_facts.constant,
                linear:scale * product_facts.linear
            )
        _symbolic_root_kind(_symbolic_clone(product_right)) = 2?
            product_facts_right: _symbolic_affine_candidate_facts(product_left, variable)
            scale_right: _symbolic_number_value(product_right)
            @: (
                valid:product_facts_right.valid,
                constant:scale_right * product_facts_right.constant,
                linear:scale_right * product_facts_right.linear
            )
        @: _symbolic_affine_candidate_invalid()
    operation = 4?
        numerator: _symbolic_left(_symbolic_clone(value))
        denominator: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(denominator)) = 2 /\ _symbolic_number_value(_symbolic_clone(denominator)) != 0?
            quotient_facts: _symbolic_affine_candidate_facts(numerator, variable)
            divisor: _symbolic_number_value(denominator)
            @: (
                valid:quotient_facts.valid,
                constant:quotient_facts.constant / divisor,
                linear:quotient_facts.linear / divisor
            )
    _symbolic_affine_candidate_invalid()

_symbolic_trigonometric_candidate_invalid():
    (valid:false, sine_scale:0, sine_frequency:0, cosine_scale:0, cosine_frequency:0)

_symbolic_trigonometric_term_facts(value:symbolic, variable:symbolic):
    scale: 1
    target: _symbolic_clone(value)
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: 0
    value_kind = 3?
        .value_operation: _symbolic_root_operation(_symbolic_clone(value))
    value_kind = 2 /\ _symbolic_number_value(_symbolic_clone(value)) = 0?
        @: (valid:true, kind:0, scale:0, frequency:0)
    value_kind = 3 /\ value_operation = 3?
        product_left: _symbolic_left(_symbolic_clone(value))
        product_right: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(product_left)) = 2?
            .scale: _symbolic_number_value(product_left)
            .target: _symbolic_clone(product_right)
        _symbolic_root_kind(_symbolic_clone(product_right)) = 2?
            .scale: _symbolic_number_value(product_right)
            .target: _symbolic_clone(product_left)
    ~(_symbolic_root_kind(_symbolic_clone(target)) = 7)?
        @: (valid:false, kind:0, scale:0, frequency:0)
    operation: _symbolic_root_operation(_symbolic_clone(target))
    ~(operation = 1 \/ operation = 2)?
        @: (valid:false, kind:0, scale:0, frequency:0)
    argument: _symbolic_linear_argument_facts(
        _symbolic_argument(target),
        variable
    )
    (valid:argument.valid, kind:operation, scale:scale, frequency:argument.rate)

_symbolic_trigonometric_candidate_facts(value:symbolic, variable:symbolic):
    outer_scale: 1
    source: _symbolic_clone(value)
    source_kind: _symbolic_root_kind(_symbolic_clone(source))
    source_operation: 0
    source_kind = 3?
        .source_operation: _symbolic_root_operation(_symbolic_clone(source))
    source_kind = 3 /\ source_operation = 4?
        denominator: _symbolic_right(_symbolic_clone(source))
        ~(_symbolic_root_kind(_symbolic_clone(denominator)) = 2)?
            @: _symbolic_trigonometric_candidate_invalid()
        _symbolic_number_value(_symbolic_clone(denominator)) = 0?
            @: _symbolic_trigonometric_candidate_invalid()
        .outer_scale: 1 / _symbolic_number_value(denominator)
        .source: _symbolic_left(source)
        .source_kind: _symbolic_root_kind(_symbolic_clone(source))
        .source_operation: 0
        source_kind = 3?
            .source_operation: _symbolic_root_operation(_symbolic_clone(source))
    first_source: _symbolic_clone(source)
    second_source: constant(0)
    second_sign: 0
    source_kind = 3 /\ (source_operation = 1 \/ source_operation = 2)?
        .first_source: _symbolic_left(_symbolic_clone(source))
        .second_source: _symbolic_right(source)
        .second_sign: 1
        source_operation = 2?
            .second_sign: -1
    first: _symbolic_trigonometric_term_facts(
        first_source,
        _symbolic_clone(variable)
    )
    second: _symbolic_trigonometric_term_facts(second_source, variable)
    second_kind: second.kind
    second_scale: second_sign * second.scale
    second_frequency: second.frequency
    ~(first.valid /\ second.valid)?
        @: _symbolic_trigonometric_candidate_invalid()
    sine_scale: 0
    sine_frequency: 0
    cosine_scale: 0
    cosine_frequency: 0
    first.kind = 1?
        .sine_scale: outer_scale * first.scale
        .sine_frequency: first.frequency
    first.kind = 2?
        .cosine_scale: outer_scale * first.scale
        .cosine_frequency: first.frequency
    second_kind = 1?
        sine_scale != 0 /\ sine_frequency != second_frequency?
            @: _symbolic_trigonometric_candidate_invalid()
        .sine_scale+: outer_scale * second_scale
        .sine_frequency: second_frequency
    second_kind = 2?
        cosine_scale != 0 /\ cosine_frequency != second_frequency?
            @: _symbolic_trigonometric_candidate_invalid()
        .cosine_scale+: outer_scale * second_scale
        .cosine_frequency: second_frequency
    (
        valid:true,
        sine_scale:sine_scale,
        sine_frequency:sine_frequency,
        cosine_scale:cosine_scale,
        cosine_frequency:cosine_frequency
    )

_symbolic_exponential_term_facts(value:symbolic, variable:symbolic):
    scale: 1
    target: _symbolic_clone(value)
    value_kind: _symbolic_root_kind(_symbolic_clone(value))
    value_operation: 0
    value_kind = 3?
        .value_operation: _symbolic_root_operation(_symbolic_clone(value))
    value_kind = 2 /\ _symbolic_number_value(_symbolic_clone(value)) = 0?
        @: (valid:true, scale:0, rate:0)
    value_kind = 3 /\ value_operation = 3?
        product_left: _symbolic_left(_symbolic_clone(value))
        product_right: _symbolic_right(value)
        _symbolic_root_kind(_symbolic_clone(product_left)) = 2?
            .scale: _symbolic_number_value(product_left)
            .target: _symbolic_clone(product_right)
        _symbolic_root_kind(_symbolic_clone(product_right)) = 2?
            .scale: _symbolic_number_value(product_right)
            .target: _symbolic_clone(product_left)
    ~(_symbolic_root_kind(_symbolic_clone(target)) = 7 /\
      _symbolic_root_operation(_symbolic_clone(target)) = 5)?
        @: (valid:false, scale:0, rate:0)
    argument: _symbolic_linear_argument_facts(
        _symbolic_argument(target),
        variable
    )
    (valid:argument.valid, scale:scale, rate:argument.rate)

_symbolic_two_exponential_candidate_facts(value:symbolic, variable:symbolic):
    source: _symbolic_clone(value)
    source_kind: _symbolic_root_kind(_symbolic_clone(source))
    source_operation: 0
    source_kind = 3?
        .source_operation: _symbolic_root_operation(_symbolic_clone(source))
    first_source: _symbolic_clone(source)
    second_source: constant(0)
    second_sign: 0
    source_kind = 3 /\ (source_operation = 1 \/ source_operation = 2)?
        .first_source: _symbolic_left(_symbolic_clone(source))
        .second_source: _symbolic_right(source)
        .second_sign: 1
        source_operation = 2?
            .second_sign: -1
    first: _symbolic_exponential_term_facts(
        first_source,
        _symbolic_clone(variable)
    )
    second: _symbolic_exponential_term_facts(second_source, variable)
    (
        valid:first.valid /\ second.valid,
        first_scale:first.scale,
        first_rate:first.rate,
        second_scale:second_sign * second.scale,
        second_rate:second.rate
    )

_symbolic_two_exponential_value(facts, point:num) -> num:
    facts.first_scale * m.exp(facts.first_rate * point) + facts.second_scale * m.exp(facts.second_rate * point)

_symbolic_two_exponential_derivative_value(facts, point:num) -> num:
    facts.first_scale * facts.first_rate * m.exp(facts.first_rate * point) + facts.second_scale * facts.second_rate * m.exp(facts.second_rate * point)

_symbolic_repeated_exponential_candidate_facts(value:symbolic, variable:symbolic):
    single: _symbolic_exponential_term_facts(
        _symbolic_clone(value),
        _symbolic_clone(variable)
    )
    single.valid?
        @: (valid:true, constant:single.scale, linear:0, rate:single.rate)
    ~(_symbolic_root_kind(_symbolic_clone(value)) = 3 /\
      _symbolic_root_operation(_symbolic_clone(value)) = 3)?
        @: (valid:false, constant:0, linear:0, rate:0)
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_affine: _symbolic_affine_candidate_facts(
        _symbolic_clone(left),
        _symbolic_clone(variable)
    )
    right_exponential: _symbolic_exponential_term_facts(
        _symbolic_clone(right),
        _symbolic_clone(variable)
    )
    left_affine.valid /\ right_exponential.valid?
        @: (
            valid:true,
            constant:left_affine.constant * right_exponential.scale,
            linear:left_affine.linear * right_exponential.scale,
            rate:right_exponential.rate
        )
    right_affine: _symbolic_affine_candidate_facts(right, variable)
    left_exponential: _symbolic_exponential_term_facts(left, variable)
    right_affine.valid /\ left_exponential.valid?
        @: (
            valid:true,
            constant:right_affine.constant * left_exponential.scale,
            linear:right_affine.linear * left_exponential.scale,
            rate:left_exponential.rate
        )
    (valid:false, constant:0, linear:0, rate:0)

_symbolic_repeated_exponential_value(facts, point:num) -> num:
    (facts.constant + facts.linear * point) * m.exp(facts.rate * point)

_symbolic_repeated_exponential_derivative_value(facts, point:num) -> num:
    (facts.linear + facts.rate * (facts.constant + facts.linear * point)) * m.exp(facts.rate * point)

_symbolic_damped_trigonometric_candidate_facts(value:symbolic, variable:symbolic):
    ~(_symbolic_root_kind(_symbolic_clone(value)) = 3 /\
      _symbolic_root_operation(_symbolic_clone(value)) = 3)?
        @: (valid:false, rate:0, sine_scale:0, sine_frequency:0, cosine_scale:0, cosine_frequency:0)
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_exponential: _symbolic_exponential_term_facts(
        _symbolic_clone(left),
        _symbolic_clone(variable)
    )
    right_trigonometric: _symbolic_trigonometric_candidate_facts(
        _symbolic_clone(right),
        _symbolic_clone(variable)
    )
    left_exponential.valid /\ right_trigonometric.valid?
        @: (
            valid:true,
            rate:left_exponential.rate,
            sine_scale:left_exponential.scale * right_trigonometric.sine_scale,
            sine_frequency:right_trigonometric.sine_frequency,
            cosine_scale:left_exponential.scale * right_trigonometric.cosine_scale,
            cosine_frequency:right_trigonometric.cosine_frequency
        )
    right_exponential: _symbolic_exponential_term_facts(right, variable)
    left_trigonometric: _symbolic_trigonometric_candidate_facts(left, variable)
    right_exponential.valid /\ left_trigonometric.valid?
        @: (
            valid:true,
            rate:right_exponential.rate,
            sine_scale:right_exponential.scale * left_trigonometric.sine_scale,
            sine_frequency:left_trigonometric.sine_frequency,
            cosine_scale:right_exponential.scale * left_trigonometric.cosine_scale,
            cosine_frequency:left_trigonometric.cosine_frequency
        )
    (valid:false, rate:0, sine_scale:0, sine_frequency:0, cosine_scale:0, cosine_frequency:0)

_symbolic_damped_trigonometric_value(facts, point:num) -> num:
    m.exp(facts.rate * point) * (
        facts.sine_scale * m.sin(facts.sine_frequency * point) +
        facts.cosine_scale * m.cos(facts.cosine_frequency * point)
    )

_symbolic_damped_trigonometric_derivative_value(facts, point:num) -> num:
    m.exp(facts.rate * point) * (
        facts.rate * (
            facts.sine_scale * m.sin(facts.sine_frequency * point) +
            facts.cosine_scale * m.cos(facts.cosine_frequency * point)
        ) +
        facts.sine_scale * facts.sine_frequency * m.cos(facts.sine_frequency * point) -
        facts.cosine_scale * facts.cosine_frequency * m.sin(facts.cosine_frequency * point)
    )

verify_ode_solution(
    solution:symbolic,
    differential_equation:symbolic,
    conditions:[symbolic:n],
    dependent:symbolic,
    independent:symbolic,
    checks:num = 16
) -> bit:
    conditions.length() != 2 \/ checks < 1?
        @: false
    independent_domain: _symbolic_domain(_symbolic_clone(independent))
    ~(_symbolic_is_continuous_domain(independent_domain) /\ _symbolic_dependent_accepts_domain(_symbolic_clone(dependent), independent_domain))?
        @: false
    relation: _symbolic_second_order_relation_facts(
        _symbolic_clone(differential_equation),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    ~relation.valid?
        @: false
    first_condition: _symbolic_ode_condition_numeric_facts(
        _symbolic_clone(conditions.0),
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    second_condition: _symbolic_ode_condition_numeric_facts(
        conditions.1,
        dependent,
        _symbolic_clone(independent)
    )
    ~(first_condition.valid /\ second_condition.valid)?
        @: false
    affine: _symbolic_affine_candidate_facts(
        _symbolic_clone(solution),
        _symbolic_clone(independent)
    )
    trigonometric: _symbolic_trigonometric_candidate_facts(
        solution,
        independent
    )
    exponential: _symbolic_two_exponential_candidate_facts(
        _symbolic_clone(solution),
        _symbolic_clone(independent)
    )
    repeated_exponential: _symbolic_repeated_exponential_candidate_facts(
        _symbolic_clone(solution),
        _symbolic_clone(independent)
    )
    damped_trigonometric: _symbolic_damped_trigonometric_candidate_facts(
        _symbolic_clone(solution),
        _symbolic_clone(independent)
    )
    sine_residual: trigonometric.sine_scale = 0 \/ trigonometric.sine_frequency^2 = relation.coefficient
    cosine_residual: trigonometric.cosine_scale = 0 \/ trigonometric.cosine_frequency^2 = relation.coefficient
    residual: false
    first_actual: 0
    second_actual: 0
    first_exponential_residual: false
    second_exponential_residual: false
    repeated_characteristic_residual: false
    repeated_derivative_residual: false
    damped_sine_residual: false
    damped_cosine_residual: false
    relation.first_coefficient = 0 /\ relation.coefficient = 0?
        .residual: affine.valid
        .first_actual: affine.constant + affine.linear * first_condition.point
        first_condition.derivative?
            .first_actual: affine.linear
        .second_actual: affine.constant + affine.linear * second_condition.point
        second_condition.derivative?
            .second_actual: affine.linear
    relation.first_coefficient = 0 /\ relation.coefficient > 0?
        .residual: trigonometric.valid /\ sine_residual /\ cosine_residual
        .first_actual: (
            trigonometric.sine_scale * m.sin(trigonometric.sine_frequency * first_condition.point) +
            trigonometric.cosine_scale * m.cos(trigonometric.cosine_frequency * first_condition.point)
        )
        first_condition.derivative?
            .first_actual: (
                trigonometric.sine_scale * trigonometric.sine_frequency * m.cos(trigonometric.sine_frequency * first_condition.point) -
                trigonometric.cosine_scale * trigonometric.cosine_frequency * m.sin(trigonometric.cosine_frequency * first_condition.point)
            )
        .second_actual: (
            trigonometric.sine_scale * m.sin(trigonometric.sine_frequency * second_condition.point) +
            trigonometric.cosine_scale * m.cos(trigonometric.cosine_frequency * second_condition.point)
        )
        second_condition.derivative?
            .second_actual: (
                trigonometric.sine_scale * trigonometric.sine_frequency * m.cos(trigonometric.sine_frequency * second_condition.point) -
                trigonometric.cosine_scale * trigonometric.cosine_frequency * m.sin(trigonometric.cosine_frequency * second_condition.point)
            )
    (relation.first_coefficient != 0 \/ relation.coefficient < 0)?
        .first_exponential_residual: (
            exponential.first_scale = 0 \/
            exponential.first_rate^2 + relation.first_coefficient * exponential.first_rate + relation.coefficient = 0
        )
        .second_exponential_residual: (
            exponential.second_scale = 0 \/
            exponential.second_rate^2 + relation.first_coefficient * exponential.second_rate + relation.coefficient = 0
        )
        .residual: exponential.valid /\ first_exponential_residual /\ second_exponential_residual
        .first_actual: _symbolic_two_exponential_value(exponential, first_condition.point)
        first_condition.derivative?
            .first_actual: _symbolic_two_exponential_derivative_value(exponential, first_condition.point)
        .second_actual: _symbolic_two_exponential_value(exponential, second_condition.point)
        second_condition.derivative?
            .second_actual: _symbolic_two_exponential_derivative_value(exponential, second_condition.point)
    relation.first_coefficient^2 - 4 * relation.coefficient = 0 /\ (relation.first_coefficient != 0 \/ relation.coefficient != 0)?
        .repeated_characteristic_residual: (
            repeated_exponential.rate^2 +
            relation.first_coefficient * repeated_exponential.rate +
            relation.coefficient = 0
        )
        .repeated_derivative_residual: (
            repeated_exponential.linear = 0 \/
            2 * repeated_exponential.rate + relation.first_coefficient = 0
        )
        .residual: repeated_exponential.valid /\ repeated_characteristic_residual /\ repeated_derivative_residual
        .first_actual: _symbolic_repeated_exponential_value(repeated_exponential, first_condition.point)
        first_condition.derivative?
            .first_actual: _symbolic_repeated_exponential_derivative_value(repeated_exponential, first_condition.point)
        .second_actual: _symbolic_repeated_exponential_value(repeated_exponential, second_condition.point)
        second_condition.derivative?
            .second_actual: _symbolic_repeated_exponential_derivative_value(repeated_exponential, second_condition.point)
    relation.first_coefficient != 0 /\ relation.first_coefficient^2 - 4 * relation.coefficient < 0?
        .damped_sine_residual: (
            damped_trigonometric.sine_scale = 0 \/ (
                damped_trigonometric.rate^2 - damped_trigonometric.sine_frequency^2 +
                    relation.first_coefficient * damped_trigonometric.rate + relation.coefficient = 0 /\
                2 * damped_trigonometric.rate * damped_trigonometric.sine_frequency +
                    relation.first_coefficient * damped_trigonometric.sine_frequency = 0
            )
        )
        .damped_cosine_residual: (
            damped_trigonometric.cosine_scale = 0 \/ (
                damped_trigonometric.rate^2 - damped_trigonometric.cosine_frequency^2 +
                    relation.first_coefficient * damped_trigonometric.rate + relation.coefficient = 0 /\
                2 * damped_trigonometric.rate * damped_trigonometric.cosine_frequency +
                    relation.first_coefficient * damped_trigonometric.cosine_frequency = 0
            )
        )
        .residual: damped_trigonometric.valid /\ damped_sine_residual /\ damped_cosine_residual
        .first_actual: _symbolic_damped_trigonometric_value(damped_trigonometric, first_condition.point)
        first_condition.derivative?
            .first_actual: _symbolic_damped_trigonometric_derivative_value(damped_trigonometric, first_condition.point)
        .second_actual: _symbolic_damped_trigonometric_value(damped_trigonometric, second_condition.point)
        second_condition.derivative?
            .second_actual: _symbolic_damped_trigonometric_derivative_value(damped_trigonometric, second_condition.point)
    residual /\ first_actual = first_condition.expected /\ second_actual = second_condition.expected

solve_ode(
    differential_equation:symbolic,
    conditions:[symbolic:n],
    dependent:symbolic,
    independent:symbolic
) -> symbolic:
    conditions.length() != 2?
        errors.RuntimeError("native symbolic boundary-value ODE strategy requires two conditions")!
    candidate: _symbolic_solve_second_order_ode_unverified(
        _symbolic_clone(differential_equation),
        [_symbolic_clone(conditions.0), _symbolic_clone(conditions.1)],
        _symbolic_clone(dependent),
        _symbolic_clone(independent)
    )
    verify_ode_solution(
        _symbolic_clone(candidate),
        differential_equation,
        conditions,
        dependent,
        independent
    )?
        @: candidate
    errors.RuntimeError("native symbolic second-order ODE candidate failed residual or condition verification")!

_symbolic_evaluate_univariate_at(value:symbolic, point:num) -> num:
    _symbolic_root_kind(_symbolic_clone(value)) = 2?
        @: _symbolic_number_value(value)
    evaluate(value, [point])

_symbolic_exact_zero_at(value:symbolic, variable:symbolic, point:num) -> bit:
    kind: _symbolic_root_kind(_symbolic_clone(value))
    kind = 4 \/ kind = 6?
        @: _symbolic_evaluate_univariate_at(value, point) = 0
    substituted: simplify(substitute(value, variable, point))
    _symbolic_is_raw_number(substituted, 0)

_symbolic_finite_limit_state(value:symbolic, variable:symbolic, point:num):
    current: expand(value)
    next: _symbolic_clone(current)
    order: 0
    at_point: _symbolic_evaluate_univariate_at(_symbolic_clone(current), point)
    exact_zero: _symbolic_exact_zero_at(_symbolic_clone(current), _symbolic_clone(variable), point)
    stalled: false
    exact_zero /\ ~stalled?>
        .next: simplify(differentiate(_symbolic_clone(current), _symbolic_clone(variable)))
        .stalled: same(_symbolic_clone(next), _symbolic_clone(current))
        .current: _symbolic_clone(next)
        .order+: 1
        .at_point: _symbolic_evaluate_univariate_at(_symbolic_clone(current), point)
        .exact_zero: _symbolic_exact_zero_at(_symbolic_clone(current), _symbolic_clone(variable), point)
    (resolved:~exact_zero, order:order, value:at_point)

_symbolic_finite_quotient_limit(
    value:symbolic,
    variable:symbolic,
    point:num,
    side:str
) -> symbolic:
    numerator: _symbolic_left(_symbolic_clone(value))
    denominator: _symbolic_right(value)
    numerator_zero: same(simplify(_symbolic_clone(numerator)), constant(0))
    numerator_state: _symbolic_finite_limit_state(numerator, _symbolic_clone(variable), point)
    denominator_state: _symbolic_finite_limit_state(denominator, variable, point)
    ~denominator_state.resolved?
        errors.RuntimeError("native symbolic finite-limit strategy could not resolve the denominator")!
    numerator_zero?
        @: _symbolic_raw_number(0)
    ~numerator_state.resolved?
        errors.RuntimeError("native symbolic finite-limit strategy could not resolve the numerator")!
    numerator_state.order > denominator_state.order?
        @: _symbolic_raw_number(0)
    numerator_state.order = denominator_state.order?
        @: _symbolic_raw_number(numerator_state.value / denominator_state.value)
    pole_order: denominator_state.order - numerator_state.order
    side = "both" /\ pole_order % 2 = 1?
        errors.RuntimeError("symbolic two-sided limit does not exist; request left or right")!
    sign: numerator_state.value / denominator_state.value
    side = "left" /\ pole_order % 2 = 1?
        .sign: 0 - sign
    sign > 0?
        @: _symbolic_clone(inf)
    sign < 0?
        @: -_symbolic_clone(inf)
    errors.RuntimeError("native symbolic finite-limit strategy could not determine the pole sign")!

limit(value:symbolic, variable:symbolic, point:num, side:str) -> symbolic:
    ~(_symbolic_root_kind(_symbolic_clone(variable)) = 1)?
        errors.TypeError("symbolic.limit variable must be a symbol")!
    ~(_symbolic_domain(_symbolic_clone(variable)) = _symbolic_domain_real)?
        errors.TypeError("symbolic finite limits require a real variable")!
    ~(side = "both" \/ side = "left" \/ side = "right")?
        errors.ValueError("symbolic.limit side must be both, left, or right")!
    is_quotient: _symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 4
    is_quotient?
        @: _symbolic_finite_quotient_limit(value, variable, point, side)
    _symbolic_raw_number(evaluate(value, [point]))

limit(variable_name:chr, value:symbolic, point:num, side:str) -> symbolic:
    limit(value, _symbolic_suffix_variable(value, variable_name), point, side)

limit(value:symbolic, variable:symbolic, point:num) -> symbolic:
    limit(value, variable, point, "both")

limit(variable_name:chr, value:symbolic, point:num) -> symbolic:
    limit(value, _symbolic_suffix_variable(value, variable_name), point)

_symbolic_limit_at_infinity(value:symbolic, variable:symbolic, direction:num) -> symbolic:
    ~(_symbolic_root_kind(_symbolic_clone(variable)) = 1)?
        errors.TypeError("symbolic.limit variable must be a symbol")!
    ~(_symbolic_domain(_symbolic_clone(variable)) = _symbolic_domain_real)?
        errors.TypeError("symbolic infinite limits require a real variable")!
    facts: _symbolic_asymptotic_facts(value, variable)
    ~facts.valid?
        errors.RuntimeError("native symbolic infinite-limit strategy is not implemented for this expression")!
    effective_exponential: facts.exponential * direction
    effective_exponential < 0?
        @: _symbolic_raw_number(0)
    sign: facts.scale
    direction < 0 /\ facts.order % 2 != 0?
        .sign: 0 - sign
    effective_exponential > 0?
        sign > 0?
            @: _symbolic_infinity()
        sign < 0?
            @: -_symbolic_infinity()
        @: _symbolic_raw_number(0)
    direction < 0 /\ facts.logarithmic != 0?
        errors.RuntimeError("real logarithmic asymptotics are undefined at negative infinity")!
    facts.order < 0?
        @: _symbolic_raw_number(0)
    facts.order > 0?
        sign > 0?
            @: _symbolic_infinity()
        sign < 0?
            @: -_symbolic_infinity()
        @: _symbolic_raw_number(0)
    facts.logarithmic < 0?
        @: _symbolic_raw_number(0)
    facts.logarithmic > 0?
        sign > 0?
            @: _symbolic_infinity()
        sign < 0?
            @: -_symbolic_infinity()
        @: _symbolic_raw_number(0)
    _symbolic_raw_number(sign)

limit(value:symbolic, variable:symbolic, point:symbolic) -> symbolic:
    positive_infinity: same(_symbolic_clone(point), _symbolic_clone(inf))
    negative_infinity: same(_symbolic_clone(point), -_symbolic_clone(inf))
    ~(positive_infinity \/ negative_infinity)?
        errors.ValueError("symbolic.limit symbolic point must be inf or -inf")!
    direction: 1
    negative_infinity?
        .direction: -1
    _symbolic_limit_at_infinity(value, variable, direction)

limit(variable_name:chr, value:symbolic, point:symbolic) -> symbolic:
    limit(value, _symbolic_suffix_variable(value, variable_name), point)

_symbolic_integral_endpoint(
    antiderivative:symbolic,
    variable:symbolic,
    bound:symbolic
) -> symbolic:
    simplify(substitute(antiderivative, variable, bound))

integ(variable_name:chr,
    value:symbolic,
    lower:symbolic,
    upper:symbolic
) -> symbolic:
    variable: _symbolic_suffix_variable(_symbolic_clone(value), variable_name)
    antiderivative: simplify(integrate(value, _symbolic_clone(variable)))
    upper_value: _symbolic_integral_endpoint(
        _symbolic_clone(antiderivative), _symbolic_clone(variable), upper)
    lower_value: _symbolic_integral_endpoint(
        antiderivative, variable, lower)
    simplify(upper_value - lower_value)

_symbolic_integ_upper(variable_name:chr,
    value:symbolic,
    lower:symbolic
) -> symbolic:
    variable: _symbolic_suffix_variable(_symbolic_clone(value), variable_name)
    antiderivative: simplify(integrate(value, _symbolic_clone(variable)))
    lower_value: _symbolic_integral_endpoint(
        _symbolic_clone(antiderivative), _symbolic_clone(variable), lower)
    upper_value: _symbolic_limit_at_infinity(antiderivative, variable, 1)
    simplify(upper_value - lower_value)

_symbolic_integ_lower(variable_name:chr,
    value:symbolic,
    upper:symbolic
) -> symbolic:
    variable: _symbolic_suffix_variable(_symbolic_clone(value), variable_name)
    antiderivative: simplify(integrate(value, _symbolic_clone(variable)))
    upper_value: _symbolic_integral_endpoint(
        _symbolic_clone(antiderivative), _symbolic_clone(variable), upper)
    lower_value: _symbolic_limit_at_infinity(antiderivative, variable, -1)
    simplify(upper_value - lower_value)

_symbolic_limit_value_matches(candidate:symbolic, expected:symbolic) -> bit:
    same(simplify(_symbolic_clone(candidate)), simplify(_symbolic_clone(expected)))?
        @: true
    expected_infinite: (
        same(_symbolic_clone(expected), _symbolic_clone(inf)) \/
        same(_symbolic_clone(expected), -_symbolic_clone(inf))
    )
    expected_infinite?
        @: false
    equivalent(candidate, expected)

_symbolic_verify_finite_limit(
    candidate:symbolic,
    value:symbolic,
    variable:symbolic,
    point:num,
    side:str
) -> bit:
    is_quotient: (
        _symbolic_root_kind(_symbolic_clone(value)) = 3 /\
        _symbolic_root_operation(_symbolic_clone(value)) = 4
    )
    ~is_quotient?
        expected: _symbolic_raw_number(evaluate(value, [point]))
        @: _symbolic_limit_value_matches(candidate, expected)
    numerator: _symbolic_left(_symbolic_clone(value))
    denominator: _symbolic_right(value)
    numerator_zero: same(simplify(_symbolic_clone(numerator)), constant(0))
    numerator_state: _symbolic_finite_limit_state(numerator, _symbolic_clone(variable), point)
    denominator_state: _symbolic_finite_limit_state(denominator, variable, point)
    ~denominator_state.resolved?
        @: false
    numerator_zero?
        @: _symbolic_limit_value_matches(candidate, _symbolic_raw_number(0))
    ~numerator_state.resolved?
        @: false
    numerator_state.order > denominator_state.order?
        @: _symbolic_limit_value_matches(candidate, _symbolic_raw_number(0))
    numerator_state.order = denominator_state.order?
        expected: _symbolic_raw_number(numerator_state.value / denominator_state.value)
        @: _symbolic_limit_value_matches(candidate, expected)
    pole_order: denominator_state.order - numerator_state.order
    side = "both" /\ pole_order % 2 = 1?
        @: false
    sign: numerator_state.value / denominator_state.value
    side = "left" /\ pole_order % 2 = 1?
        .sign: 0 - sign
    sign > 0?
        @: _symbolic_limit_value_matches(candidate, _symbolic_clone(inf))
    sign < 0?
        @: _symbolic_limit_value_matches(candidate, -_symbolic_clone(inf))
    false

_symbolic_verify_infinite_limit(
    candidate:symbolic,
    value:symbolic,
    variable:symbolic,
    direction:num
) -> bit:
    facts: _symbolic_asymptotic_facts(value, variable)
    ~facts.valid?
        @: false
    effective_exponential: facts.exponential * direction
    effective_exponential < 0?
        @: _symbolic_limit_value_matches(candidate, _symbolic_raw_number(0))
    sign: facts.scale
    direction < 0 /\ facts.order % 2 != 0?
        .sign: 0 - sign
    effective_exponential > 0?
        sign > 0?
            @: _symbolic_limit_value_matches(candidate, _symbolic_clone(inf))
        sign < 0?
            @: _symbolic_limit_value_matches(candidate, -_symbolic_clone(inf))
        @: _symbolic_limit_value_matches(candidate, _symbolic_raw_number(0))
    direction < 0 /\ facts.logarithmic != 0?
        @: false
    facts.order < 0?
        @: _symbolic_limit_value_matches(candidate, _symbolic_raw_number(0))
    facts.order > 0?
        sign > 0?
            @: _symbolic_limit_value_matches(candidate, _symbolic_clone(inf))
        sign < 0?
            @: _symbolic_limit_value_matches(candidate, -_symbolic_clone(inf))
        @: _symbolic_limit_value_matches(candidate, _symbolic_raw_number(0))
    facts.logarithmic < 0?
        @: _symbolic_limit_value_matches(candidate, _symbolic_raw_number(0))
    facts.logarithmic > 0?
        sign > 0?
            @: _symbolic_limit_value_matches(candidate, _symbolic_clone(inf))
        sign < 0?
            @: _symbolic_limit_value_matches(candidate, -_symbolic_clone(inf))
        @: _symbolic_limit_value_matches(candidate, _symbolic_raw_number(0))
    _symbolic_limit_value_matches(candidate, _symbolic_raw_number(sign))

verify_limit(
    candidate:symbolic,
    value:symbolic,
    variable:symbolic,
    point:num,
    side:str = "both"
) -> bit:
    ~(_symbolic_root_kind(_symbolic_clone(variable)) = 1)?
        @: false
    ~(_symbolic_domain(_symbolic_clone(variable)) = _symbolic_domain_real)?
        @: false
    ~(side = "both" \/ side = "left" \/ side = "right")?
        @: false
    _symbolic_verify_finite_limit(candidate, value, variable, point, side)

verify_limit(
    candidate:symbolic,
    value:symbolic,
    variable:symbolic,
    point:symbolic
) -> bit:
    ~(_symbolic_root_kind(_symbolic_clone(variable)) = 1)?
        @: false
    ~(_symbolic_domain(_symbolic_clone(variable)) = _symbolic_domain_real)?
        @: false
    positive_infinity: same(_symbolic_clone(point), _symbolic_clone(inf))
    negative_infinity: same(_symbolic_clone(point), -_symbolic_clone(inf))
    ~(positive_infinity \/ negative_infinity)?
        @: false
    direction: 1
    negative_infinity?
        .direction: -1
    _symbolic_verify_infinite_limit(candidate, value, variable, direction)

_symbolic_compile_evaluation_finish(source:symbolic, result:num, steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)], rule:str, ordinal:num) -> (value:num,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    ordinal < 0? @: (value:result,steps:[])
    [symbolic] output:[source]
    _symbolic_compile_numeric_finite(result) /\ _symbolic_compile_numeric_real(result)?
        output.0:_symbolic_raw_number(result)
    receipt: (ordinal:ordinal+steps.length(),rule_id:rule,status:"observed_evaluator_branch",input:_symbolic_clone(source),output:_symbolic_clone(output.0),assumption:(kind:"actual_guarded_operand",operand:_symbolic_clone(source),scope:"actual evaluator branch; original source obligations checked only when guard_exact is enabled"),numerical_requirement:"exact_algebra",execution_authority:false)
    (value:result,steps:steps & [receipt])

_symbolic_evaluate_raw_inspection(value:symbolic, catalog:[num], variables:[num], guard_exact:bit, ordinal:num) -> (value:num,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    kind: _symbolic_root_kind(value)
    kind = 1?
        index: _symbolic_catalog_entry_index(catalog, _symbolic_raw_catalog(value))
        index < 0 \/ index >= variables.length()?
            errors.ValueError("symbolic.evaluate has no actual numeric binding for this catalog identity")!
        guard_exact?
            @: _symbolic_compile_evaluation_finish(value,_symbolic_compile_guard_catalog_operand(value,variables.(index)),steps,"evaluate_actual_branch",ordinal)
        @: _symbolic_compile_evaluation_finish(value,variables.(index),steps,"evaluate_actual_branch",ordinal)
    kind = 2?
        operand: _symbolic_number_value(value)
        guard_exact /\ ~_symbolic_compile_numeric_finite(operand)?
            errors.ValueError("compiled exact source literal is a nonfinite numeric carrier")!
        @: _symbolic_compile_evaluation_finish(value,operand,steps,"evaluate_actual_branch",ordinal)
    kind = 7?
        argument_view: _symbolic_evaluate_raw_inspection(_symbolic_argument(value),catalog,variables,guard_exact,_symbolic_calculus_next(ordinal,steps.length()))
        .steps: steps & argument_view.steps
        argument: argument_view.value
        operation: _symbolic_root_operation(value)
        operation = 1? @: _symbolic_compile_evaluation_finish(value,m.sin(argument),steps,"evaluate_actual_branch",ordinal)
        operation = 2? @: _symbolic_compile_evaluation_finish(value,m.cos(argument),steps,"evaluate_actual_branch",ordinal)
        operation = 3?
            guard_exact?
                ~_symbolic_compile_numeric_finite(argument)?
                    errors.ValueError("compiled exact log domain cannot be established from this numeric operand")!
                argument = 0 \/ (_symbolic_compile_numeric_real(argument) /\ argument != 0 /\ argument = 0-m.abs(argument))?
                    errors.ValueError("compiled exact log requires a positive real operand or an established complex branch away from its cut")!
            @: _symbolic_compile_evaluation_finish(value,m.ln(argument),steps,"evaluate_actual_branch",ordinal)
        operation = 4?
            guard_exact?
                ~_symbolic_compile_numeric_finite(argument)?
                    errors.ValueError("compiled exact root domain cannot be established from this numeric operand")!
                _symbolic_compile_numeric_real(argument) /\ argument != 0 /\ argument = 0-m.abs(argument)?
                    errors.ValueError("compiled exact root requires a nonnegative real operand or an established complex branch away from its cut")!
                argument = 0 /\ ~_symbolic_compile_point_root_zero_admitted(_symbolic_argument(value),catalog,variables)?
                    errors.ValueError("compiled root roundedzero has no original nonnegative-source proof")!
            @: _symbolic_compile_evaluation_finish(value,m.sqrt(argument),steps,"evaluate_actual_branch",ordinal)
        operation = 5? @: _symbolic_compile_evaluation_finish(value,m.exp(argument),steps,"evaluate_actual_branch",ordinal)
        operation = 6? @: _symbolic_compile_evaluation_finish(value,argument,steps,"evaluate_actual_branch",ordinal)
        operation = 7? @: _symbolic_compile_evaluation_finish(value,m.abs(argument),steps,"evaluate_actual_branch",ordinal)
        errors.TypeError("symbolic.evaluate has no executable unary primitive for this source")!
    ~(kind = 3)?
        errors.TypeError("symbolic.evaluate source kind has no numeric execution rule")!
    left_view: _symbolic_evaluate_raw_inspection(_symbolic_left(value),catalog,variables,guard_exact,_symbolic_calculus_next(ordinal,steps.length()))
    .steps: steps & left_view.steps
    left: left_view.value
    right_view: _symbolic_evaluate_raw_inspection(_symbolic_right(value),catalog,variables,guard_exact,_symbolic_calculus_next(ordinal,steps.length()))
    .steps: steps & right_view.steps
    right: right_view.value
    operation: _symbolic_root_operation(value)
    operation = 1? @: _symbolic_compile_evaluation_finish(value,left + right,steps,"evaluate_actual_branch",ordinal)
    operation = 2? @: _symbolic_compile_evaluation_finish(value,left - right,steps,"evaluate_actual_branch",ordinal)
    operation = 3? @: _symbolic_compile_evaluation_finish(value,left * right,steps,"evaluate_actual_branch",ordinal)
    operation = 4?
        guard_exact?
            ~_symbolic_compile_numeric_finite(right)?
                errors.ValueError("compiled exact denominator nonzero obligation cannot be established from this numeric operand")!
            right = 0?
                errors.ValueError("compiled exact source denominator must be nonzero")!
        @: _symbolic_compile_evaluation_finish(value,left / right,steps,"evaluate_actual_branch",ordinal)
    operation = 5?
        guard_exact?
            left = 0 /\ (~_symbolic_compile_numeric_real(right) \/ right != 0 /\ right = 0-m.abs(right))?
                errors.ValueError("compiled exact zero base requires a nonnegative real exponent")!
            _symbolic_compile_numeric_real(left) /\ left != 0 /\ left = 0-m.abs(left) /\ (~_symbolic_compile_numeric_real(right) \/ m.abs(right) % 1 != 0)?
                errors.ValueError("compiled exact power branch is not established on the negative real cut")!
        @: _symbolic_compile_evaluation_finish(value,left^right,steps,"evaluate_actual_branch",ordinal)
    errors.TypeError("symbolic.evaluate operator has no executable numeric rule")!


_symbolic_evaluate_raw(value:symbolic, catalog:[num], variables:[num], guard_exact:bit=false) -> num:
    _symbolic_evaluate_raw_inspection(value,catalog,variables,guard_exact,-1).value

# Cache prototype: representation adapters only. Existing differentiate,
# integrate and evaluate remain the exact rule executors. Frontend issuance
# must bind role_scope to an owned recipe and exact completed generation.
# Scope names use the actual compiler-issued UTF8 bytes; numeric role indices
# have a bounded deterministic ASCII hex suffix, with no runtime string ABI.
_symbolic_compile_role_name(scope:[num], index:num) -> [num]:
    index < 0 \/ index >= 65536 \/ index % 1 != 0?
        errors.ValueError("compiled formal role index is outside the issued budget")!
    [num] suffix: []
    remaining: index
    ..7 >>
        digit: remaining % 16
        code: digit+48
        digit >= 10?
            .code: digit+87
        .suffix: [code] & suffix
        .remaining: (remaining-digit)/16
    scope & [58] & suffix

_symbolic_compile_formal_symbol(value:symbolic, name:[num]) -> symbol:
    _symbolic_root_kind(value) != 1?
        errors.TypeError("compiled formal role requires an actual symbol")!
    entry: _symbolic_raw_catalog(value)
    ~_symbolic_catalog_identity_same(entry, entry) \/ entry.2 = 2?
        errors.TypeError("compiled formal role requires a numeric catalog identity")!
    tail: 4 + entry.3
    [num] replacement: [0, entry.1, 1, name.length()]
    name.length() > 0?
        ..name.length()-1 >>
            .replacement: replacement & [name.($)]
    tail..entry.length()-1 >>
        .replacement: replacement & [entry.($)]
    replacement.0: replacement.length()-1
    [num] result: [1] & replacement & [1, 0, replacement.length()+4]
    result

_symbolic_compile_catalog_role_view(value:symbolic, selected:[symbolic], roles:[symbolic]) -> symbolic:
    selected.length() != roles.length()?
        errors.ValueError("compiled formal role layout changed")!
    kind: _symbolic_root_kind(value)
    storage: _symbolic_storage_kind(value)
    storage = 10 \/ kind = 4 \/ kind = 6?
        [num] catalog: []
        storage = 10?
            .catalog: _symbolic_dag_catalog(value)
        ~(storage = 10)?
            .catalog: _symbolic_raw_catalog(value)
        count: _symbolic_catalog_variable_count(catalog)
        [num] replacement: []
        count > 0?
            ..count-1 >>
                [num] entry: _symbolic_catalog_entry(catalog, $)
                selected.length() > 0?
                    ..selected.length()-1 >>
                        _symbolic_catalog_identity_same(entry, _symbolic_raw_catalog(selected.($)))?
                            .entry: _symbolic_raw_catalog(roles.($))
                .replacement: replacement & entry
        storage = 10?
            start: _symbolic_dag_node_start(value)
            length: _symbolic_dag_node_count(value)*4
            [num] nodes: []
            length > 0?
                .nodes: [start..start+length-1 >> value.($)]
            @: _symbolic_dag_make(replacement, nodes, _symbolic_dag_root(value))
        old_start: 3 + catalog.length()
        [num] payload: [old_start..value.length()-4 >> value.($)]
        [num] header: [kind, replacement.length(), value.2]
        total: 3 + replacement.length() + payload.length() + 3
        [num] result: header & replacement & payload & [kind, 0, total]
        @: result
    dag: _symbolic_as_dag(value)
    _symbolic_compile_catalog_role_view(dag,selected,roles)

_symbolic_compile_formal_view(value:symbolic, selected:[symbolic], scope:[num]) -> [symbolic]:
    ~_symbolic_compile_numeric_payload(value)?
        errors.TypeError("compiled transform source has an unresolved exact numeric rule")!
    catalog: _symbolic_catalog(value)
    count: _symbolic_catalog_variable_count(catalog)
    count > 0?
        ..count-1 >>
            entry: _symbolic_catalog_entry(catalog, $)
            matched: false
            selected.length() > 0?
                ..selected.length()-1 >>
                    _symbolic_catalog_identity_same(entry, _symbolic_raw_catalog(selected.($)))?
                        .matched: true
            ~matched?
                errors.ValueError("compiled transform source has an unmatched dependency")!
    [symbolic] roles: []
    selected.length() > 0?
        ..selected.length()-1 >>
            position: $
            position > 0?
                ..position-1 >>
                    _symbolic_catalog_identity_same(_symbolic_raw_catalog(selected.(position)), _symbolic_raw_catalog(selected.($)))?
                        errors.ValueError("compiled transform selected identities repeat")!
            name: _symbolic_compile_role_name(scope,position)
            [symbolic] candidate: [_symbolic_compile_formal_symbol(selected.(position), name)]
            # Scoped view cannot merge with an existing variable identity.
            # The source catalog, including constants, remains immutable.
            _symbolic_catalog_has_entry(catalog, _symbolic_raw_catalog(candidate.0))?>
                .name: name & [58]
                candidate.0: _symbolic_compile_formal_symbol(selected.(position), name)
            .roles: roles & [candidate.0]
    [_symbolic_compile_catalog_role_view(value, selected, roles)] & roles

_symbolic_compile_derivative_payload(value:symbolic, selected:[symbolic], groups:[num]) -> symbolic:
    [symbolic] current: [value]
    [symbolic] sum: [_symbolic_raw_number(0)]
    group_has_formal: false
    groups.length() > 0?
        ..groups.length()-1 >>
            index: groups.($)
            index = -2?
                current.0: sum.0
                sum.0: _symbolic_raw_number(0)
                .group_has_formal: false
            ~(index = -2)?
                index < 0 \/ index >= selected.length() \/ index % 1 != 0?
                    errors.ValueError("compiled derivative formal index is not owned")!
                derivative: differentiate(current.0, selected.(index))
                sum.0: _symbolic_add_simplified(sum.0, derivative)
                .group_has_formal: true
    group_has_formal?
        errors.ValueError("compiled derivative group lacks a completed selector boundary")!
    current.0

_symbolic_compile_derivative_evaluate(value:symbolic, selected:[symbolic], arguments:[num], groups:[num], scope:[num]) -> num:
    view: _symbolic_compile_formal_view(value, selected, scope)
    [symbolic] roles: []
    selected.length() > 0?
        .roles: [1..selected.length() >> view.($)]
    derivative: _symbolic_compile_derivative_payload(view.0, roles, groups)
    _symbolic_compile_evaluate_payload(derivative, roles, arguments)

_symbolic_compile_integral_evaluate(value:symbolic, selected:[symbolic], arguments:[num], groups:[num], indices:[num], lower:[num], upper:[num], scope:[num]) -> num:
    indices.length() != lower.length() \/ indices.length() != upper.length()?
        errors.ValueError("compiled integral bound layout changed")!
    view: _symbolic_compile_formal_view(value, selected, scope)
    [symbolic] roles: []
    selected.length() > 0?
        .roles: [1..selected.length() >> view.($)]
    [symbolic] primitive: [_symbolic_compile_derivative_payload(view.0, roles, groups)]
    [num] active: []
    volume: 1
    indices.length() > 0?
        ..indices.length()-1 >>
            position: $
            index: indices.(position)
            index = -1?
                .volume *: upper.(position)-lower.(position)
            ~(index = -1)?
                index < 0 \/ index >= roles.length() \/ index % 1 != 0?
                    errors.ValueError("compiled integral formal index is not owned")!
                primitive.0: integrate(primitive.0, roles.(index))
                .active: active & [position]
    active.length() > 16?
        errors.ValueError("compiled exact integral endpoint budget exceeded")!
    endpoints: 2^active.length()
    total: 0
    ..endpoints-1 >>
        mask: $
        [num] values: []
        arguments.length() > 0?
            .values: [..arguments.length()-1 >> arguments.($)]
        sign: 1
        active.length() > 0?
            ..active.length()-1 >>
                bit_position: $
                bound_position: active.(bit_position)
                formal_index: indices.(bound_position)
                int(mask / 2^bit_position) % 2 = 1?
                    values.(formal_index): upper.(bound_position)
                ~(int(mask / 2^bit_position) % 2 = 1)?
                    values.(formal_index): lower.(bound_position)
                    .sign *: -1
        .total +: sign * _symbolic_compile_evaluate_payload(primitive.0, roles, values)
    volume * total

# Generated endpoint roles retain unknown mathematical domain. Their ordinary
# num type and actual bound Graph roots are separate invocation obligations.
_symbolic_compile_unknown_formal(name:[num]) -> symbol:
    [num] entry: [0, 0, 1, name.length()]
    name.length() > 0?
        ..name.length()-1 >>
            .entry: entry & [name.($)]
    .entry: entry & [0, 0, 0, 0]
    entry.0: entry.length()-1
    [num] result: [1] & entry & [1, 0, entry.length()+4]
    result

_symbolic_compile_catalog_symbol(entry:[num]) -> symbol:
    ~_symbolic_catalog_identity_same(entry,entry)?
        errors.TypeError("compiled symbolic catalog framing changed")!
    [num] stream: [1] & entry & [1, 0, entry.length()+4]
    stream

# Exact source-domain admission uses actual catalog identities and numeric
# operands. It does not infer a mathematical domain from the public num type.
_symbolic_compile_numeric_finite(value:num) -> bit:
    value-value = 0

_symbolic_compile_numeric_real(value:num) -> bit:
    magnitude: m.abs(value)
    value = magnitude \/ value = 0-magnitude

_symbolic_compile_guard_catalog_operand(value:symbolic, operand:num) -> num:
    ~_symbolic_compile_numeric_finite(operand)?
        errors.ValueError("compiled exact source has a nonfinite numeric carrier")!
    domain: _symbolic_domain(value)
    domain = _symbolic_domain_natural \/ domain = _symbolic_domain_integer \/ domain = _symbolic_domain_rational \/ domain = _symbolic_domain_real?
        ~_symbolic_compile_numeric_real(operand)?
            errors.ValueError("compiled exact operand violates its actual selected real catalog domain")!
    domain = _symbolic_domain_natural \/ domain = _symbolic_domain_integer?
        m.abs(operand) % 1 != 0?
            errors.ValueError("compiled exact operand violates its actual selected discrete catalog domain")!
    domain = _symbolic_domain_natural /\ operand != m.abs(operand)?
        errors.ValueError("compiled exact operand violates its actual selected natural catalog domain")!
    operand

# This predicate mirrors the existing polynomial constructor admission. It
# issues no algebra/calculus result and evaluates no source computation.
_symbolic_compile_polynomial_admitted(value:symbolic, depth:num=0) -> bit:
    depth > 128?
        errors.ValueError("compiled interval polynomial admission budget exceeded")!
    kind: _symbolic_root_kind(value)
    kind = 1 \/ kind = 2 \/ kind = 4 \/ kind = 6?
        @: true
    ~(kind = 3)?
        @: false
    operation: _symbolic_root_operation(value)
    operation = 1 \/ operation = 2 \/ operation = 3?
        @: _symbolic_compile_polynomial_admitted(_symbolic_left(value),depth+1) /\ _symbolic_compile_polynomial_admitted(_symbolic_right(value),depth+1)
    operation = 5?
        exponent: _symbolic_right(value)
        _symbolic_root_kind(exponent) = 2?
            power: _symbolic_number_value(exponent)
            @: _symbolic_compile_numeric_real(power) /\ power = m.abs(power) /\ m.abs(power) % 1 = 0 /\ _symbolic_compile_polynomial_admitted(_symbolic_left(value),depth+1)
    false

# Whole-interval affine facts retain original syntax. No expanded numeric
# coefficient fold may certify an exact interval. Coefficients/offsets below
# are direct actual carriers; only exact sign/copy operations are performed.
_symbolic_compile_affine_scalar(value:symbolic, variable:symbolic, roles:[symbolic], arguments:[num], availability:[bit]=[]):
    kind: _symbolic_root_kind(value)
    ~(kind = 1 \/ kind = 2) \/ depends_on(value,variable)?
        @: (valid:false,value:0)
    ~_symbolic_compile_inputs_available(value,roles,availability)?
        @: (valid:false,value:0)
    operand: _symbolic_compile_evaluate_payload(value,roles,arguments,true)
    ~_symbolic_compile_numeric_finite(operand) \/ ~_symbolic_compile_numeric_real(operand)?
        @: (valid:false,value:0)
    (valid:true,value:operand)

_symbolic_compile_interval_affine_facts(value:symbolic, variable:symbolic, roles:[symbolic], arguments:[num], depth:num=0, availability:[bit]=[]):
    depth > 128?
        errors.ValueError("compiled interval affine syntax admission budget exceeded")!
    kind: _symbolic_root_kind(value)
    kind = 1 /\ same(value,variable)?
        @: (valid:true,rate:1,offset:0)
    kind = 1 \/ kind = 2?
        scalar: _symbolic_compile_affine_scalar(value,variable,roles,arguments,availability)
        @: (valid:scalar.valid,rate:0,offset:scalar.value)
    ~(kind = 3)?
        @: (valid:false,rate:0,offset:0)
    left: _symbolic_left(value)
    right: _symbolic_right(value)
    operation: _symbolic_root_operation(value)
    operation = 3?
        _symbolic_root_kind(right) = 1 /\ same(right,variable)?
            scalar: _symbolic_compile_affine_scalar(left,variable,roles,arguments,availability)
            @: (valid:scalar.valid,rate:scalar.value,offset:0)
        _symbolic_root_kind(left) = 1 /\ same(left,variable)?
            scalar: _symbolic_compile_affine_scalar(right,variable,roles,arguments,availability)
            @: (valid:scalar.valid,rate:scalar.value,offset:0)
        @: (valid:false,rate:0,offset:0)
    ~(operation = 1 \/ operation = 2)?
        @: (valid:false,rate:0,offset:0)
    a: _symbolic_compile_interval_affine_facts(left,variable,roles,arguments,depth+1,availability)
    b: _symbolic_compile_interval_affine_facts(right,variable,roles,arguments,depth+1,availability)
    ~a.valid \/ ~b.valid \/ (a.rate != 0 /\ b.rate != 0) \/ (a.offset != 0 /\ b.offset != 0)?
        @: (valid:false,rate:0,offset:0)
    rate: a.rate
    offset: a.offset
    rate = 0?
        .rate: b.rate
        operation = 2?
            .rate: 0-b.rate
    offset = 0?
        .offset: b.offset
        operation = 2?
            .offset: 0-b.offset
    (valid:true,rate:rate,offset:offset)

_symbolic_compile_interval_affine_nonzero(value:symbolic, variable:symbolic, roles:[symbolic], arguments:[num], lower:num, upper:num, availability:[bit]=[]) -> bit:
    ~_symbolic_compile_numeric_real(lower) \/ ~_symbolic_compile_numeric_real(upper)?
        @: false
    facts: _symbolic_compile_interval_affine_facts(value,variable,roles,arguments,0,availability)
    ~facts.valid?
        @: false
    left: facts.rate*lower+facts.offset
    right: facts.rate*upper+facts.offset
    ~_symbolic_compile_numeric_finite(left) \/ ~_symbolic_compile_numeric_finite(right)?
        @: false
    # A proved real affine map takes its whole real interval between endpoints.
    (left != 0 /\ right != 0) /\ ((left = m.abs(left) /\ right = m.abs(right)) \/ (left = 0-m.abs(left) /\ right = 0-m.abs(right)))

_symbolic_compile_interval_affine_positive(value:symbolic, variable:symbolic, roles:[symbolic], arguments:[num], lower:num, upper:num, zero_allowed:bit=false, availability:[bit]=[]) -> bit:
    ~_symbolic_compile_numeric_real(lower) \/ ~_symbolic_compile_numeric_real(upper)?
        @: false
    facts: _symbolic_compile_interval_affine_facts(value,variable,roles,arguments,0,availability)
    ~facts.valid?
        @: false
    left: facts.rate*lower+facts.offset
    right: facts.rate*upper+facts.offset
    ~_symbolic_compile_numeric_finite(left) \/ ~_symbolic_compile_numeric_finite(right)?
        @: false
    zero_allowed?
        # Rounded zero is not an exact nonnegative endpoint proof. A single
        # product can underflow, or a product/offset cancellation can round a
        # negative exact affine value to zero. Only exact copy/sign products
        # may establish a zero endpoint without an existing exact receipt.
        left = 0 /\ ~(facts.rate = 0 \/ facts.rate = 1 \/ facts.rate = -1 \/ lower = 0 \/ lower = 1 \/ lower = -1)?
            @: false
        right = 0 /\ ~(facts.rate = 0 \/ facts.rate = 1 \/ facts.rate = -1 \/ upper = 0 \/ upper = 1 \/ upper = -1)?
            @: false
        @: left = m.abs(left) /\ right = m.abs(right)
    left != 0 /\ right != 0 /\ left = m.abs(left) /\ right = m.abs(right)

_symbolic_compile_interval_admitted(value:symbolic, variable:symbolic, roles:[symbolic], arguments:[num], lower:num, upper:num, depth:num=0, availability:[bit]=[]) -> bit:
    depth > 128?
        errors.ValueError("compiled integral interval admission budget exceeded")!
    ~depends_on(value,variable)?
        # This is a conditional factor scope only; the caller must discharge
        # every missing dependency against its own actualfuture integral.
        ~_symbolic_compile_inputs_available(value,roles,availability)?
            @: true
        checked: _symbolic_compile_evaluate_payload(value,roles,arguments,true)
        @: _symbolic_compile_numeric_finite(checked)
    kind: _symbolic_root_kind(value)
    kind = 1 \/ kind = 2 \/ kind = 4 \/ kind = 6?
        @: true
    kind = 7?
        operation: _symbolic_root_operation(value)
        argument: _symbolic_argument(value)
        operation = 1 \/ operation = 2 \/ operation = 5 \/ operation = 6?
            @: _symbolic_compile_interval_admitted(argument,variable,roles,arguments,lower,upper,depth+1,availability)
        operation = 3?
            @: _symbolic_compile_interval_affine_positive(argument,variable,roles,arguments,lower,upper,false,availability)
        operation = 4?
            @: _symbolic_compile_interval_affine_positive(argument,variable,roles,arguments,lower,upper,true,availability)
        @: false
    ~(kind = 3)?
        @: false
    operation: _symbolic_root_operation(value)
    left: _symbolic_left(value)
    right: _symbolic_right(value)
    operation = 1 \/ operation = 2 \/ operation = 3?
        @: _symbolic_compile_interval_admitted(left,variable,roles,arguments,lower,upper,depth+1,availability) /\ _symbolic_compile_interval_admitted(right,variable,roles,arguments,lower,upper,depth+1,availability)
    operation = 4?
        ~_symbolic_compile_interval_admitted(left,variable,roles,arguments,lower,upper,depth+1,availability)?
            @: false
        ~depends_on(right,variable)?
            ~_symbolic_compile_inputs_available(right,roles,availability)?
                @: true
            denominator: _symbolic_compile_evaluate_payload(right,roles,arguments,true)
            @: denominator != 0
        # A nonlinear rational denominator is NOT proved by two valid endpoints.
        @: _symbolic_compile_interval_affine_nonzero(right,variable,roles,arguments,lower,upper,availability)
    operation = 5 /\ _symbolic_root_kind(right) = 2?
        exponent: _symbolic_number_value(right)
        ~_symbolic_compile_numeric_real(exponent)?
            @: false
        m.abs(exponent) % 1 = 0 /\ exponent = m.abs(exponent)?
            @: _symbolic_compile_interval_admitted(left,variable,roles,arguments,lower,upper,depth+1,availability)
        m.abs(exponent) % 1 = 0?
            @: _symbolic_compile_interval_affine_nonzero(left,variable,roles,arguments,lower,upper,availability)
        @: _symbolic_compile_interval_affine_positive(left,variable,roles,arguments,lower,upper,exponent > 0,availability)
    false

# Existing-format representation view for exact symbolic endpoint substitution.
# No coefficients/exponents are changed and no calculus rule is implemented.
_symbolic_compile_unexpanded(value:symbolic) -> symbolic:
    kind: _symbolic_root_kind(value)
    ~(kind = 4 \/ kind = 6)?
        @: _symbolic_clone(value)
    polynomial: _symbolic_as_polynomial(value)
    catalog: _symbolic_catalog(polynomial)
    variables: _symbolic_catalog_variable_count(catalog)
    [symbolic] symbols: []
    variables > 0?
        ..variables-1 >>
            entry: _symbolic_catalog_entry(catalog, $)
            .symbols: symbols & [_symbolic_compile_catalog_symbol(entry)]
    [symbolic] result: [_symbolic_raw_number(0)]
    terms: _symbolic_polynomial_term_count(polynomial)
    terms > 0?
        ..terms-1 >>
            term_index: $
            [symbolic] term: [_symbolic_raw_number(_symbolic_polynomial_term_coefficient(polynomial, term_index))]
            variables > 0?
                ..variables-1 >>
                    exponent: _symbolic_polynomial_term_exponent(polynomial, term_index, $)
                    exponent > 0?
                        power: _symbolic_power_simplified(symbols.($), _symbolic_raw_number(exponent))
                        term.0: _symbolic_multiply_simplified(term.0, power)
            result.0: _symbolic_add_simplified(result.0, term.0)
    result.0

_symbolic_compile_inputs_available(value:symbolic, roles:[symbolic], availability:[bit]) -> bit:
    availability.length() = 0? @: true
    availability.length() != roles.length()?
        errors.ValueError("compiled operand availability layout changed")!
    available:true
    roles.length() > 0?
        ..roles.length()-1 >>
            ~availability.($) /\ depends_on(value,roles.($))?
                .available:false
    available

# Locate an actual later integral over this role, following only issued
# substitution role indexes. No public name or guessedzero is a binding.
_symbolic_compile_future_interval(role:num, plan:[num], first:num):
    current:role
    found:false
    owner:-1
    lower:-1
    upper:-1
    count:plan.length()/4
    first < count?
        first..count-1 >>
            offset:$*4
            ~found /\ plan.(offset)=3 /\ plan.(offset+1)=current?
                .current:plan.(offset+2)
            ~found /\ plan.(offset)=2 /\ plan.(offset+1)=current?
                .found:true
                .owner:$
                .upper:plan.(offset+2)
                .lower:plan.(offset+3)
    (found:found,owner:owner,lower:lower,upper:upper)

_symbolic_compile_endpoint_candidates(index:num, arguments:[num], availability:[bit], plan:[num], first:num, depth:num=0) -> [num]:
    depth > 32 \/ index < 0 \/ index >= arguments.length() \/ index % 1 != 0?
        errors.ValueError("compiled endpoint role has no owned available operand")!
    availability.(index)?
        @: [arguments.(index)]
    future:_symbolic_compile_future_interval(index,plan,first)
    ~future.found?
        errors.ValueError("compiled endpoint role has no actual future integral bounds")!
    lower:_symbolic_compile_endpoint_candidates(future.lower,arguments,availability,plan,future.owner+1,depth+1)
    upper:_symbolic_compile_endpoint_candidates(future.upper,arguments,availability,plan,future.owner+1,depth+1)
    lower & upper

# Domain guard facts are linked to actual plan indexes and retained original
# input snapshots. Conditional factors are checked for EVERY missing role.
_symbolic_compile_source_guard(value:symbolic, roles:[symbolic], arguments:[num], availability:[bit], plan:[num], first:num, ordinal:num) -> (steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)],facts:[(role:num,integral_ordinal:num,lower_role:num,upper_role:num,source:symbolic,status:str)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps:[]
    [(role:num,integral_ordinal:num,lower_role:num,upper_role:num,source:symbolic,status:str)] facts:[]
    _symbolic_compile_inputs_available(value,roles,availability)?
        checked:_symbolic_compile_evaluate_payload_inspection(value,roles,arguments,true,ordinal)
        .steps:checked.steps
        ordinal >= 0?
            receipt:(ordinal:ordinal+steps.length(),rule_id:"compiled_original_source_point_checked",status:"checked",input:_symbolic_clone(value),output:_symbolic_clone(value),assumption:(kind:"actual_available_source_operands",operand:_symbolic_clone(value),scope:"actual original-source point obligations checked before erasure"),numerical_requirement:"exact_algebra",execution_authority:false)
            .steps:steps & [receipt]
        @: (steps:steps,facts:facts)
    roles.length()>0?
        ..roles.length()-1 >>
            role:$
            ~availability.(role) /\ depends_on(value,roles.(role))?
                future:_symbolic_compile_future_interval(role,plan,first)
                ~future.found?
                    errors.ValueError("compiled original source obligation lacks an actual operand or future integral scope")!
                lower:_symbolic_compile_endpoint_candidates(future.lower,arguments,availability,plan,future.owner+1)
                upper:_symbolic_compile_endpoint_candidates(future.upper,arguments,availability,plan,future.owner+1)
                ..lower.length()-1 >>
                    l:$
                    ..upper.length()-1 >>
                        _symbolic_compile_guard_catalog_operand(roles.(role),lower.(l))
                        _symbolic_compile_guard_catalog_operand(roles.(role),upper.($))
                        ~_symbolic_compile_interval_admitted(value,roles.(role),roles,arguments,lower.(l),upper.($),0,availability)?
                            errors.ValueError("compiled retained original source interval proof is not established")!
                .facts:facts & [(role:role,integral_ordinal:future.owner,lower_role:future.lower,upper_role:future.upper,source:_symbolic_clone(value),status:"checked_original_source_interval")]
                ordinal >= 0?
                    receipt:(ordinal:ordinal+steps.length(),rule_id:"compiled_original_source_future_interval_checked",status:"checked",input:_symbolic_clone(value),output:_symbolic_clone(value),assumption:(kind:"actual_issued_future_bounds",operand:_symbolic_clone(roles.(role)),scope:"all conditional missing dependencies checked against their own actual issued future integral bounds"),numerical_requirement:"exact_algebra",execution_authority:false)
                    .steps:steps & [receipt]
    (steps:steps,facts:facts)

# Only original syntax can prove nonnegative source when its numeric carrier
# rounded tozero. Direct factor signs and exact copy/sign zero cases suffice.
_symbolic_compile_point_root_zero_admitted(argument:symbolic, catalog:[num], values:[num]) -> bit:
    _symbolic_root_kind(argument)=2?
        @: _symbolic_number_value(argument)=0
    _symbolic_root_kind(argument)=3 /\ _symbolic_root_operation(argument)=2?
        same(_symbolic_left(argument),_symbolic_right(argument))?
            @: true
    [symbolic] roles:[]
    count:_symbolic_catalog_variable_count(catalog)
    count>0?
        ..count-1 >>
            .roles:roles & [_symbolic_compile_catalog_symbol(_symbolic_catalog_entry(catalog,$))]
    admitted:false
    count>0?
        ..count-1 >>
            facts:_symbolic_compile_interval_affine_facts(argument,roles.($),roles,values)
            facts.valid?
                operand:values.($)
                facts.offset=0?
                    same_sign:(facts.rate=m.abs(facts.rate) /\ operand=m.abs(operand)) \/ (facts.rate=0-m.abs(facts.rate) /\ operand=0-m.abs(operand))
                    (facts.rate=0 \/ operand=0 \/ same_sign)?
                        .admitted:true
                facts.offset!=0 /\ (facts.rate=0 \/ facts.rate=1 \/ facts.rate=-1 \/ operand=0 \/ operand=1 \/ operand=-1)?
                    facts.rate*operand+facts.offset=0?
                        .admitted:true
    admitted

_symbolic_compile_operator_plan_inspection(value:symbolic, selected:[symbolic], arguments:[num], templates:[num], plan:[num], role_scope:[num], availability:[bit], ordinal:num=-1) -> (value:num,source:symbolic,expression:symbolic,selected:[symbolic],roles:[symbolic],steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)],guards:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)],operators:[(ordinal:num,operation:num,variable:num,upper:num,lower:num,input:symbolic,output:symbolic,status:str)],facts:[(role:num,integral_ordinal:num,lower_role:num,upper_role:num,source:symbolic,status:str)],domain:(scope:str,execution_checked:bit),ordinal_scope:str,numerical_requirement:str,execution_authority:bit):
    plan.length()%4!=0 \/ arguments.length()!=templates.length() \/ arguments.length()!=availability.length() \/ selected.length()>templates.length()?
        errors.ValueError("compiled operator plan or actual availability framing changed")!
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps:[]
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] guards:[]
    [(ordinal:num,operation:num,variable:num,upper:num,lower:num,input:symbolic,output:symbolic,status:str)] operators:[]
    [(role:num,integral_ordinal:num,lower_role:num,upper_role:num,source:symbolic,status:str)] facts:[]
    [symbolic] current:[value]
    [symbolic] roles:selected
    instructions:plan.length()/4
    instructions>0?
        view:_symbolic_compile_formal_view(value,selected,role_scope)
        current.0:view.0
        .roles:[]
        selected.length()>0?
            .roles:[1..selected.length() >> view.($)]
        templates.length()>selected.length()?
            selected.length()..templates.length()-1 >>
                position:$
                template:templates.(position)
                template < -1 \/ template >= roles.length() \/ template%1!=0?
                    errors.ValueError("compiled role has no actual catalog domain issuer")!
                name:_symbolic_compile_role_name(role_scope & [58,98,111,117,110,100],position)
                [symbolic] role:[_symbolic_compile_unknown_formal(name)]
                template>=0?
                    role.0:_symbolic_compile_formal_symbol(roles.(template),name)
                _symbolic_catalog_has_entry(_symbolic_catalog(value),_symbolic_raw_catalog(role.0))?>
                    .name:name & [58]
                    role.0:_symbolic_compile_unknown_formal(name)
                    template>=0?
                        role.0:_symbolic_compile_formal_symbol(roles.(template),name)
                .roles:roles & [role.0]
        ..instructions-1 >>
            instruction:$
            offset:instruction*4
            operation:plan.(offset)
            variable:plan.(offset+1)
            upper:plan.(offset+2)
            lower:plan.(offset+3)
            ~(operation=1 \/ operation=2 \/ operation=3 \/ operation=4 \/ operation=5)?
                errors.ValueError("compiled operator is not issued")!
            operation!=4 /\ operation!=5 /\ (variable<0 \/ variable>=roles.length() \/ variable%1!=0)?
                errors.ValueError("compiled selected role is not issued")!
            # A compiled interval cannot claim every original catalog-domain
            # obligation checked from discrete endpoint samples. Formal symbolic
            # antiderivatives and ordinary int-formal extensions are separate.
            operation=2?
                ~_symbolic_is_continuous_domain(_symbolic_domain(_symbolic_clone(roles.(variable))))?
                    errors.ValueError("compiled integral selected catalog domain requires an explicit continuous extension")!
            before:_symbolic_clone(current.0)
            checked:_symbolic_compile_source_guard(current.0,roles,arguments,availability,plan,instruction,_symbolic_calculus_next(ordinal,steps.length()))
            .steps:steps & checked.steps
            .guards:guards & checked.steps
            .facts:facts & checked.facts
            operation=1?
                math:_symbolic_differentiate_inspection(current.0,roles.(variable),true,_symbolic_calculus_next(ordinal,steps.length()))
                current.0:math.expression
                .steps:steps & math.steps
            operation=2?
                lower<0 \/ upper<0 \/ lower>=roles.length() \/ upper>=roles.length()?
                    errors.ValueError("compiled integral bound role is not issued")!
                lower_values:_symbolic_compile_endpoint_candidates(lower,arguments,availability,plan,instruction+1)
                upper_values:_symbolic_compile_endpoint_candidates(upper,arguments,availability,plan,instruction+1)
                ..lower_values.length()-1 >>
                    l:$
                    ..upper_values.length()-1 >>
                        _symbolic_compile_guard_catalog_operand(roles.(variable),lower_values.(l))
                        _symbolic_compile_guard_catalog_operand(roles.(variable),upper_values.($))
                        ~_symbolic_compile_interval_admitted(current.0,roles.(variable),roles,arguments,lower_values.(l),upper_values.($),0,availability)?
                            errors.ValueError("compiled integral source interval is not established")!
                [symbolic] source:[current.0]
                _symbolic_compile_polynomial_admitted(current.0)?
                    source.0:_symbolic_as_polynomial(expand(current.0))
                math:_symbolic_integrate_inspection(source.0,roles.(variable),_symbolic_calculus_next(ordinal,steps.length()))
                .steps:steps & math.steps
                primitive:_symbolic_compile_unexpanded(math.expression)
                upper_value:substitute(primitive,roles.(variable),roles.(upper))
                lower_value:substitute(primitive,roles.(variable),roles.(lower))
                current.0:_symbolic_subtract_simplified(upper_value,lower_value)
            operation=3?
                upper<0 \/ upper>=roles.length()?
                    errors.ValueError("compiled forwarding target role is not issued")!
                current.0:substitute(_symbolic_compile_unexpanded(current.0),roles.(variable),roles.(upper))
            operation=4?
                current.0:_symbolic_raw_number(0)
            operation=5?
                upper<0 \/ lower<0 \/ upper>=roles.length() \/ lower>=roles.length()?
                    errors.ValueError("compiled absent integral endpoint role is not issued")!
                width:_symbolic_subtract_simplified(roles.(upper),roles.(lower))
                current.0:_symbolic_multiply_simplified(current.0,width)
            ordinal>=0?
                receipt:(ordinal:ordinal+steps.length(),rule_id:"compiled_operator_invocation_completed",status:"observed_operator_invocation",input:before,output:_symbolic_clone(current.0),assumption:(kind:"original_source_checked_before_erasure",operand:before,scope:"actual ordered compiler-issued operator invocation"),numerical_requirement:"exact_algebra",execution_authority:false)
                .operators:operators & [(ordinal:receipt.ordinal,operation:operation,variable:variable,upper:upper,lower:lower,input:before,output:_symbolic_clone(current.0),status:"observed_operator_invocation")]
                .steps:steps & [receipt]
    ~_symbolic_compile_inputs_available(current.0,roles,availability)?
        errors.ValueError("compiled final payload has an unresolved removed source operand")!
    result:_symbolic_compile_evaluate_payload_inspection(current.0,roles,arguments,instructions>0,_symbolic_calculus_next(ordinal,steps.length()))
    .steps:steps & result.steps
    ordinal>=0?
        receipt:(ordinal:ordinal+steps.length(),rule_id:"compiled_evaluate_completed",status:"observed_operator_invocation",input:_symbolic_clone(current.0),output:_symbolic_clone(current.0),assumption:(kind:"actual_value_retained_separately",operand:_symbolic_clone(current.0),scope:"this single owned compiled execution; value grants no Graph known-value authority"),numerical_requirement:"exact_algebra",execution_authority:false)
        .steps:steps & [receipt]
    (value:result.value,source:_symbolic_clone(value),expression:_symbolic_clone(current.0),selected:selected,roles:roles,steps:steps,guards:guards,operators:operators,facts:facts,domain:(scope:"actual original source point and issued future interval scopes",execution_checked:instructions>0),ordinal_scope:"local to this owned compiled invocation",numerical_requirement:"exact_algebra",execution_authority:false)

# Private adapter plan consists of ordered calls to EXISTING exact primitives.
# Each instruction is [operation, actual-role-index, upper-role, lower-role].
# 1=differentiate, 2=integrate+symbolic endpoint subtraction, 3=substitute,
# 4=the exact absent-public-formal derivative zero, 5=absent interval width.
_symbolic_compile_operator_plan_evaluate(value:symbolic, selected:[symbolic], arguments:[num], templates:[num], plan:[num], scope:[num], availability:[bit]) -> num:
    _symbolic_compile_operator_plan_inspection(value,selected,arguments,templates,plan,scope,availability,-1).value

# Admission adapter for actual immutable symbolic payload compilation. The
# existing evaluate implementation remains the only numeric rule executor.
_symbolic_compile_numeric_payload(value:symbolic, depth:num = 0) -> bit:
    depth > 128?
        errors.ValueError("symbolic compile payload depth budget exceeded")!
    kind: _symbolic_root_kind(value)
    kind = 4 \/ kind = 6?
        @: true
    kind = 1?
        entry: _symbolic_raw_catalog(value)
        @: _symbolic_catalog_identity_same(entry, entry) /\ entry.2 != 2
    kind = 2?
        @: true
    kind = 3?
        operation: _symbolic_root_operation(value)
        operation < 1 \/ operation > 5?
            @: false
        @: _symbolic_compile_numeric_payload(_symbolic_left(value), depth+1) /\ _symbolic_compile_numeric_payload(_symbolic_right(value), depth+1)
    kind = 7?
        operation: _symbolic_root_operation(value)
        operation < 1 \/ operation > 7?
            @: false
        @: _symbolic_compile_numeric_payload(_symbolic_argument(value), depth+1)
    false

_symbolic_compile_evaluate_payload_inspection(value:symbolic, selected:[symbolic], arguments:[num], guard_exact:bit, ordinal:num) -> (value:num,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    [(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)] steps: []
    selected.length() != arguments.length()?
        errors.ValueError("symbolic compile argument count does not match selected symbols")!
    ~_symbolic_compile_numeric_payload(value)?
        errors.TypeError("symbolic compile payload has an unresolved numeric rule or function dependency")!
    catalog: _symbolic_catalog(value)
    count: _symbolic_catalog_variable_count(catalog)
    values: [0:count]
    matched: [false:count]
    selected.length() > 0?
        ..selected.length() - 1 >>
            position: $
            symbol_value: selected.(position)
            _symbolic_root_kind(symbol_value) != 1?
                errors.TypeError("symbolic compile selected value must be an actual symbol")!
            entry: _symbolic_raw_catalog(symbol_value)
            ~_symbolic_catalog_identity_same(entry, entry) \/ entry.2 = 2?
                errors.TypeError("symbolic compile selected symbol has an unresolved function dependency")!
            guard_exact?
                _symbolic_compile_guard_catalog_operand(symbol_value,arguments.(position))
            target: _symbolic_catalog_entry_index(catalog, entry)
            position > 0?
                ..position - 1 >>
                    _symbolic_catalog_identity_same(entry, _symbolic_raw_catalog(selected.($)))?
                        errors.ValueError("symbolic compile selected symbols repeat mathematical identity")!
            # An absent selected formal is allowed; every actual dependency
            # must still be matched below before invoking evaluate.
            target >= 0 /\ target < count?
                matched.(target)?
                    errors.ValueError("symbolic compile selected symbols repeat mathematical identity")!
                values.(target): arguments.(position)
                matched.(target): true
    count > 0?
        ..count - 1 >>
            ~matched.($)?
                errors.ValueError("symbolic compile payload contains an unmatched variable, constant, or function dependency")!
    guard_exact /\ ~(_symbolic_root_kind(value) = 4 \/ _symbolic_root_kind(value) = 6)?
        @: _symbolic_evaluate_raw_inspection(value,catalog,values,true,ordinal)
    ~(_symbolic_root_kind(value) = 4 \/ _symbolic_root_kind(value) = 6)?
        @: _symbolic_evaluate_raw_inspection(value,catalog,values,guard_exact,ordinal)
    result: evaluate(value,values)
    _symbolic_compile_evaluation_finish(value,result,steps,"evaluate_existing_polynomial_or_ordinary_catalog",ordinal)

_symbolic_compile_evaluate_payload(value:symbolic, selected:[symbolic], arguments:[num], guard_exact:bit=false) -> num:
    _symbolic_compile_evaluate_payload_inspection(value,selected,arguments,guard_exact,-1).value

evaluate(value:symbolic, variables:[num]) -> num:
    ~_symbolic_compile_numeric_payload(value)?
        errors.TypeError("symbolic.evaluate requires a closed numeric expression; unresolved function or operator has no executable binding")!
    index: 0
    univariate_result: 0
    _symbolic_root_kind(value) = 6?
        variables.length() != 1?
            errors.ValueError("symbolic.evaluate expected one variable value")!
        .index: _symbolic_univariate_capacity(value) - 1
        index >= 0?>
            .univariate_result: univariate_result * variables.0 + value.(_symbolic_univariate_coefficient_start(value) + index)
            .index -: 1
        @: univariate_result
    ~(_symbolic_root_kind(value) = 4)?
        catalog: _symbolic_catalog(value)
        _symbolic_catalog_variable_count(catalog) != variables.length()?
            errors.ValueError("symbolic.evaluate variable count does not match expression")!
        @: _symbolic_evaluate_raw(value, catalog, variables)
    variable_count: _symbolic_polynomial_variable_count(value)
    variables.length() != variable_count?
        errors.ValueError("symbolic.evaluate variable count does not match polynomial")!
    catalog_length: value.(1)
    terms: _symbolic_polynomial_term_count(value)
    width: variable_count + 1
    start: catalog_length + 4
    total: 0
    ..terms - 1 >>
        term_index: $
        term: value.(start + term_index * width)
        ..variable_count - 1 >>
            .term *: variables.($)^value.(start + term_index * width + $ + 1)
        .total+: term
    total

verify_recurrence(
    solution:symbolic,
    index:symbolic,
    multiplier:num,
    offset:num,
    initial:num,
    checks:num = 16
) -> bit:
    ~(_symbolic_root_kind(index) = 1)?
        @: false
    checks < 1?
        @: false
    ~_symbolic_is_discrete_domain(_symbolic_domain(_symbolic_clone(index)))?
        @: false
    expected: solve_recurrence(multiplier, offset, initial, index)
    same(simplify(solution), simplify(expected))

verify_recurrence(
    solution:symbolic,
    recurrence:symbolic,
    initial_condition:symbolic,
    dependent:symbolic,
    index:symbolic,
    checks:num = 16
) -> bit:
    index_domain: _symbolic_domain(_symbolic_clone(index))
    ~(_symbolic_is_discrete_domain(index_domain) /\ _symbolic_dependent_accepts_domain(_symbolic_clone(dependent), index_domain))?
        @: false
    recurrence_is_equation: _symbolic_dag_operation(_symbolic_clone(recurrence)) = 13
    following: _symbolic_left(_symbolic_clone(recurrence))
    following_is_application: _symbolic_dag_operation(_symbolic_clone(following)) = 18
    following_target_matches: same(_symbolic_left(_symbolic_clone(following)), _symbolic_clone(dependent))
    shifted_index: _symbolic_right(following)
    shift_is_addition: _symbolic_dag_operation(_symbolic_clone(shifted_index)) = 3
    shift_left: _symbolic_left(_symbolic_clone(shifted_index))
    shift_right: _symbolic_right(shifted_index)
    shift_matches: (same(_symbolic_clone(shift_left), _symbolic_clone(index)) /\ _symbolic_is_raw_number(_symbolic_clone(shift_right), 1)) \/ (same(shift_right, _symbolic_clone(index)) /\ _symbolic_is_raw_number(shift_left, 1))

    affine: _symbolic_right(recurrence)
    affine_is_addition: _symbolic_dag_operation(_symbolic_clone(affine)) = 3
    affine_left: _symbolic_left(_symbolic_clone(affine))
    affine_right: _symbolic_right(affine)
    affine_left_is_number: _symbolic_root_kind(_symbolic_clone(affine_left)) = 2
    affine_right_is_number: _symbolic_root_kind(_symbolic_clone(affine_right)) = 2
    product: _symbolic_clone(affine_left)
    offset_value: _symbolic_clone(affine_right)
    affine_left_is_number?
        .product: _symbolic_clone(affine_right)
        .offset_value: _symbolic_clone(affine_left)
    product_is_multiplication: _symbolic_dag_operation(_symbolic_clone(product)) = 5
    product_left: _symbolic_left(_symbolic_clone(product))
    product_right: _symbolic_right(product)
    product_left_is_number: _symbolic_root_kind(_symbolic_clone(product_left)) = 2
    product_right_is_number: _symbolic_root_kind(_symbolic_clone(product_right)) = 2
    multiplier_value: _symbolic_clone(product_left)
    current_application: _symbolic_clone(product_right)
    product_right_is_number?
        .multiplier_value: _symbolic_clone(product_right)
        .current_application: _symbolic_clone(product_left)
    current_matches: _symbolic_recurrence_application_matches(current_application, _symbolic_clone(dependent), _symbolic_clone(index))

    condition_is_equation: _symbolic_dag_operation(_symbolic_clone(initial_condition)) = 13
    condition_application: _symbolic_left(_symbolic_clone(initial_condition))
    condition_is_at: _symbolic_dag_operation(_symbolic_clone(condition_application)) = 15
    condition_target_matches: same(_symbolic_left(_symbolic_clone(condition_application)), dependent)
    condition_at_zero: _symbolic_is_raw_number(_symbolic_right(condition_application), 0)
    initial_value: _symbolic_right(initial_condition)
    initial_is_number: _symbolic_root_kind(_symbolic_clone(initial_value)) = 2

    valid_problem: recurrence_is_equation /\ following_is_application /\ following_target_matches /\ shift_is_addition /\ shift_matches /\ affine_is_addition /\ (affine_left_is_number \/ affine_right_is_number) /\ product_is_multiplication /\ (product_left_is_number \/ product_right_is_number) /\ current_matches /\ condition_is_equation /\ condition_is_at /\ condition_target_matches /\ condition_at_zero /\ initial_is_number
    valid_problem?
        multiplier: _symbolic_number_value(multiplier_value)
        offset: _symbolic_number_value(offset_value)
        initial: _symbolic_number_value(initial_value)
        @: verify_recurrence(solution, index, multiplier, offset, initial, checks)
    false

_symbolic_recurrence_characteristic_root_matches(
    base:symbolic,
    index:symbolic,
    first_multiplier:num,
    second_multiplier:num
) -> bit:
    depends_on(_symbolic_clone(base), index)?
        @: false
    variable_count: _symbolic_catalog_variable_count(_symbolic_catalog(_symbolic_clone(base)))
    variable_count > 1?
        @: false
    [num] no_variables: []
    root: 0
    variable_count = 0?
        .root: evaluate(_symbolic_clone(base), no_variables)
    variable_count = 1?
        .root: evaluate(base, [0])
    m.abs(root * root - first_multiplier * root - second_multiplier) < 0.000000001

_symbolic_recurrence_power_mode_matches(
    value:symbolic,
    index:symbolic,
    first_multiplier:num,
    second_multiplier:num
) -> bit:
    ~(_symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 5)?
        @: false
    exponent: _symbolic_right(_symbolic_clone(value))
    ~same(exponent, _symbolic_clone(index))?
        @: false
    _symbolic_recurrence_characteristic_root_matches(
        _symbolic_left(value),
        index,
        first_multiplier,
        second_multiplier
    )

_symbolic_recurrence_is_index_power(value:symbolic, index:symbolic) -> bit:
    (
        _symbolic_root_kind(_symbolic_clone(value)) = 3 /\
        _symbolic_root_operation(_symbolic_clone(value)) = 5 /\
        same(_symbolic_right(_symbolic_clone(value)), _symbolic_clone(index)) /\
        ~depends_on(_symbolic_left(value), index)
    )

_symbolic_recurrence_trigonometric_mode_matches(
    value:symbolic,
    index:symbolic,
    radius:num,
    first_multiplier:num,
    second_multiplier:num
) -> bit:
    trigonometric: _symbolic_trigonometric_candidate_facts(
        value,
        index
    )
    ~trigonometric.valid?
        @: false
    has_sine: m.abs(trigonometric.sine_scale) >= 0.000000000001
    has_cosine: m.abs(trigonometric.cosine_scale) >= 0.000000000001
    ~(has_sine \/ has_cosine)?
        @: false
    frequency: trigonometric.cosine_frequency
    has_sine?
        .frequency: trigonometric.sine_frequency
    has_sine /\ has_cosine /\ m.abs(trigonometric.sine_frequency - trigonometric.cosine_frequency) >= 0.000000001?
        @: false
    (
        m.abs(first_multiplier - 2 * radius * m.cos(frequency)) < 0.000000001 /\
        m.abs(second_multiplier + radius * radius) < 0.000000001
    )

_symbolic_recurrence_damped_trigonometric_mode_matches(
    value:symbolic,
    index:symbolic,
    first_multiplier:num,
    second_multiplier:num
) -> bit:
    ~(_symbolic_root_kind(_symbolic_clone(value)) = 3 /\ _symbolic_root_operation(_symbolic_clone(value)) = 3)?
        @: false
    left: _symbolic_left(_symbolic_clone(value))
    right: _symbolic_right(value)
    left_is_power: _symbolic_recurrence_is_index_power(
        _symbolic_clone(left),
        _symbolic_clone(index)
    )
    right_is_power: _symbolic_recurrence_is_index_power(
        _symbolic_clone(right),
        _symbolic_clone(index)
    )
    left_is_power = right_is_power?
        @: false
    power: constant(0)
    oscillation: constant(0)
    left_is_power?
        .power: _symbolic_clone(left)
        .oscillation: _symbolic_clone(right)
    right_is_power?
        .power: _symbolic_clone(right)
        .oscillation: _symbolic_clone(left)
    base: _symbolic_left(power)
    variable_count: _symbolic_catalog_variable_count(_symbolic_catalog(_symbolic_clone(base)))
    variable_count > 1?
        @: false
    [num] no_variables: []
    radius: 0
    variable_count = 0?
        .radius: evaluate(_symbolic_clone(base), no_variables)
    variable_count = 1?
        .radius: evaluate(base, [0])
    _symbolic_recurrence_trigonometric_mode_matches(
        oscillation,
        index,
        radius,
        first_multiplier,
        second_multiplier
    )

_symbolic_recurrence_candidate_modes_match(
    value:symbolic,
    index:symbolic,
    first_multiplier:num,
    second_multiplier:num
) -> bit:
    ~depends_on(_symbolic_clone(value), _symbolic_clone(index))?
        @: m.abs(1 - first_multiplier - second_multiplier) < 0.000000001
    affine: _symbolic_affine_candidate_facts(
        _symbolic_clone(value),
        _symbolic_clone(index)
    )
    affine.valid?
        recurrence_scale: first_multiplier + second_multiplier
        linear_residual: affine.linear - recurrence_scale * affine.linear
        constant_residual: (
            affine.constant + 2 * affine.linear -
            recurrence_scale * affine.constant -
            first_multiplier * affine.linear
        )
        @: m.abs(linear_residual) < 0.000000001 /\ m.abs(constant_residual) < 0.000000001
    _symbolic_recurrence_trigonometric_mode_matches(
        _symbolic_clone(value),
        _symbolic_clone(index),
        1,
        first_multiplier,
        second_multiplier
    )?
        @: true
    _symbolic_recurrence_damped_trigonometric_mode_matches(
        _symbolic_clone(value),
        _symbolic_clone(index),
        first_multiplier,
        second_multiplier
    )?
        @: true
    kind: _symbolic_root_kind(_symbolic_clone(value))
    ~(kind = 3)?
        @: false
    operation: _symbolic_root_operation(_symbolic_clone(value))
    operation = 1 \/ operation = 2?
        @: (
            _symbolic_recurrence_candidate_modes_match(
                _symbolic_left(_symbolic_clone(value)),
                _symbolic_clone(index),
                first_multiplier,
                second_multiplier
            ) /\
            _symbolic_recurrence_candidate_modes_match(
                _symbolic_right(value),
                index,
                first_multiplier,
                second_multiplier
            )
        )
    operation = 4?
        denominator: _symbolic_right(_symbolic_clone(value))
        depends_on(_symbolic_clone(denominator), _symbolic_clone(index))?
            @: false
        @: _symbolic_recurrence_candidate_modes_match(
            _symbolic_left(value),
            index,
            first_multiplier,
            second_multiplier
        )
    operation = 5?
        @: _symbolic_recurrence_power_mode_matches(
            value,
            index,
            first_multiplier,
            second_multiplier
        )
    operation = 3?
        left: _symbolic_left(_symbolic_clone(value))
        right: _symbolic_right(value)
        left_depends: depends_on(_symbolic_clone(left), _symbolic_clone(index))
        right_depends: depends_on(_symbolic_clone(right), _symbolic_clone(index))
        ~left_depends?
            @: _symbolic_recurrence_candidate_modes_match(
                right,
                index,
                first_multiplier,
                second_multiplier
            )
        ~right_depends?
            @: _symbolic_recurrence_candidate_modes_match(
                left,
                index,
                first_multiplier,
                second_multiplier
            )
        left_is_power: _symbolic_recurrence_power_mode_matches(
            _symbolic_clone(left),
            _symbolic_clone(index),
            first_multiplier,
            second_multiplier
        )
        right_is_power: _symbolic_recurrence_power_mode_matches(
            _symbolic_clone(right),
            _symbolic_clone(index),
            first_multiplier,
            second_multiplier
        )
        left_affine: _symbolic_affine_candidate_facts(
            _symbolic_clone(left),
            _symbolic_clone(index)
        )
        right_affine: _symbolic_affine_candidate_facts(
            _symbolic_clone(right),
            _symbolic_clone(index)
        )
        repeated_root: first_multiplier / 2
        repeated_characteristic: m.abs(
            repeated_root * repeated_root -
            first_multiplier * repeated_root -
            second_multiplier
        ) < 0.000000001
        repeated_derivative: m.abs(2 * repeated_root - first_multiplier) < 0.000000001
        @: (
            repeated_characteristic /\
            repeated_derivative /\
            ((left_is_power /\ right_affine.valid) \/ (right_is_power /\ left_affine.valid))
        )
    false

_symbolic_recurrence_candidate_matches_initial(
    value:symbolic,
    index:symbolic,
    point:num,
    expected:num
) -> bit:
    variable_count: _symbolic_catalog_variable_count(_symbolic_catalog(_symbolic_clone(value)))
    variable_count > 1?
        @: false
    [num] no_variables: []
    actual: 0
    variable_count = 0?
        .actual: evaluate(_symbolic_clone(value), no_variables)
    variable_count = 1?
        .actual: evaluate(value, [point])
    m.abs(actual - expected) < 0.000000001

verify_recurrence(
    solution:symbolic,
    recurrence:symbolic,
    initial_conditions:[symbolic:2],
    dependent:symbolic,
    index:symbolic,
    checks:num = 16
) -> bit:
    checks < 1?
        @: false
    index_domain: _symbolic_domain(_symbolic_clone(index))
    ~(_symbolic_is_discrete_domain(index_domain) /\ _symbolic_dependent_accepts_domain(_symbolic_clone(dependent), index_domain))?
        @: false
    problem: _symbolic_second_order_recurrence_problem(
        recurrence,
        initial_conditions,
        dependent,
        _symbolic_clone(index)
    )
    ~problem.valid?
        @: false
    mode_residual: _symbolic_recurrence_candidate_modes_match(
        _symbolic_clone(solution),
        _symbolic_clone(index),
        problem.first_multiplier,
        problem.second_multiplier
    )
    initial_zero_residual: _symbolic_recurrence_candidate_matches_initial(
        _symbolic_clone(solution),
        _symbolic_clone(index),
        0,
        problem.initial_zero
    )
    initial_one_residual: _symbolic_recurrence_candidate_matches_initial(
        solution,
        index,
        1,
        problem.initial_one
    )
    mode_residual /\ initial_zero_residual /\ initial_one_residual

solve_recurrence(
    recurrence:symbolic,
    initial_condition:symbolic,
    dependent:symbolic,
    index:symbolic
) -> symbolic:
    candidate: _symbolic_solve_recurrence_unverified(
        _symbolic_clone(recurrence),
        _symbolic_clone(initial_condition),
        _symbolic_clone(dependent),
        _symbolic_clone(index)
    )
    verify_recurrence(_symbolic_clone(candidate), recurrence, initial_condition, dependent, index)?
        @: candidate
    errors.RuntimeError("native symbolic recurrence candidate failed residual or initial-condition verification")!

solve_recurrence(
    recurrence:symbolic,
    initial_conditions:[symbolic:2],
    dependent:symbolic,
    index:symbolic
) -> symbolic:
    problem: _symbolic_second_order_recurrence_problem(
        _symbolic_clone(recurrence),
        [_symbolic_clone(initial_conditions.0), _symbolic_clone(initial_conditions.1)],
        _symbolic_clone(dependent),
        _symbolic_clone(index)
    )
    ~problem.valid?
        errors.RuntimeError("native symbolic second-order recurrence planner has no strategy for this problem")!
    candidate: _symbolic_solve_second_order_recurrence(
        problem.first_multiplier,
        problem.second_multiplier,
        problem.initial_zero,
        problem.initial_one,
        index
    )
    verify_recurrence(
        _symbolic_clone(candidate),
        recurrence,
        initial_conditions,
        dependent,
        _symbolic_clone(index)
    )?
        @: candidate
    errors.RuntimeError("native symbolic second-order recurrence candidate failed residual or initial-condition verification")!

_symbolic_problem_is_recurrence(relation:symbolic, dependent:symbolic) -> bit:
    ~(_symbolic_dag_operation(_symbolic_clone(relation)) = 13)?
        @: false
    left: _symbolic_left(_symbolic_clone(relation))
    right: _symbolic_right(relation)
    left_is_application: _symbolic_dag_operation(_symbolic_clone(left)) = 18
    right_is_application: _symbolic_dag_operation(_symbolic_clone(right)) = 18
    left_matches: false
    right_matches: false
    left_is_application?
        .left_matches: same(_symbolic_left(left), _symbolic_clone(dependent))
    right_is_application?
        .right_matches: same(_symbolic_left(right), dependent)
    left_matches \/ right_matches

solve(
    relation:symbolic,
    conditions:[symbolic:1],
    dependent:symbolic,
    independent:symbolic
) -> symbolic:
    recurrence_problem: _symbolic_problem_is_recurrence(
        _symbolic_clone(relation),
        _symbolic_clone(dependent)
    )
    recurrence_problem?
        @: solve_recurrence(
            relation,
            conditions.0,
            dependent,
            independent
        )
    solve_ode(
        relation,
        conditions.0,
        dependent,
        independent
    )

solve(
    relation:symbolic,
    conditions:[symbolic:2],
    dependent:symbolic,
    independent:symbolic
) -> symbolic:
    recurrence_problem: _symbolic_problem_is_recurrence(
        _symbolic_clone(relation),
        _symbolic_clone(dependent)
    )
    recurrence_problem?
        @: solve_recurrence(
            relation,
            conditions,
            dependent,
            independent
        )
    solve_ode(
        relation,
        conditions,
        dependent,
        independent
    )

solve(
    relation:symbolic,
    conditions:[symbolic:n],
    dependent:symbolic,
    independent:[symbolic:m]
) -> symbolic:
    solve_pde(
        relation,
        conditions,
        dependent,
        independent
    )

_symbolic_binomial_term(left:symbolic, right:symbolic, degree:num, index:num, coefficient:num) -> symbolic:
    coefficient * left^(degree - index) * right^index

_symbolic_expand_binomial_power(value:symbolic, degree:num) -> symbolic:
    left: _symbolic_left(value)
    right: _symbolic_right(value)
    result: left^degree
    coefficient: 1
    1..degree >>
        .coefficient: coefficient * (degree - $ + 1) / $
        .result: result + _symbolic_binomial_term(left, right, degree, $, coefficient)
    result

_symbolic_expand_power_only(value:symbolic) -> symbolic:
    base: _symbolic_left(value)
    exponent: _symbolic_right(value)
    ~(_symbolic_root_kind(exponent) = 2)?
        @: _symbolic_clone(value)
    degree: _symbolic_number_value(exponent)
    degree < 0 \/ ~(degree % 1 = 0)?
        @: _symbolic_clone(value)
    direct_multinomial: _symbolic_root_kind(exponent) = 2 /\ degree >= 0 /\ degree % 1 = 0 /\ _symbolic_is_distinct_symbol_sum(base)
    direct_multinomial?
        @: _symbolic_expand_distinct_sum_power(base, degree)
    expanded: expand(base)
    _symbolic_polynomial_power(expanded, degree)

_symbolic_expand_add(value:symbolic) -> symbolic:
    left: expand(_symbolic_left(value))
    right: expand(_symbolic_right(value))
    _symbolic_polynomial_add(left, right)

_symbolic_expand_subtract(value:symbolic) -> symbolic:
    left: expand(_symbolic_left(value))
    right: expand(_symbolic_right(value))
    _symbolic_polynomial_subtract(left, right)

_symbolic_expand_multiply(value:symbolic) -> symbolic:
    left: expand(_symbolic_left(value))
    right: expand(_symbolic_right(value))
    _symbolic_polynomial_multiply(left, right)

expand(value:symbolic) -> symbolic:
    ~(_symbolic_root_kind(value) = 3)?
        @: _symbolic_clone(value)
    _symbolic_root_operation(value)??
        1 => @: _symbolic_expand_add(value)
        2 => @: _symbolic_expand_subtract(value)
        3 => @: _symbolic_expand_multiply(value)
        5 => @: _symbolic_expand_power_only(value)
        @: _symbolic_clone(value)

collect(value:symbolic) -> symbolic:
    expand(value)

_symbolic_simplify_inspection(value:symbolic, ordinal:num) -> (expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)]):
    kind: _symbolic_root_kind(value)
    kind = 1 \/ kind = 2 \/ kind = 4 \/ kind = 6?
        @: _symbolic_inspection_rule(value, _symbolic_clone(value), "leaf_unchanged", "unchanged", "issued_leaf_domain_retained", value, ordinal)
    kind = 7?
        argument: _symbolic_simplify_inspection(_symbolic_argument(value), ordinal)
        rebuilt: _symbolic_rebuild_inspection(argument.expression, _symbolic_root_operation(value), ordinal + argument.steps.length())
        @: (expression:rebuilt.expression, steps:argument.steps & rebuilt.steps)
    ~(kind = 3)?
        errors.TypeError("symbolic.simplify received an unsupported expression kind")!
    left: _symbolic_simplify_inspection(_symbolic_left(value), ordinal)
    right: _symbolic_simplify_inspection(_symbolic_right(value), ordinal + left.steps.length())
    next: ordinal + left.steps.length() + right.steps.length()
    _symbolic_root_operation(value)??
        1 =>
            operation: _symbolic_add_inspection(left.expression, right.expression, next)
            @: (expression:operation.expression, steps:left.steps & right.steps & operation.steps)
        2 =>
            operation: _symbolic_subtract_inspection(left.expression, right.expression, next)
            @: (expression:operation.expression, steps:left.steps & right.steps & operation.steps)
        3 =>
            operation: _symbolic_multiply_inspection(left.expression, right.expression, next)
            @: (expression:operation.expression, steps:left.steps & right.steps & operation.steps)
        4 =>
            operation: _symbolic_divide_inspection(left.expression, right.expression, next)
            @: (expression:operation.expression, steps:left.steps & right.steps & operation.steps)
        5 =>
            operation: _symbolic_power_inspection(left.expression, right.expression, next)
            @: (expression:operation.expression, steps:left.steps & right.steps & operation.steps)
        errors.TypeError("symbolic.simplify received an unsupported operation")!

inspect_simplify(value:symbolic) -> (source:symbolic,expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)],domain:(scope:str,execution_checked:bit),ordinal_scope:str,numerical_requirement:str,execution_authority:bit):
    result: _symbolic_simplify_inspection(value, 0)
    (source:_symbolic_clone(value), expression:_symbolic_clone(result.expression),
     steps:result.steps,
     domain:(scope:"original source obligations retained; mathematical identities are conditional on declared scalar domains", execution_checked:false),
     ordinal_scope:"local to this owned inspection invocation",
     numerical_requirement:"exact_algebra", execution_authority:false)

# Executing an inspection retains the exact original expression and its catalog.
# This does not impose a new finite-input policy or select reordered arithmetic.
evaluate_inspection(view:(source:symbolic,expression:symbolic,steps:[(ordinal:num,rule_id:str,status:str,input:symbolic,output:symbolic,assumption:(kind:str,operand:symbolic,scope:str),numerical_requirement:str,execution_authority:bit)],domain:(scope:str,execution_checked:bit),ordinal_scope:str,numerical_requirement:str,execution_authority:bit), variables:[num]) -> num:
    evaluate(_symbolic_clone(view.source), variables)

simplify(value:symbolic) -> symbolic:
    _symbolic_simplify_inspection(value, -1).expression

substitute(value:symbolic, variable:symbolic, replacement:symbolic) -> symbolic:
    ~(_symbolic_root_kind(variable) = 1)?
        errors.TypeError("symbolic.substitute variable must be a symbol")!
    same(value, variable)?
        @: _symbolic_clone(replacement)
    kind: _symbolic_root_kind(value)
    kind = 1 \/ kind = 2?
        @: _symbolic_clone(value)
    kind = 4 \/ kind = 6?
        errors.TypeError("symbolic.substitute expects an unexpanded expression")!
    kind = 7?
        argument: substitute(_symbolic_argument(value), variable, replacement)
        @: _symbolic_rebuild_function(argument, _symbolic_root_operation(value))
    ~(kind = 3)?
        errors.TypeError("symbolic.substitute received an unsupported expression kind")!
    left: substitute(_symbolic_left(value), variable, replacement)
    right: substitute(_symbolic_right(value), variable, replacement)
    operation: _symbolic_root_operation(value)
    operation = 1?
        @: _symbolic_add_simplified(left, right)
    operation = 2?
        @: _symbolic_subtract_simplified(left, right)
    operation = 3?
        @: _symbolic_multiply_simplified(left, right)
    operation = 4?
        @: _symbolic_divide_simplified(left, right)
    operation = 5?
        @: _symbolic_power_simplified(left, right)
    _symbolic_dag_binary(left, right, operation + 2)

substitute(value:symbolic, variable:symbolic, replacement:num) -> symbolic:
    substitute(value, variable, constant(replacement))

substitute(variable_name:chr, value:symbolic, replacement:symbolic) -> symbolic:
    substitute(value, _symbolic_suffix_variable(value, variable_name), replacement)

substitute(variable_name:chr, value:symbolic, replacement:num) -> symbolic:
    substitute(value, _symbolic_suffix_variable(value, variable_name), replacement)

term_count(value:symbolic) -> num:
    _symbolic_storage_kind(value) = 10?
        @: _symbolic_dag_term_count(value, _symbolic_dag_root(value))
    _symbolic_root_kind(value) = 4?
        @: _symbolic_polynomial_term_count(value)
    _symbolic_root_kind(value) = 6?
        @: value.(_symbolic_univariate_count_index(value))
    terms: 1
    cursor: 0
    cursor < value.length()?>
        kind: value.(cursor)
        kind = 1?
            .cursor+: value.(cursor + 1) + 3
        kind = 2?
            .cursor+: 3
        kind = 3?
            operation: value.(cursor + 1)
            operation = 1?
                .terms+: 1
            operation = 2?
                .terms+: 1
            .cursor+: 3
    terms

series_multiply(left:[num], right:[num], order:num) -> [num]:
    order < 0 \/ ~(order % 1 = 0)?
        errors.ValueError("symbolic.series_multiply order must be a nonnegative integer")!
    result: [0:order]
    left_limit: left.length()
    left_limit > order?
        .left_limit: order
    left_index: 0
    right_limit: 0
    right_index: 0
    output_index: 0
    left_index < left_limit?>
        .right_limit: right.length()
        right_limit > order - left_index?
            .right_limit: order - left_index
        .right_index: 0
        right_index < right_limit?>
            .output_index: left_index + right_index
            result.(output_index): result.(output_index) + left.(left_index) * right.(right_index)
            .right_index+: 1
        .left_index+: 1
    result