- 1. Getting Started
- 1.1. Overview
- 1.2. Installing and Running Biocham Locally
- 1.3. About this manual
- 2. Syntax of Biocham Reaction Systems
- 3. Syntax of Biocham Influence Systems
- 4. Syntax of Biocham Temporal Properties
- 5. Commands at Top-level
- 5.1. Loading, listing, importing and exporting models
- 5.1.1. Biocham files
- 5.1.2. SBML files
- 5.1.3. ODE files
- 5.1.4. GPAC files
- 5.1.5. Transfer function files
- 5.1.6. Graphics files
- 5.1.7. Other files
- 5.2. Listing and editing reactions, influences and events
- 5.2.1. Reactions
- 5.2.2. Influences
- 5.2.3. Events
- 5.3. Listing and defining initial states, molecules and locations
- 5.3.1. Molecules
- 5.3.2. Initial state
- 5.4. Listing and declaring parameters, functions and aliases
- 5.4.1. Parameters
- 5.4.2. Functions
- 5.4.3. Aliases
- 5.5. Simulations
- 5.5.1. ODE and stochastic simulations
- 5.5.2. Traces and tables
- 5.5.3. Plotting the result of simulations
- 5.6. Listing and editing graphs
- 5.7. Static analyses
- 5.8. Boolean dynamical analyses
- 5.9. Numerical dynamical analyses
- 5.9.1. Parameter search
- 5.9.2. Sensitivity of FOLTL(R) properties
- 5.9.3. Robustness of FOLTL(R) properties
- 6. Index
- 7. Bibliography

Getting Started

- a rule-based language for modeling biochemical systems (compatible with SBML and SBGN),
- static analysers for inferring various dynamical properties from the structure of the model;
- simulators for the different semantics: continuous (differential equations), stochastic, asynchronous Boolean;
- a temporal logic based language to formalize the temporal behaviours of biological systems, validate models with respect to such specifications by model-checking methods, infer parameter values in high dimension with temporal logic constraints, measure parameter sensitivity indices and robustness of temporal properties;
- unique features for developing/correcting/completing/reducing/coupling models.

Biocham is a free software protected by the GNU General Public License GPL
version 2. This is an Open Source license that allows free usage of this
software.

### 1.2. Installing and Running Biocham Locally

### 1.3. About this manual

This reference manual (and its extended version for developpers) is automaticaly generated from the source code of Biocham.
The syntax of Biocham is described with formal grammar rules which define new syntactic tokens from primitive tokens such as atom (i.e. string), number, term (e.g. atom(..., ...)).
For instance, the syntax of an input or output file is just the syntax of an atom in both cases, but they are distinguished in this manual for documentation purposes:

## Chapter 2

Syntax of Biocham Reaction Systems

### 2.1. Biochemical objects

### 2.2. Reaction and transport rules

## Chapter 3

Syntax of Biocham Influence Systems

## Chapter 4

Syntax of Biocham Temporal Properties

### 4.1. Boolean temporal logic CTL

### 4.2. First-order numerical temporal logic FOLTL(R)

## Chapter 5

Commands at Top-level

`about.`

input_file ::= |

output_file ::= |

Syntax of Biocham Reaction Systems

concentration ::= |

time ::= |

name ::= |

parameter ::= |

function_prototype ::= |

object ::= |

reaction ::= |

basic_reaction ::= |

solution ::= |
| `_` |

kinetics ::= |

condition ::= |
| `true` | `false` |

arithmetic_expression ::= |

Syntax of Biocham Influence Systems

influence ::= |

basic_influence ::= |

inputs ::= |

enumeration ::= |
| `_` |

Syntax of Biocham Temporal Properties

ctl ::= | reachable(φ) is equivalent to EF(φ)oscil(φ) is equivalent to AG((φ -> EF(not φ)) /\ (not φ -> EF(φ))), i.e. AG(EF(φ) /\ EF(not φ))checkpoint(φ, ψ) is equivalent to not EU(not φ, ψ) |

`add_ctl(``Formula`: ctl).

Adds a CTL formula to the currently declared CTL specification.

`delete_ctl(``Formula`: ctl).

Removes a CTL formula to the currently declared CTL specification.

`delete_ctl.`

Removes all formulae from the current CTL specification.

`list_ctl.`

Prints out all formulae from the current CTL specification.

foltl ::= |

foltl_predicate ::= |

foltl_expression ::= |

`validity_domain(``Formula`: foltl).

solves a FOLTL(R) constraint on the current trace, i.e. computes
the validity domain for the free variables
that make the formula true on the numerical trace.

Commands at Top-level

`quit.`

quits the interpreter.

Some commands (e.g., `numerical_simulation/1`

) take named options
as arguments.
All the options can either be defined either locally for a single command or
globally for the whole model.
Options can be defined for a single command
by adding additional arguments of the form `Option: Value`

.
`biocham: `

`biocham: `

`biocham: `

`biocham: `

`biocham: `

Options can be defined globally for the model with the command

### 5.1. Loading, listing, importing and exporting models

#### 5.1.1. Biocham files

#### 5.1.2. SBML files

#### 5.1.3. ODE files

**Example.**
`a=>b.`
`list_ode.`

**Example.**
`present(x,1).`
`present(y,3).`
`add_function(z=x+y).`
`list_reactions.`
`list_ode.`
#### 5.1.4. GPAC files

Biocham can import GPAC (Shannon's General Purpose Analog Computer) and compile them into reaction systems. Only weak GPACs, in which the integration is with respect to time and not a variable, are considered. The syntax of weak GPACs is as follows:

`option(Option: Value, ..., Option: Value)`

.
Local options take precedence over global options.
`list_options.`

lists the set of options defined in the current model.

range ::= |

ref ::= |

`load(input_file).`

acts as the corresponding

`load_biocham/1`

/ `load_sbml/1`

/ `load_ode/1`

/ `load_trace/1`

,
depending on the file extension
(respectively `.bc`

, `.xml`

, `.ode`

, `.csv`

– assuming no extension is `.bc`

).
`add(input_file).`

acts as the corresponding

`add_biocham/1`

/ `add_sbml/1`

/ `add_ode/1`

/ `add_trace/1`

,
depending on the file extension
(respectively `.bc`

, `.xml`

, `.ode`

, `.csv`

– assuming no extension is `.bc`

).
`load_biocham(input_file).`

opens a new model, loads the reaction rules and executes the commands
(with the file directory as current directory)
contained in the given Biocham

`.bc`

file.
The suffix `.bc`

is automatically added to the name if such a
file exists.
`add_biocham(input_file).`

the rules of the given *added* to the current set of rules.
The commands contained in the file are executed
(with the file directory as current directory).

`.bc`

file are loaded and
`export_biocham(output_file).`

exports the current model into a

`.bc`

file.
`new_model.`

opens a new fresh model.

`clear_model.`

clears the current model.

`list_models.`

lists all open models.

`list_current_models.`

lists current models.

`list_model.`

lists the contents of the current Biocham model.

`select_model({ref`_{1}, ...,
ref_{n}}).

selects some models.

`set_model_name(name).`

changes the current model name.

`delete([range`_{1}],
...,
[range_{n}]).

deletes the listed elements from the model.

`inherits(ref`_{1},
...,
ref_{n}).

makes the current model inherit from the given ancestor models.

`load_sbml(input_file).`

acts as

`load_biocham/1`

but importing reactions, parameters and
initial state (and only that!) from an SBML .xml file.
`add_sbml(input_file).`

acts as

`add_biocham/1`

but importing reactions, parameters and
initial state (and only that!) from an SBML .xml file.
`load_qual(input_file).`

acts as

`load_biocham/1`

but importing influences and
initial state (and only that!) from an SBML3qual .sbml file.
`add_qual(input_file).`

acts as

`add_biocham/1`

but importing influences and
initial state (and only that!) from an SBML3qual .sbml file.
oderef ::= |

`new_ode_system.`

creates an ODE system.

`delete_ode_system(name).`

deletes an ODE system.

`set_ode_system_name(name).`

sets the name of the current ODE system.

`list_ode_systems.`

lists the ODE systems of the current model.

`select_ode_system(name).`

selects an ODE system

ode ::= |

`add_ode(ode`_{1},
...,
ode_{n}).

If there is a current ODE system, adds the given set of ODEs to it.
If there is no current ODE system,
imports the reactions inferred from the given set of ODEs.

`import_reactions_from_ode_system.`

adds the reactions that match the current ODE system.

`delete_ode(oderef`_{1},
...,
oderef_{n}).

removes the given set of ODEs from the current ODE system.

`list_ode.`

returns the set of ordinary differential equations
and initial concentrations (one line per molecule)
associated to the current model.

`biocham: `

`biocham: `

[0] d(b)/dt=a [1] d(a)/dt= -a

`ode_system.`

builds the set of ODES corresponding to the reactions of the current model.

`import_ode(input_file).`

imports a set of ODEs.

`init(name`_{1} = arithmetic_expression_{1},
...,
name_{n} =
arithmetic_expression_{n}).

sets the initial value of a variable in the current set of ODEs.

`load_ode_system(input_file).`

acts as

`load_biocham/1`

but importing a model from an ODE system.
`add_ode_system(input_file).`

acts as

`add_biocham/1`

but importing a model from an ODE system.
`export_ode_system(output_file).`

exports the current ODE system.

`add_function(term`_{1} = term_{1},
...,
term_{n} =
term_{n}).

adds reactions to compute the result of a function of the current variables in the concentration of a new variable at steady state.

`biocham: `

`biocham: `

`biocham: `

`biocham: `

[0] _=[x]=>z [1] _=[y]=>z [2] z=>_

`biocham: `

[0] d(z)/dt=x+y-z [1] d(y)/dt=0 [2] d(x)/dt=0

wgpac ::= |

wgpac_box ::= |

wgpac_named ::= |

`compile_wgpac(wgpac, ``Rate`: number).

compiles a wgpac into a biochemical system.

`compile_wgpac({wgpac`_{1}, ...,
wgpac_{n}}, `Rate`).

compiles a set of wgpac.

`biocham: `

`biocham: `

`biocham: `

`biocham: `

`debug_iswgpac(``W`).

`debug_iswgpacbox(``B`).

transfer_polynomial ::= |
| `s` |

transfer_function ::= |

`enable_plus_minus_mode.`

Each variable corresponds to two species: one for the negative part and one for the positive part.

`disable_plus_minus_mode.`

Each variable corresponds to one species.

`which_plus_minus_mode.`

Displays which mode is being used.

`set_plus_minus_rate(``Rate`: number).

Set the annihilation rate between two complementary species.

`set_kinetics_rate(``Rate`: number).

Set the final summator rate

`biocham: `

`biocham: `

`biocham: `

`biocham: `

`biocham: `

`add_reaction(reaction).`

adds reaction rules to the current set of reactions.
This command is implicit: reaction rules can be added directly in
reaction models.

`list_reactions.`

lists the current set of reaction rules.

`s.`

`add_influence(influence).`

adds influence rules to the current set of influences.
This command is implicit: influence rules can be added directly in
influence models.

`list_influences.`

lists the current set of influence rules.
If the current model is a reaction model,
the influence rules are inferred from the reaction model
(see

`influence_model/0`

).
`influence_model.`

creates a new influence model by inferring
the influences between all molecular objects of the current reaction model

`list_stable_states.`

lists stable steady states of the state transition graph corresponding
to the positive semantics of the current influence model.

`list_tscc_candidates.`

lists possible representative states of Terminal Strongly Connected
Components (TSCC) of the state transition graph corresponding to the
positive semantics of the current influence model.

`add_event(condition, parameter`_{1} = arithmetic_expression_{1},
...,
parameter_{n} =
arithmetic_expression_{n}).

sets up an event that will be fired each time the condition given as first
argument goes from false to true.
This command is effective in numerical simulations only.
Upon firing, the parameters receive new values
computed from the expression.
The initial values of the parameters are restored after the simulation.

`biocham: `

`biocham: `

`biocham: `

`biocham: `

`biocham: `

`biocham: `

`list_events.`

lists all the declared events.

`list_molecules.`

lists all the molecules of the current model.

`list_locations.`

lists all the locations of the current model.

`list_initial_state.`

lists the objects which are present (including their initial concentration)
and absent from the initial state.

`clear_initial_state.`

makes undefined all objects possibly present or absent in the initial
state.

`present({object`_{1}, ...,
object_{n}}).

`present({object`_{1}, ...,
object_{n}}, concentration).

Every object in

`[object`_{1}, ...,
object_{n}]

is initialized
with the given initial concentration.
An initial value equal to 0 means absent.
`absent({object`_{1}, ...,
object_{n}}).

`undefined({object`_{1}, ...,
object_{n}}).

Every object in

`[object`_{1}, ...,
object_{n}]

is made possibly present or absent
in the initial state.
`make_present_not_absent.`

makes all objects (appearing in the instances of the current set of rules)
which are not declared absent, present in the initial state.

`make_absent_not_present.`

makes all objects (appearing in the instances of the current set of rules)
which are not declared present, absent in the initial state.

`set_parameter(parameter`_{1} = arithmetic_expression_{1},
...,
parameter_{n} =
arithmetic_expression_{n}).

sets the value of parameters.

`show_parameter(parameter).`

shows the value of

`parameter`

.
`list_parameters.`

shows the values of all known parameters.

`delete_parameter({parameter`_{1}, ...,
parameter_{n}}).

deletes some parameters

`function(function_prototype`_{1} = term_{1},
...,
function_prototype_{n} =
term_{n}).

sets the value of functions.

`show_function(``Functor`: name).

shows the expression associated to the given function.

`list_functions.`

lists all known functions.

`delete_function({name`_{1}, ...,
name_{n}}).

deletes some functions.

`alias(object`_{1} = ... =
object_{n}).

makes

`Objects`

be alternative names for the
same object.
`canonical(object).`

makes

`object`

be the canonical representant
for all its aliases.
`list_aliases.`

shows the values of all known aliases.

`delete_alias(object).`

makes

`object`

distinct from all other objects.
method ::= |
| `rk2` | `rk4` | `rkf45` | `rkck` | `rk8pd` | `rk1imp` | `rk2imp` | `rk4imp` | `bsimp` | `msadams` | `msbdf` |

time ::= |

`numerical_simulation(time).`

performs a numerical simulation up to a given time.

`method`: method- method for the numerical solver
`error_epsilon_absolute`: number- absolute error for the numerical solver
`error_epsilon_relative`: number- relative error for the numerical solver
`initial_step_size`: number- initial step size for the numerical solver
`maximum_step_size`: number- maximum step size for the numerical solver, as a fraction of time
`precision`: number- precision for the numerical solver

`load_table(input_file).`

loads the given

`.csv`

file as a table.
`export_table(output_file).`

exports the current table into a

`.csv`

file.
`list_tables.`

lists the current set of tables.

`select_table(table).`

selects

`table`

to be the current table.
`rename_table(name).`

renames the current table.

`delete_table({table`_{1}, ...,
table_{n}}).

deletes some tables.

`list_rows.`

lists the rows of the current table.

`list_columns.`

lists the column names of the current table.

column ::= |

`delete_column(column`_{1},
...,
column_{n}).

deletes the given columns from the current table.

`rename_column(column, name).`

renames the given column of the current table.

`delete_row(number`_{1},
...,
number_{n}).

deletes the given rows from the current table.

`plot.`

plots the current trace.

`biocham: `

`biocham: `

`biocham: `

`export_plot(``FileTemplate`).

saves the current trace into two files:

`FileTemplate`

`.csv`

and `.plot`

.
`export_plot_to_png(output_file).`

plots the current trace in a PNG file

`export_plot_to_canvas(output_file, ``BaseOutputFile`: output_file).

plots the current trace as a canvas element in an HTML file

`reaction_graph.`

Builds the reaction graph of the current model.

`import_reactions_from_graph.`

Updates the set of reactions of the current model with the current graph.

`draw_reactions.`

Draws the reaction graph of the current model.
Equivalent to

`reaction_graph. draw_graph.`

`biocham: `

`biocham: `

`influence_graph.`

builds the influence graph of the current model.

`draw_influences.`

Draws the influence graph of the current model.

`biocham: `

`biocham: `

attribute ::= |

edge ::= |

edgeref ::= |

`new_graph.`

Creates a new graph.

`delete_graph(name).`

Deletes a graph.

`set_graph_name(name).`

Sets the name of the current graph.

`list_graphs.`

Lists the graph of the current model.

`select_graph(name).`

Selects a graph

`add_vertex(name`_{1},
...,
name_{n}).

Adds new vertices to the current graph.

`delete_vertex(name`_{1},
...,
name_{n}).

Deletes a set of vertices from the current graph.

`add_edge(edge`_{1},
...,
edge_{n}).

Adds the given set of edges to the current graph.
The vertices are added if needed.

`delete_edge(edgeref`_{1},
...,
edgeref_{n}).

Deletes a set of edges from the current graph.

`list_edges.`

Lists the edges of the current graph.

`list_isolated_vertices.`

Lists the isolated vertices of the current graph.

`list_graph_objects.`

Lists the edges and the isolated vertices of the current graph,
and their attributes if any.

graph_object ::= |

`set_attribute({graph_object`_{1}, ...,
graph_object_{n}}, attribute).

Adds an attribute to every vertex or edge in the given set.
The vertices and the edges are added if needed.

`place(name`_{1},
...,
name_{n}).

`transition(name`_{1},
...,
name_{n}).

`delete_attribute(graph_object, ``Attribute`: name).

Removes an attribute from

`graph_object`

.
`list_attributes(graph_object).`

List the attributes of

`graph_object`

.
`draw_graph.`

Draws the current graph.

`export_graph(output_file).`

Exports the current graph in a file.
The format is chosen from the suffix:

`.dot`

, texttt{.pdf}, texttt{.eps}, texttt{.ps},
texttt{.png} or texttt{.svg}
– assuming no extension is `.dot`

.
`add_conservation(``Conservation`: solution).

declares a new mass conservation law for all molecules given with the
corresponding weight in

`Conservation`

. During a numerical
simulation, one of those variables will be
eliminated thanks to this conservation law. Be careful if you declare
conservation laws and then plot the result of a previous simulation, the
caption might not be correct.
When added, the conservation law will be checked against the reactions
(i.e. purely from stoichiometry), if that fails against the kinetics.
Since these checks are not complete, even a failure will be accepted with
a warning.
`delete_conservation(``Conservation`: solution).

removes the given mass conservation law.

`delete_conservations.`

removes all mass conservation laws.

`list_conservations.`

prints out all the mass conservation laws.

`check_conservations.`

checks all conservation laws against reactions, and if necessary kinetics
(see also

`add_conservation/1`

).
`search_conservations.`

calls

`search_conservations/1`

with the default size of 4.
`search_conservations(integer).`

computes and displays the P-invariants of the system up to the maximal
size

`integer`

. Such P-invariants are particular mass
conservation laws that are independent from the kinetics.
`export_nusmv(output_file).`

exports the current Biocham set of reactions and initial state in an SMV

`.smv`

file.
`boolean_semantics`: boolean_semantics- Use positive or negative boolean semantics for inhibitors.

boolean_semantics ::= |
| `positive` | `negative` |

nusmv_counter_example ::= |
| `yes` | `no` |

nusmv_initial_states ::= |
| `some` | `all` |

`check_ctl(``Query`: ctl).

evaluates the

`Query`

on the current model by calling the
NuSMV model-checker.
As is usual in Model-Checking, the query is evaluated for all possible
initial states (`Ai`

in Biocham v3). This can be changed via
the `nusmv_initial_states`

option.
`nusmv_initial_states`: nusmv_initial_states- Consider that a query is true if verified for all/some initial states.
`nusmv_counter_example`: nusmv_counter_example- Compute a counter-example for a query when possible.
`boolean_semantics`: boolean_semantics- Use positive or negative boolean semantics for inhibitors.

`biocham: `

`biocham: `

`biocham: `

`biocham: `

`biocham: `

EX(not a\/EG(not b)) is true

`biocham: `

Trace: a b TRUE FALSE EG(not b) is false

`biocham: `

reachable(b) is true

`check_ctl.`

Checks the current CTL specification (i.e., the conjunction of all
formulae of the current specification).

`revise_model(``Query`: ctl).

Use theory-revision on the current model to satisfy the query given as
argument. cf.

`CCFS05tcsb`

.
`revise_model.`

Use theory-revision as above, using the currently defined CTL
specification.

Index

- about/0 1.1.
- absent/1 5.3.2.
- add/1 5.1.1.
- add_biocham/1 5.1.1.
- add_conservation/1 5.7.1.
- add_ctl/1 4.1.
- add_edge/* 5.6.
- add_event/* 5.2.3.
- add_function/* 5.1.3.
- add_influence/1 5.2.2.
- add_ode/* 5.1.3.
- add_ode_system/1 5.1.3.
- add_qual/1 5.1.2.
- add_reaction/1 5.2.1.
- add_sbml/1 5.1.2.
- add_vertex/* 5.6.
- alias/1 5.4.3.

- canonical/1 5.4.3.
- check_conservations/0 5.7.1.
- check_ctl/0 5.8.1.
- check_ctl/1 5.8.1.
- clear_initial_state/0 5.3.2.
- clear_model/0 5.1.1.
- compile_wgpac/2 5.1.4.5.1.4.

- debug_iswgpac/1 5.1.4.
- debug_iswgpacbox/1 5.1.4.
- delete/* 5.1.1.
- delete_alias/1 5.4.3.
- delete_attribute/2 5.6.
- delete_column/* 5.5.2.
- delete_conservation/1 5.7.1.
- delete_conservations/0 5.7.1.
- delete_ctl/0 4.1.
- delete_ctl/1 4.1.
- delete_edge/* 5.6.
- delete_function/1 5.4.2.
- delete_graph/1 5.6.
- delete_ode/* 5.1.3.
- delete_ode_system/1 5.1.3.
- delete_parameter/1 5.4.1.
- delete_row/* 5.5.2.
- delete_table/1 5.5.2.
- delete_vertex/* 5.6.
- disable_plus_minus_mode/0 5.1.5.
- draw_graph/0 5.6.
- draw_influences/0 5.6.
- draw_reactions/0 5.6.

- enable_plus_minus_mode/0 5.1.5.
- export_biocham/1 5.1.1.
- export_graph/1 5.6.
- export_nusmv/1 5.8.1.
- export_ode_system/1 5.1.3.
- export_plot/1 5.5.3.
- export_plot_to_canvas/2 5.5.3.
- export_plot_to_png/1 5.5.3.
- export_table/1 5.5.2.

- function/* 5.4.2.

- import_ode/1 5.1.3.
- import_reactions_from_graph/0 5.6.
- import_reactions_from_ode_system/0 5.1.3.
- influence_graph/0 5.6.
- influence_model/0 5.2.2.
- inherits/* 5.1.1.
- init/1 5.1.3.

- list_aliases/0 5.4.3.
- list_attributes/1 5.6.
- list_columns/0 5.5.2.
- list_conservations/0 5.7.1.
- list_ctl/0 4.1.
- list_current_models/0 5.1.1.
- list_edges/0 5.6.
- list_events/0 5.2.3.
- list_functions/0 5.4.2.
- list_graph_objects/0 5.6.
- list_graphs/0 5.6.
- list_influences/0 5.2.2.
- list_initial_state/0 5.3.2.
- list_isolated_vertices/0 5.6.
- list_locations/0 5.3.1.
- list_model/0 5.1.1.
- list_models/0 5.1.1.
- list_molecules/0 5.3.1.
- list_ode/0 5.1.3.
- list_ode_systems/0 5.1.3.
- list_options/0 5.
- list_parameters/0 5.4.1.
- list_reactions/0 5.2.1.
- list_rows/0 5.5.2.
- list_stable_states/0 5.2.2.
- list_tables/0 5.5.2.
- list_tscc_candidates/0 5.2.2.
- load/1 5.1.1.
- load_biocham/1 5.1.1.
- load_ode_system/1 5.1.3.
- load_qual/1 5.1.2.
- load_sbml/1 5.1.2.
- load_table/1 5.5.2.

- ode_system/0 5.1.3.

- quit/0 5.

- reaction_graph/0 5.6.
- rename_column/2 5.5.2.
- rename_table/1 5.5.2.
- revise_model/0 5.8.2.
- revise_model/1 5.8.2.

- s/0 5.2.2.
- search_conservations/0 5.7.1.
- search_conservations/1 5.7.1.
- select_graph/1 5.6.
- select_model/1 5.1.1.
- select_ode_system/1 5.1.3.
- select_table/1 5.5.2.
- set_attribute/2 5.6.
- set_graph_name/1 5.6.
- set_kinetics_rate/1 5.1.5.
- set_model_name/1 5.1.1.
- set_ode_system_name/1 5.1.3.
- set_parameter/* 5.4.1.
- set_plus_minus_rate/1 5.1.5.
- show_function/1 5.4.2.
- show_parameter/1 5.4.1.

- transition/* 5.6.

- undefined/1 5.3.2.

- validity_domain/1 4.2.

- which_plus_minus_mode/0 5.1.5.

Bibliography