This is Visualize.info, produced by Macaulay2, version 1.25.11

Visualize -- A package to help visualize algebraic objects in the browser using javascript
******************************************************************************************

Description
===========

Using JavaScript, this package creates interactive visualizations of a variety
of objects in a modern browser. While viewing the object, the user has the
ability to manipulate and run various tests. Once finished, the user can export
the finished result back to the Macaulay2 session.

Javascript Packages Used
========================

Built on the shoulders of giants, this package utilizes a variety of existing
open-source javascript packages.
  * BootSideMenu.js (see https://github.com/AndreaLombardo/BootSideMenu )
  * Bootstrap.js (see http://getbootstrap.com/ )
  * clipboard.js (see https://clipboardjs.com/ )
  * D3.js (see https://d3js.org/ )
  * jQuery (see https://jquery.com/ )
  * noUiSlider.js (see http://refreshless.com/nouislider/ )
  * Three.js (see https://github.com/mrdoob/three.js/ )

Contributors
============

The following people have generously contributed code or worked on our code at
various Macaulay2 workshops.
  * Ata Firat Pir
  * Elliot Korte
  * Will Smith
  * Julio Urenda
In particular we are thankful to Dan Grayson and Mike Stillman for their help
in creating communication between Macaulay2 and the browser.

Interactive Examples
====================

The following links are interactive examples without the communication between
Macaulay2 and the browser. The editing, manipulation, and TikZ should work.
Depending on the browser, some features may require you to open the links in a
new tab.
  * Visualize Graphs example (see
    common/share/Macaulay2/Visualize/graph-example.html )
  * Visualize Digraphs example (see
    common/share/Macaulay2/Visualize/digraph-example.html )
  * Visualize Posets example (see
    common/share/Macaulay2/Visualize/poset-example.html )
  * Visualize Simplicial Complexes example (see
    common/share/Macaulay2/Visualize/simplicial-complex-example.html )
  * Visualize Ideals in 2 variables example (see
    common/share/Macaulay2/Visualize/ideal2d-example.html )
  * Visualize Ideals in 3 variables example (see
    common/share/Macaulay2/Visualize/ideal3d-example.html )

Methods and Workflow
====================

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Authors
=======

  * Brett Barwick (see http://faculty.uscupstate.edu/bbarwick/ )
    <bbarwick@uscupstate.edu>
  * Thomas Enkosky (see http://math.bu.edu/people/tomenk/ ) <tomenk@bu.edu>
  * Branden Stone (see http://math.adelpi.edu/~bstone/ ) <bstone@adelphi.edu>
  * Jim Vallandingham (see http://vallandingham.me/ ) <vlandham@gmail.com>
  * Doug Torrance (see https://webwork.piedmont.edu/~dtorrance )
    <dtorrance@piedmont.edu>

Version
=======

This documentation describes version 1.8 of Visualize, released October 27,
2025.

Citation
========

If you have used this package in your research, please cite it as follows:

+-----------------------------------------------------------------------------+
|@misc{VisualizeSource,                                                       |
|  title = {{Visualize: interactive visualization and manipulation            |
|  author = {Brett Barwick and Thomas Enkosky and Branden Stone and           |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/           |
|}                                                                            |
|-----------------------------------------------------------------------------|
|of combinatorial objects in a browser. Version~1.8}},                        |
| Jim Vallandingham and Doug Torrance},                                       |
|                                                                             |
|packages}}                                                                   |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * closePort -- closes and open port
      * openPort -- opens a port
      * visualize -- creates an interactive object in a
        modern browser
  * Methods
      * "openPort(String)" -- see openPort, -- opens a port
      * visualize(Digraph) -- visualizes a
        digraph in the browser
      * visualize(Graph) -- visualizes a graph in
        a modern browser
      * visualize(Ideal) -- visualizes an ideal in
        the browser
      * visualize(Poset) -- visualizes a poset in
        the browser
      * visualize(SimplicialComplex),
        -- visualizes a simplicial complex in the browser
  * Symbols
      * FixExtremeElements -- an option to fix
        extreme elements of a poset
      * VisPath -- an option to define a path to save
        visualizations
      * VisTemplate -- an option defining the template path
      * Warning -- an option to squelch warnings

For the programmer
==================

The object Visualize, is a package (Macaulay2Doc),
defined in Visualize.m2, with auxiliary files in Visualize/.

-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1108:0.

Basic Workflow for Visualize
****************************

The basic workflow this package requires the user to open a port for
communication between Macaulay2 and the web browser. Once the port is open, the
visualize, method can be used freely. In particular, the
workflow is as follows:

  * 1. Load or install the package.
  * 2. Open a port with openPort, method for communication with
    the browser. It is up to the user to choose port and also to close the port
    when finished.
  * 3. Define an object you wish to visualize. For example, a graph, poset,
    digraph, etc.
  * 4. Run the visualize, method. This will open the browser
    with an interactive interface. This session is in communication with
    Macaulay2 through the open port above. At this point you can edit and
    manipulate the created object.
  * 5. End the session and export work back to Macaulay2.
  * 6. Continue manipulating the object and repeat steps 3-5 as necessary.
  * 7. When finished, close the port with closePort, or
    restart Macaulay2.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1142:0.

closePort -- closes and open port
*********************************

Description
===========

When a port is opened with the openPort, method, closePort() is
used to close the port. If the user forgets to close the port, closing or
restarting Macaulay2 will automatically close the port.

+----------------------------------------------------------+
|i1 : closePort()                                          |
|--Port null is now closing. This could take a few seconds.|
+----------------------------------------------------------+

Caveat
======

This method does not have an input. In order for it to run, you must write the
'()' at the end as follows: closePort().

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Ways to use closePort:
======================

  * closePort() (missing documentation)

For the programmer
==================

The object closePort, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:2205:0.

FixExtremeElements -- an option to fix extreme elements of a poset
******************************************************************

Description
===========

When using this option, the visualized poset will be drawn such that the
extreme elements are placed at the top and bottom of the drawing.

See also
========

  * Basic Workflow for Visualize
  * visualize(Poset) -- visualizes a poset in the
    browser

Functions with optional argument named FixExtremeElements:
==========================================================

  * "visualize(Poset,FixExtremeElements=>...)"

For the programmer
==================

The object FixExtremeElements, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1750:0.

openPort -- opens a port
************************

  * Usage:
        openPort N
  * Inputs:
      * N, a string (Macaulay2Doc), a port number

Description
===========

In order to use the visualize, method, the user must first
open a port on their machine. This can be dangerous as someone could
potentially be listening on that port. The port being open is only accessible
to the localhost and is most vulnerable if the package is being run on a
server. If running on a personal computer/laptop, then the risk of cyber attack
is very small as the attacker would have to have access to your local machine.
Because of this risk, and the fact that the examples will throw errors if the
user is using the example port, the documentation will not actually run
examples of openPort.

The user can use any port number they wish. Common ports are '8080' and '8081'.
For example, openPort"8080" will open port '8080' for communication.

Once a port is open, another instance of openPort, will not be
allowed to open another port. Hence the user can only open one port at a time
with this method. Once finished visualizing, you can close the port with the
closePort, method.

+----------------------------------------------------------+
|i1 : closePort()                                          |
|--Port null is now closing. This could take a few seconds.|
+----------------------------------------------------------+

Restarting Macaulay2 will also close the port.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Ways to use openPort:
=====================

  * "openPort(String)"

For the programmer
==================

The object openPort, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:2177:0.

VisPath -- an option to define a path to save visualizations
************************************************************

Description
===========

The default nature of the Visualize package is to open the visualization in a
temporary file. Use the VisPath option if you wish to save the visualization to
a given directory. If the process will overwrite files, a warning appears
asking the user if they would like to proceed. You can squelch this warning
with the Warning, option.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisPath:
===============================================

  * visualize(Digraph,VisPath=>...)
    -- an option to define a path
    to save visualizations of Digraphs
  * visualize(Graph,VisPath=>...)
    -- an option to define a path to
    save visualizations of Graphs
  * visualize(Ideal,VisPath=>...)
    -- an option to define a path to
    save visualizations of Ideals
  * visualize(Poset,VisPath=>...)
    -- an option to define a path to
    save visualizations of Posets
  * visualize(SimplicialComplex,VisPath=>...)
    -- an option to
    define a path to save visualizations of simplicial complexes

For the programmer
==================

The object VisPath, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1700:0.

VisTemplate -- an option defining the template path
***************************************************

Description
===========

This option is used internally to pass paths from one method to another. A
savvy user would be able to use this option to create a personal template and
pass the path for Visualize.m2 to use.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisTemplate:
===================================================

  * visualize(Digraph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Graph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Ideal,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Poset,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(SimplicialComplex,VisTemplate=>...)
    -- an option
    defining the template path

For the programmer
==================

The object VisTemplate, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1718:0.

visualize -- creates an interactive object in a modern browser
**************************************************************

Description
===========

Given an open port, this method will create an interactive visualization of a
variety of objects in a modern browser. While viewing the object, the user has
the ability to manipulate the object, and run various tests. Once finished, the
user can export the finished result back to the Macaulay2 session.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Ways to use visualize:
======================

  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser

For the programmer
==================

The object visualize, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1235:0.

visualize(Digraph) -- visualizes a digraph in the browser
*********************************************************

  * Function: visualize,

Description
===========

Using JavaScript, this method creates an interactive visualization of a digraph
in a modern browser. While viewing the digraph, the user has the ability to
manipulate and run various tests. Once finished, the user can export the
finished result back to the Macaulay2 session.

The workflow for this package is as follows. Once we have loaded the package,
we first open a port with openPort, for Macaulay2 to
communicate with the browser. Once a port is established, define an object to
visualize. In this example we could use the command openPort"8080" before or
after we define the following digraph.

+-----------------------------------------------------------------------------+
|i1 : D = digraph {{1,{2,3}}, {2,{4,5}}, {3,{5,6}}, {4,{7}},                  |
|                                                                             |
|o1 = Digraph{1 => {2, 3}}                                                    |
|             2 => {4, 5}                                                     |
|             3 => {5, 6}                                                     |
|             4 => {7}                                                        |
|             5 => {7}                                                        |
|             6 => {7}                                                        |
|             7 => {}                                                         |
|                                                                             |
|o1 : Digraph                                                                 |
|-----------------------------------------------------------------------------|
|{5,{7}},{6,{7}},{7,{}}}                                                      |
+-----------------------------------------------------------------------------+

At this point we wish to visualize D. To do this simply execute H = visualize D
and browser will open with interactive image. You can view this image in the
link below.

Visualize Digraphs example (see
common/share/Macaulay2/Visualize/digraph-example.html )

Once finished with a session, you can keep visualizing. For example if you were
to say H = visualize D, once you ended the session, the last digraph on the
screen would be assigned to H. After running various computations on this
digraph, you can then visualize it once more with the visualize,
method. You can keep using this method until the port is closed with
closePort, or Macaulay2 is restarted.

Browser Menu Options
====================

On the side of the browser will be several options to interact with the digraph
using the Graphs, package. Below is a brief overview of the
options.

  * Force Variables: The 'charge' slider will force the vertices to repel or
    attract each other while the 'links' slider increases and decreases the
    length of the edges.

  * Enable Editing: In the browser, you can edit the digraph (add/delete
    vertices or edges) by clicking Enable Editing.  For example, in order to
    remove the edges {0,1} and {1,3} click on 'Enable Editing' and select the
    edges and press delete on the keyboard. You may also add vertices and edges
    with the mouse/trackpad. When editing is enabled, you can move the vertices
    around by holding down the shift key. Further, to create a loop, select a
    node and press the 'r' key. When an edge is selected, you may press the
    'l', 'r', and 'b' keys to change the edge to a left-, right-, or two-sided
    edge, respectively.

  * Hide Labels: Removes the labels from the vertices.

  * Highlight Neighbors: Allows you to see the neighbors of a vertex when
    selected.

  * Reset Nodes: When you move a vertex, it will pin it to the canvas. If you
    have pinned a node to the canvas, you can undo this process by resetting
    the nodes. Clicking this will reset all nodes.

  * Turn off force: The force is what creates the charges on the nodes. Turning
    this off will make the vertices not repel each other.

  * Generate TikZ code: Clicking this will generate the TikZ code for a black
    and white version of the digraph that is being viewed. You will then have
    to copy this to the clipboard by clicking a new button. The TeX file will
    only need '\usepackage{tikz}' in the preamble. If you decide you want to
    modify the digraph, feel free. All you need do in order to get a new TikZ
    code is click on 'Generate TikZ code' once more, and then click the button.
    This button will look the same, but it will be a new code.

  * Boolean tests: Clicking this will pull up a submenu of boolean tests
    supported by the Graphs, package. Clicking on these
    tests will send a request to Macaulay2 to calculate the answer for the
    current digraph on the screen. Warning: If your digraph is too large,
    clicking a menu item could take a very long time. In order to cancel the
    process you need to kill the session of Macaulay2 with 'Ctrl+c+c' in the
    instance of Macaulay2.

  * Numerical invariants: Clicking this will pull up a submenu of numerical
    invariants supported by the Graphs, package. Clicking on
    these will send a request to Macaulay2 to calculate the answer for the
    current digraph on the screen. Warning: If your digraph is too large,
    clicking a menu item could take a very long time. In order to cancel the
    process you need to kill the session of Macaulay2 with 'Ctrl+c+c' in the
    instance of Macaulay2.

  * End session: When you are finished editing, you can end the session and
    send the current digraph to Macaulay2. The output of visualize D is the
    digraph on the screen when end session is clicked.

Caveat
======

When the digraph is exported back to Macaulay2 after ending the visualization
session, all vertices are represented as strings.  To recover the values of
these labels (for example, if they have numeric values or represent ring
variables), use the command value first toString G.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Ways to use this method:
========================

  * visualize(Digraph) -- visualizes a digraph
    in the browser
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1480:0.

visualize(Digraph,Verbose=>...) -- an to view communication between Macaulay2 server and browser
*************************************************************************************************

  * Usage:
        H = visualize (D, Verbose => true)
  * Inputs:
      * D, a digraph (Graphs), a digraph

Description
===========

When this option is used, the user can view the communication between the
Macaulay2 server and the browser. The communication will be displayed in the
instance of Macaulay2.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named Verbose:
===============================================

  * "check(...,Verbose=>...)" -- see check (Macaulay2Doc), --
    perform tests of a package
  * "checkDegrees(...,Verbose=>...)" -- see checkDegrees (Isomorphism),
    -- compares the degrees of generators of two
    modules
  * "copyDirectory(...,Verbose=>...)" -- see
    copyDirectory(String,String) (Macaulay2Doc),
  * "copyFile(...,Verbose=>...)" -- see copyFile(String,String) (Macaulay2Doc),
  * "findProgram(...,Verbose=>...)" -- see findProgram (Macaulay2Doc),
    -- load external program
  * "installPackage(...,Verbose=>...)" -- see installPackage (Macaulay2Doc),
    -- load and install a package and its
    documentation
  * "isIsomorphic(...,Verbose=>...)" -- see isIsomorphic (Isomorphism),
    -- probabilistic test for isomorphism of modules
  * "isomorphism(...,Verbose=>...)" -- see isomorphism (Isomorphism),
    -- retrieve an isomorphism of modules
  * "moveFile(...,Verbose=>...)" -- see moveFile(String,String) (Macaulay2Doc),
  * "runProgram(...,Verbose=>...)" -- see runProgram (Macaulay2Doc),
    -- run an external program
  * "symlinkDirectory(...,Verbose=>...)" -- see
    symlinkDirectory(String,String) (Macaulay2Doc),
    -- make symbolic links
    for all files in a directory tree
  * visualize(Digraph,Verbose=>...)
    -- an to view communication
    between Macaulay2 server and browser
  * visualize(Graph,Verbose=>...)
    -- an to view communication
    between Macaulay2 server and browser
  * visualize(Ideal,Verbose=>...) (missing documentation)
  * visualize(Poset,Verbose=>...)
    -- an to view communication
    between Macaulay2 server and browser
  * visualize(SimplicialComplex,Verbose=>...) (missing documentation)

Further information
===================

  * Default value: false (Macaulay2Doc),
  * Method: visualize(Digraph), -- visualizes a
    digraph in the browser
  * Option key: Verbose (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:2113:0.

visualize(Digraph,VisPath=>...) -- an option to define a path to save visualizations of Digraphs
************************************************************************************************

  * Usage:
        H = visualize (D, VisPath => "/PATH/TO/DIRECTORY/")
  * Inputs:
      * D, a digraph (Graphs), a Digraph

Description
===========

The default nature of the Visualize package is to open the visualization in a
temporary file. Use the VisPath option if you wish to save the visualization to
a given directory. If the process will overwrite files, a warning appears
asking the user if they would like to proceed. You can squelch this warning
with the Warning, option.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisPath:
===============================================

  * visualize(Digraph,VisPath=>...)
    -- an option to define a path
    to save visualizations of Digraphs
  * visualize(Graph,VisPath=>...)
    -- an option to define a path to
    save visualizations of Graphs
  * visualize(Ideal,VisPath=>...)
    -- an option to define a path to
    save visualizations of Ideals
  * visualize(Poset,VisPath=>...)
    -- an option to define a path to
    save visualizations of Posets
  * visualize(SimplicialComplex,VisPath=>...)
    -- an option to
    define a path to save visualizations of simplicial complexes

Further information
===================

  * Default value: null
  * Method: visualize(Digraph), -- visualizes a
    digraph in the browser
  * Option key: VisPath, -- an option to define a path to save
    visualizations
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1771:0.

visualize(Digraph,VisTemplate=>...) -- an option defining the template path
***************************************************************************

  * Usage:
        H = visualize (D, VisPath => "/PATH/TO/TEMPLATE/")
  * Inputs:
      * D, a digraph (Graphs), a digraph

Description
===========

This option is used internally to pass paths from one method to another. A
savvy user would be able to use this option to create a personal template and
pass the path for Visualize.m2 to use.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisTemplate:
===================================================

  * visualize(Digraph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Graph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Ideal,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Poset,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(SimplicialComplex,VisTemplate=>...)
    -- an option
    defining the template path

Further information
===================

  * Default value: /home/macaulay/rpmbuild/BUILD/Macaulay2-1.25.11/M2/Macaulay2
    /packages/Visualize/templates/visDigraph/visDigraph-template.html
  * Method: visualize(Digraph), -- visualizes a
    digraph in the browser
  * Option key: VisTemplate, -- an option defining the
    template path
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1879:0.

visualize(Digraph,Warning=>...) -- an option to squelch warnings
****************************************************************

  * Usage:
        H = visualize (D, VisPath => "/PATH/TO/DIRECTORY/", Warning => false)
  * Inputs:
      * D, a digraph (Graphs), a digraph

Description
===========

When using the option VisPath, a warning is produced if files
will be overwritten. Warning is used to squelch these warnings. The default
value is true, meaning the warning will be displayed.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named Warning:
===============================================

  * visualize(Digraph,Warning=>...)
    -- an option to squelch
    warnings
  * visualize(Graph,Warning=>...)
    -- an option to squelch warnings
  * visualize(Ideal,Warning=>...)
    -- an option to squelch warnings
  * visualize(Poset,Warning=>...)
    -- an option to squelch warnings
  * visualize(SimplicialComplex,Warning=>...)
    -- an option to
    squelch warnings

Further information
===================

  * Default value: true (Macaulay2Doc),
  * Method: visualize(Digraph), -- visualizes a
    digraph in the browser
  * Option key: Warning, -- an option to squelch warnings
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1983:0.

visualize(Graph) -- visualizes a graph in a modern browser
**********************************************************

  * Function: visualize,
  * Usage:
        H = visualize G
  * Inputs:
      * G, a graph (Graphs),  a graph
  * Optional inputs (Macaulay2Doc),:
      * Verbose, => ...,
        default value false, an to view communication between Macaulay2 server
        and browser
      * VisPath, => ...,
        default value null, an option to define a path to save visualizations
        of Graphs
      * VisTemplate, =>
        ..., default value "/usr/share/Macaulay2/Visualize/templates/visGraph/
        visGraph-template.html", an option defining the template path
      * Warning, => ...,
        default value true, an option to squelch warnings

Description
===========

Using JavaScript, this method creates an interactive visualization of a graph
in a modern browser. While viewing the graph, the user has the ability to
manipulate and run various tests. Once finished, the user can export the
finished result back to the Macaulay2 session.

The workflow for this package is as follows. Once we have loaded the package,
we first open a port with openPort, for Macaulay2 to
communicate with the browser. Once a port is established, define an object to
visualize. In this example we could use the command openPort"8080" before or
after we define the following graph.

+-----------------------------------------------------------------+
|i1 : G = graph({{0,1},{0,3},{0,4},{1,3},{2,3}},Singletons => {5})|
|                                                                 |
|o1 = Graph{0 => {1, 3, 4}}                                       |
|           1 => {0, 3}                                           |
|           2 => {3}                                              |
|           3 => {0, 1, 2}                                        |
|           4 => {0}                                              |
|           5 => {}                                               |
|                                                                 |
|o1 : Graph                                                       |
+-----------------------------------------------------------------+

At this point we wish to visualize G. To do this simply execute H = visualize G
and browser will open with interactive image. You can view this image in the
link below.

Visualize Graphs example (see
common/share/Macaulay2/Visualize/graph-example.html )

Once finished with a session, you can keep visualizing. For example if you were
to say H = visualize G, once you ended the session, the last graph on the
screen would be assigned to H. After running various computations on this
graph, you can then visualize it once more with the visualize,
method. You can keep using this method until the port is closed with
closePort, or Macaulay2 is restarted.

Browser Menu Options
====================

On the side of the browser will be several options to interact with the graph
using the Graphs, package. Below is a brief overview of the
options.

  * Force Variables: The 'charge' slider will force the vertices to repel or
    attract each other while the 'links' slider increases and decreases the
    length of the edges.

  * Enable Editing: In the browser, you can edit the graph (add/delete vertices
    or edges) by clicking Enable Editing.  For example, in order to remove the
    edges {0,1} and {1,3} click on 'Enable Editing' and select the edges and
    press delete on the keyboard. You may also add vertices and edges with the
    mouse/trackpad. When editing is enabled, you can move the vertices around
    by holding down the shift key.

  * Hide Labels: Removes the labels from the vertices.

  * Highlight Neighbors: Allows you to see the neighbors of a vertex when
    selected.

  * Reset Nodes: When you move a vertex, it will pin it to the canvas. If you
    have pinned a node to the canvas, you can undo this process by resetting
    the nodes. Clicking this will reset all nodes.

  * Turn off force: The force is what creates the charges on the nodes. Turning
    this off will make the vertices not repel each other.

  * Generate TikZ code: Clicking this will generate the TikZ code for a black
    and white version of the graph that is being viewed. You will then have to
    copy this to the clipboard by clicking a new button. The TeX file will only
    need '\usepackage{tikz}' in the preamble. If you decide you want to modify
    the graph, feel free. All you need do in order to get a new TikZ code is
    click on 'Generate TikZ code' once more, and then click the button. This
    button will look the same, but it will be a new code.

  * Boolean tests: Clicking this will pull up a submenu of boolean tests
    supported by the Graphs, package. Clicking on these
    tests will send a request to Macaulay2 to calculate the answer for the
    current graph on the screen. Warning: If your graph is too large, clicking
    a menu item could take a very long time. In order to cancel the process you
    need to kill the session of Macaulay2 with 'Ctrl+c+c' in the instance of
    Macaulay2.

  * Numerical invariants: Clicking this will pull up a submenu of numerical
    invariants supported by the Graphs, package. Clicking on
    these will send a request to Macaulay2 to calculate the answer for the
    current graph on the screen. Warning: If your graph is too large, clicking
    a menu item could take a very long time. In order to cancel the process you
    need to kill the session of Macaulay2 with 'Ctrl+c+c' in the instance of
    Macaulay2.

  * End session: When you are finished editing, you can end the session and
    send the current graph to Macaulay2. The output of visualize G is the graph
    on the screen when end session is clicked.

Caveat
======

When the graph is exported back to Macaulay2 after ending the visualization
session, all vertices are represented as strings.  To recover the values of
these labels (for example, if they have numeric values or represent ring
variables), use the command value first toString G.

See also
========

  * Basic Workflow for Visualize
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Ways to use this method:
========================

  * visualize(Graph) -- visualizes a graph in a
    modern browser
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1341:0.

visualize(Graph,Verbose=>...) -- an to view communication between Macaulay2 server and browser
***********************************************************************************************

  * Usage:
        H = visualize (G, Verbose => true)
  * Inputs:
      * G, a graph (Graphs), a graph

Description
===========

When this option is used, the user can view the communication between the
Macaulay2 server and the browser. The communication will be displayed in the
instance of Macaulay2.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named Verbose:
===============================================

  * "check(...,Verbose=>...)" -- see check (Macaulay2Doc), --
    perform tests of a package
  * "checkDegrees(...,Verbose=>...)" -- see checkDegrees (Isomorphism),
    -- compares the degrees of generators of two
    modules
  * "copyDirectory(...,Verbose=>...)" -- see
    copyDirectory(String,String) (Macaulay2Doc),
  * "copyFile(...,Verbose=>...)" -- see copyFile(String,String) (Macaulay2Doc),
  * "findProgram(...,Verbose=>...)" -- see findProgram (Macaulay2Doc),
    -- load external program
  * "installPackage(...,Verbose=>...)" -- see installPackage (Macaulay2Doc),
    -- load and install a package and its
    documentation
  * "isIsomorphic(...,Verbose=>...)" -- see isIsomorphic (Isomorphism),
    -- probabilistic test for isomorphism of modules
  * "isomorphism(...,Verbose=>...)" -- see isomorphism (Isomorphism),
    -- retrieve an isomorphism of modules
  * "moveFile(...,Verbose=>...)" -- see moveFile(String,String) (Macaulay2Doc),
  * "runProgram(...,Verbose=>...)" -- see runProgram (Macaulay2Doc),
    -- run an external program
  * "symlinkDirectory(...,Verbose=>...)" -- see
    symlinkDirectory(String,String) (Macaulay2Doc),
    -- make symbolic links
    for all files in a directory tree
  * visualize(Digraph,Verbose=>...)
    -- an to view communication
    between Macaulay2 server and browser
  * visualize(Graph,Verbose=>...)
    -- an to view communication
    between Macaulay2 server and browser
  * visualize(Ideal,Verbose=>...) (missing documentation)
  * visualize(Poset,Verbose=>...)
    -- an to view communication
    between Macaulay2 server and browser
  * visualize(SimplicialComplex,Verbose=>...) (missing documentation)

Further information
===================

  * Default value: false (Macaulay2Doc),
  * Method: visualize(Graph), -- visualizes a graph
    in a modern browser
  * Option key: Verbose (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:2092:0.

visualize(Graph,VisPath=>...) -- an option to define a path to save visualizations of Graphs
********************************************************************************************

  * Usage:
        H = visualize (G, VisPath => "/PATH/TO/DIRECTORY/")
  * Inputs:
      * G, a graph (Graphs), a graph

Description
===========

The default nature of the Visualize package is to open the visualization in a
temporary file. Use the VisPath option if you wish to save the visualization to
a given directory. If the process will overwrite files, a warning appears
asking the user if they would like to proceed. You can squelch this warning
with the Warning, option.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisPath:
===============================================

  * visualize(Digraph,VisPath=>...)
    -- an option to define a path
    to save visualizations of Digraphs
  * visualize(Graph,VisPath=>...)
    -- an option to define a path to
    save visualizations of Graphs
  * visualize(Ideal,VisPath=>...)
    -- an option to define a path to
    save visualizations of Ideals
  * visualize(Poset,VisPath=>...)
    -- an option to define a path to
    save visualizations of Posets
  * visualize(SimplicialComplex,VisPath=>...)
    -- an option to
    define a path to save visualizations of simplicial complexes

Further information
===================

  * Default value: null
  * Method: visualize(Graph), -- visualizes a graph
    in a modern browser
  * Option key: VisPath, -- an option to define a path to save
    visualizations
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1792:0.

visualize(Graph,VisTemplate=>...) -- an option defining the template path
*************************************************************************

  * Usage:
        H = visualize (G, VisPath => "/PATH/TO/TEMPLATE/")
  * Inputs:
      * G, a graph (Graphs), a graph

Description
===========

This option is used internally to pass paths from one method to another. A
savvy user would be able to use this option to create a personal template and
pass the path for Visualize.m2 to use.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisTemplate:
===================================================

  * visualize(Digraph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Graph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Ideal,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Poset,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(SimplicialComplex,VisTemplate=>...)
    -- an option
    defining the template path

Further information
===================

  * Default value: /home/macaulay/rpmbuild/BUILD/Macaulay2-1.25.11/M2/Macaulay2
    /packages/Visualize/templates/visGraph/visGraph-template.html
  * Method: visualize(Graph), -- visualizes a graph
    in a modern browser
  * Option key: VisTemplate, -- an option defining the
    template path
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1899:0.

visualize(Graph,Warning=>...) -- an option to squelch warnings
**************************************************************

  * Usage:
        H = visualize (G, VisPath => "/PATH/TO/DIRECTORY/", Warning => false)
  * Inputs:
      * G, a graph (Graphs), a graph

Description
===========

When using the option VisPath, a warning is produced if files
will be overwritten. Warning is used to squelch these warnings. The default
value is true, meaning the warning will be displayed.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named Warning:
===============================================

  * visualize(Digraph,Warning=>...)
    -- an option to squelch
    warnings
  * visualize(Graph,Warning=>...)
    -- an option to squelch warnings
  * visualize(Ideal,Warning=>...)
    -- an option to squelch warnings
  * visualize(Poset,Warning=>...)
    -- an option to squelch warnings
  * visualize(SimplicialComplex,Warning=>...)
    -- an option to
    squelch warnings

Further information
===================

  * Default value: true (Macaulay2Doc),
  * Method: visualize(Graph), -- visualizes a graph
    in a modern browser
  * Option key: Warning, -- an option to squelch warnings
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:2004:0.

visualize(Ideal) -- visualizes an ideal in the browser
******************************************************

  * Function: visualize,

Description
===========

Using JavaScript, this method creates an interactive visualization of an ideal,
in either 2 or 3 variables, in a modern browser. Unlike other Type (Macaulay2Doc),
s, when visualizing an ideal you do not need to open a port
as there is no communication between Macaulay2 and the browser. We hope to add
more functionality to this method in future versions. The ideal being
visualized is actually the ideal of leading terms.

+-------------------------+
|i1 : S = QQ[x,y]         |
|                         |
|o1 = S                   |
|                         |
|o1 : PolynomialRing      |
+-------------------------+
|i2 : I = ideal"x4,xy3,y5"|
|                         |
|             4     3   5 |
|o2 = ideal (x , x*y , y )|
|                         |
|o2 : Ideal of S          |
+-------------------------+

In order to visualize this, simply type visualize I and the following example
will appear in the browser.

Visualize ideal in 2 variables example (see
common/share/Macaulay2/Visualize/ideal2d-example.html )

+-------------------------------------------+
|i3 : R = QQ[x,y,z]                         |
|                                           |
|o3 = R                                     |
|                                           |
|o3 : PolynomialRing                        |
+-------------------------------------------+
|i4 : J = ideal"x4,xyz3,yz2,xz3,z6,y5"      |
|                                           |
|             4       3     2     3   6   5 |
|o4 = ideal (x , x*y*z , y*z , x*z , z , y )|
|                                           |
|o4 : Ideal of R                            |
+-------------------------------------------+

In order to visualize this, simply type visualize J and the following example
will appear in the browser.

Visualize ideal in 3 variables example (see
common/share/Macaulay2/Visualize/ideal3d-example.html )

Caveat
======

Visualizing ideals is still in development so please be gentle with it.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser

Ways to use this method:
========================

  * visualize(Ideal) -- visualizes an ideal in the
    browser
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1384:0.

visualize(Ideal,VisPath=>...) -- an option to define a path to save visualizations of Ideals
********************************************************************************************

  * Usage:
        H = visualize (I, VisPath => "/PATH/TO/DIRECTORY/")
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal

Description
===========

The default nature of the Visualize package is to open the visualization in a
temporary file. Use the VisPath option if you wish to save the visualization to
a given directory. If the process will overwrite files, a warning appears
asking the user if they would like to proceed. You can squelch this warning
with the Warning, option.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisPath:
===============================================

  * visualize(Digraph,VisPath=>...)
    -- an option to define a path
    to save visualizations of Digraphs
  * visualize(Graph,VisPath=>...)
    -- an option to define a path to
    save visualizations of Graphs
  * visualize(Ideal,VisPath=>...)
    -- an option to define a path to
    save visualizations of Ideals
  * visualize(Poset,VisPath=>...)
    -- an option to define a path to
    save visualizations of Posets
  * visualize(SimplicialComplex,VisPath=>...)
    -- an option to
    define a path to save visualizations of simplicial complexes

Further information
===================

  * Default value: null
  * Method: visualize(Ideal), -- visualizes an
    ideal in the browser
  * Option key: VisPath, -- an option to define a path to save
    visualizations
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1814:0.

visualize(Ideal,VisTemplate=>...) -- an option defining the template path
*************************************************************************

  * Usage:
        H = visualize (I, VisPath => "/PATH/TO/TEMPLATE/")
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal

Description
===========

This option is used internally to pass paths from one method to another. A
savvy user would be able to use this option to create a personal template and
pass the path for Visualize.m2 to use.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisTemplate:
===================================================

  * visualize(Digraph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Graph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Ideal,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Poset,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(SimplicialComplex,VisTemplate=>...)
    -- an option
    defining the template path

Further information
===================

  * Default value: /home/macaulay/rpmbuild/BUILD/Macaulay2-1.25.11/M2/Macaulay2
    /packages/Visualize/templates/visIdeal/visIdeal
  * Method: visualize(Ideal), -- visualizes an
    ideal in the browser
  * Option key: VisTemplate, -- an option defining the
    template path
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1920:0.

visualize(Ideal,Warning=>...) -- an option to squelch warnings
**************************************************************

  * Usage:
        H = visualize (I, VisPath => "/PATH/TO/DIRECTORY/", Warning => false)
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal

Description
===========

When using the option VisPath, a warning is produced if files
will be overwritten. Warning is used to squelch these warnings. The default
value is true, meaning the warning will be displayed.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named Warning:
===============================================

  * visualize(Digraph,Warning=>...)
    -- an option to squelch
    warnings
  * visualize(Graph,Warning=>...)
    -- an option to squelch warnings
  * visualize(Ideal,Warning=>...)
    -- an option to squelch warnings
  * visualize(Poset,Warning=>...)
    -- an option to squelch warnings
  * visualize(SimplicialComplex,Warning=>...)
    -- an option to
    squelch warnings

Further information
===================

  * Default value: true (Macaulay2Doc),
  * Method: visualize(Ideal), -- visualizes an
    ideal in the browser
  * Option key: Warning, -- an option to squelch warnings
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:2026:0.

visualize(Poset) -- visualizes a poset in the browser
*****************************************************

  * Function: visualize,

Description
===========

Using JavaScript, this method creates an interactive visualization of a poset
in a modern browser. While viewing the poset, the user has the ability to
manipulate and run various tests. Once finished, the user can export the
finished result back to the Macaulay2 session.

The workflow for this package is as follows. Once we have loaded the package,
we first open a port with openPort, for Macaulay2 to
communicate with the browser. Once a port is established, define an object to
visualize. In this example we could use the command openPort"8080" before or
after we define the following poset.

+----------------------------------------------------+
|i1 : P = poset {{1,2},{2,3},{3,4},{5,6},{6,7},{3,6}}|
|                                                    |
|o1 = P                                              |
|                                                    |
|o1 : Poset                                          |
+----------------------------------------------------+

At this point we wish to visualize P. To do this simply execute H = visualize P
and browser will open with interactive image. You can view this image in the
link below.

Visualize Posets example (see
common/share/Macaulay2/Visualize/poset-example.html )

Once finished with a session, you can keep visualizing. For example if you were
to say H = visualize P, once you ended the session, the last poset on the
screen would be assigned to H. After running various computations on this
poset, you can then visualize it once more with the visualize,
method. You can keep using this method until the port is closed with
closePort, or Macaulay2 is restarted.

Browser Menu Options
====================

On the side of the browser will be several options to interact with the poset
using the Posets, package. Below is a brief overview of the
options.

  * Force Variables: The 'charge' slider will force the vertices to repel or
    attract each other while the 'links' slider increases and decreases the
    length of the edges.

  * Enable Editing: In the browser, you can edit the poset (add/delete vertices
    or edges) by clicking Enable Editing.  For example, in order to remove the
    edge {1,2}, click on 'Enable Editing' and select the edge and press delete
    on the keyboard.  When deleting an edge, the minimal covering relations and
    visual display are automatically updated to reflect the new poset
    structure.  You may also add vertices and edges with the mouse/trackpad.
    When adding a new edge (relation), you must drag from the smaller vertex in
    the relation to the larger vertex.  Each time a new edge is added, a check
    is performed to determine whether the new edge would violate antisymmetry,
    and if so then an alert is displayed.  Also, each time a new edge is added,
    the transitive closure is computed, the rank/height of each poset element
    is recomputed, and the visual display of the poset is updated.  When
    editing is enabled, you can move the vertices around by holding down the
    shift key.

  * Hide Labels: Removes the labels from the vertices.

  * Highlight comparable elements: Allows you to see the comparable elements
    when a vertex is selected.

  * Fix extremal nodes: Forces extremal nodes to be placed at the top and
    bottom of the image.

  * Reset Nodes: When you move a vertex, it will pin it to the canvas. If you
    have pinned a node to the canvas, you can undo this process by resetting
    the nodes. Clicking this will reset all nodes.

  * Turn off force: The force is what creates the charges on the nodes. Turning
    this off will make the vertices not repel each other.

  * Generate TikZ code: Clicking this will generate the TikZ code for a black
    and white version of the poset that is being viewed. You will then have to
    copy this to the clipboard by clicking a new button. The TeX file will only
    need '\usepackage{tikz}' in the preamble. If you decide you want to modify
    the poset, feel free. All you need do in order to get a new TikZ code is
    click on 'Generate TikZ code' once more, and then click the button. This
    button will look the same, but it will be a new code.

  * Boolean tests: Clicking this will pull up a submenu of boolean tests
    supported by the Posets, package. Clicking on these
    tests will send a request to Macaulay2 to calculate the answer for the
    current poset on the screen. Warning: If your poset is too large, clicking
    a menu item could take a very long time. In order to cancel the process you
    need to kill the session of Macaulay2 with 'Ctrl+c+c' in the instance of
    Macaulay2.

  * Numerical invariants: Clicking this will pull up a submenu of numerical
    invariants supported by the Posets, package. Clicking on
    these will send a request to Macaulay2 to calculate the answer for the
    current poset on the screen. Warning: If your poset is too large, clicking
    a menu item could take a very long time. In order to cancel the process you
    need to kill the session of Macaulay2 with 'Ctrl+c+c' in the instance of
    Macaulay2.

  * End session: When you are finished editing, you can end the session and
    send the current poset to Macaulay2. The output of visualize P is the poset
    on the screen when end session is clicked.

Caveat
======

When the poset is exported back to Macaulay2 after ending the visualization
session, all vertices are represented as strings.  To recover the values of
these labels (for example, if they have numeric values or represent ring
variables), use the command poset(value toString vertices P,value toString
coveringRelations P).

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Ways to use this method:
========================

  * visualize(Poset) -- visualizes a poset in the
    browser
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1583:0.

visualize(Poset,Verbose=>...) -- an to view communication between Macaulay2 server and browser
***********************************************************************************************

  * Usage:
        H = visualize (P, Verbose => true)
  * Inputs:
      * P, an instance of the type Poset (Posets), a poset

Description
===========

When this option is used, the user can view the communication between the
Macaulay2 server and the browser. The communication will be displayed in the
instance of Macaulay2.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named Verbose:
===============================================

  * "check(...,Verbose=>...)" -- see check (Macaulay2Doc), --
    perform tests of a package
  * "checkDegrees(...,Verbose=>...)" -- see checkDegrees (Isomorphism),
    -- compares the degrees of generators of two
    modules
  * "copyDirectory(...,Verbose=>...)" -- see
    copyDirectory(String,String) (Macaulay2Doc),
  * "copyFile(...,Verbose=>...)" -- see copyFile(String,String) (Macaulay2Doc),
  * "findProgram(...,Verbose=>...)" -- see findProgram (Macaulay2Doc),
    -- load external program
  * "installPackage(...,Verbose=>...)" -- see installPackage (Macaulay2Doc),
    -- load and install a package and its
    documentation
  * "isIsomorphic(...,Verbose=>...)" -- see isIsomorphic (Isomorphism),
    -- probabilistic test for isomorphism of modules
  * "isomorphism(...,Verbose=>...)" -- see isomorphism (Isomorphism),
    -- retrieve an isomorphism of modules
  * "moveFile(...,Verbose=>...)" -- see moveFile(String,String) (Macaulay2Doc),
  * "runProgram(...,Verbose=>...)" -- see runProgram (Macaulay2Doc),
    -- run an external program
  * "symlinkDirectory(...,Verbose=>...)" -- see
    symlinkDirectory(String,String) (Macaulay2Doc),
    -- make symbolic links
    for all files in a directory tree
  * visualize(Digraph,Verbose=>...)
    -- an to view communication
    between Macaulay2 server and browser
  * visualize(Graph,Verbose=>...)
    -- an to view communication
    between Macaulay2 server and browser
  * visualize(Ideal,Verbose=>...) (missing documentation)
  * visualize(Poset,Verbose=>...)
    -- an to view communication
    between Macaulay2 server and browser
  * visualize(SimplicialComplex,Verbose=>...) (missing documentation)

Further information
===================

  * Default value: false (Macaulay2Doc),
  * Method: visualize(Poset), -- visualizes a poset
    in the browser
  * Option key: Verbose (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:2134:0.

visualize(Poset,VisPath=>...) -- an option to define a path to save visualizations of Posets
********************************************************************************************

  * Usage:
        H = visualize (P, VisPath => "/PATH/TO/DIRECTORY/")
  * Inputs:
      * P, an instance of the type Poset (Posets), a poset

Description
===========

The default nature of the Visualize package is to open the visualization in a
temporary file. Use the VisPath option if you wish to save the visualization to
a given directory. If the process will overwrite files, a warning appears
asking the user if they would like to proceed. You can squelch this warning
with the Warning, option.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisPath:
===============================================

  * visualize(Digraph,VisPath=>...)
    -- an option to define a path
    to save visualizations of Digraphs
  * visualize(Graph,VisPath=>...)
    -- an option to define a path to
    save visualizations of Graphs
  * visualize(Ideal,VisPath=>...)
    -- an option to define a path to
    save visualizations of Ideals
  * visualize(Poset,VisPath=>...)
    -- an option to define a path to
    save visualizations of Posets
  * visualize(SimplicialComplex,VisPath=>...)
    -- an option to
    define a path to save visualizations of simplicial complexes

Further information
===================

  * Default value: null
  * Method: visualize(Poset), -- visualizes a poset
    in the browser
  * Option key: VisPath, -- an option to define a path to save
    visualizations
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1835:0.

visualize(Poset,VisTemplate=>...) -- an option defining the template path
*************************************************************************

  * Usage:
        H = visualize (P, VisPath => "/PATH/TO/TEMPLATE/")
  * Inputs:
      * P, an instance of the type Poset (Posets), a poset

Description
===========

This option is used internally to pass paths from one method to another. A
savvy user would be able to use this option to create a personal template and
pass the path for Visualize.m2 to use.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisTemplate:
===================================================

  * visualize(Digraph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Graph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Ideal,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Poset,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(SimplicialComplex,VisTemplate=>...)
    -- an option
    defining the template path

Further information
===================

  * Default value: /home/macaulay/rpmbuild/BUILD/Macaulay2-1.25.11/M2/Macaulay2
    /packages/Visualize/templates/visPoset/visPoset-template.html
  * Method: visualize(Poset), -- visualizes a poset
    in the browser
  * Option key: VisTemplate, -- an option defining the
    template path
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1941:0.

visualize(Poset,Warning=>...) -- an option to squelch warnings
**************************************************************

  * Usage:
        H = visualize (P, VisPath => "/PATH/TO/DIRECTORY/", Warning => false)
  * Inputs:
      * P, an instance of the type Poset (Posets), a poset

Description
===========

When using the option VisPath, a warning is produced if files
will be overwritten. Warning is used to squelch these warnings. The default
value is true, meaning the warning will be displayed.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named Warning:
===============================================

  * visualize(Digraph,Warning=>...)
    -- an option to squelch
    warnings
  * visualize(Graph,Warning=>...)
    -- an option to squelch warnings
  * visualize(Ideal,Warning=>...)
    -- an option to squelch warnings
  * visualize(Poset,Warning=>...)
    -- an option to squelch warnings
  * visualize(SimplicialComplex,Warning=>...)
    -- an option to
    squelch warnings

Further information
===================

  * Default value: true (Macaulay2Doc),
  * Method: visualize(Poset), -- visualizes a poset
    in the browser
  * Option key: Warning, -- an option to squelch warnings
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:2048:0.

visualize(SimplicialComplex) -- visualizes a simplicial complex in the browser
******************************************************************************

  * Function: visualize,

Description
===========

Using JavaScript, this method creates an interactive visualization of a
simplicial complex in a modern browser. While viewing the simplicial complex,
the user has the ability to manipulate and run various tests. Once finished,
the user can export the finished result back to the Macaulay2 session.

The workflow for this package is as follows. Once we have loaded the package,
we first open a port with openPort, for Macaulay2 to
communicate with the browser. Once a port is established, define an object to
visualize. In this example we could use the command openPort"8080" before or
after we define the following simplicial complex.

+--------------------------------------------------+
|i1 : R = ZZ[a..g]                                 |
|                                                  |
|o1 = R                                            |
|                                                  |
|o1 : PolynomialRing                               |
+--------------------------------------------------+
|i2 : D = simplicialComplex {a*b*c,a*b*d,a*e*f,a*g}|
|                                                  |
|o2 = simplicialComplex | ag aef abd abc |         |
|                                                  |
|o2 : SimplicialComplex                            |
+--------------------------------------------------+

At this point we wish to visualize D. To do this simply execute H = visualize D
and browser will open with interactive image. You can view this image in the
link below.

Visualize Simplicial Complex example (see
common/share/Macaulay2/Visualize/simplicial-complex-example.html )

Once finished with a session, you can keep visualizing. For example if you were
to say H = visualize D, once you ended the session, the last simplicial complex
on the screen would be assigned to H. After running various computations on
this simplicial complex, you can then visualize it once more with the
visualize, method. You can keep using this method until the port is
closed with closePort, or Macaulay2 is restarted.

Browser Menu Options
====================

On the side of the browser will be several options to interact with the
simplicial complex using the SimplicialComplex (SimplicialComplexes),
package. Below is a brief overview of
the options.

  * Force Variables: The 'charge' slider will force the vertices to repel or
    attract each other while the 'links' slider increases and decreases the
    length of the edges.

  * Enable Editing: In the browser, you can edit the simplicial complex
    (add/delete vertices or edges) by clicking Enable Editing.  For example, in
    order to remove the edges {0,1} and {1,3} click on 'Enable Editing' and
    select the edges and press delete on the keyboard. You may also add
    vertices and edges with the mouse/trackpad. When editing is enabled, you
    can move the vertices around by holding down the shift key. Further, to
    create a face, hold down the 'f' key and select three distinct nodes.

  * Hide Labels: Removes the labels from the vertices.

  * Highlight faces: Allows you to see the connecting faces when a vertex is
    selected.

  * Reset Nodes: When you move a vertex, it will pin it to the canvas. If you
    have pinned a node to the canvas, you can undo this process by resetting
    the nodes. Clicking this will reset all nodes.

  * Turn off force: The force is what creates the charges on the nodes. Turning
    this off will make the vertices not repel each other.

  * Generate TikZ code: Clicking this will generate the TikZ code for a black
    and white version of the simplicial complex that is being viewed. You will
    then have to copy this to the clipboard by clicking a new button. The TeX
    file will only need '\usepackage{tikz}' in the preamble. If you decide you
    want to modify the simplicial complex, feel free. All you need do in order
    to get a new TikZ code is click on 'Generate TikZ code' once more, and then
    click the button. This button will look the same, but it will be a new
    code.

  * Boolean tests: Clicking this will pull up a submenu of boolean tests
    supported by the SimplicialComplex (SimplicialComplexes),
    package. Clicking on these tests
    will send a request to Macaulay2 to calculate the answer for the current
    simplicial complex on the screen. Warning: If your simplicial complex is
    too large, clicking a menu item could take a very long time. In order to
    cancel the process you need to kill the session of Macaulay2 with
    'Ctrl+c+c' in the instance of Macaulay2.

  * End session: When you are finished editing, you can end the session and
    send the current simplicial complex to Macaulay2. The output of visualize D
    is the simplicial complex on the screen when end session is clicked.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Ways to use this method:
========================

  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1680:0.

visualize(SimplicialComplex,VisPath=>...) -- an option to define a path to save visualizations of simplicial complexes
**********************************************************************************************************************

  * Usage:
        H = visualize (S, VisPath => "/PATH/TO/DIRECTORY/")
  * Inputs:
      * S, an abstract simplicial complex (SimplicialComplexes),
        a simplicial complex

Description
===========

The default nature of the Visualize package is to open the visualization in a
temporary file. Use the VisPath option if you wish to save the visualization to
a given directory. If the process will overwrite files, a warning appears
asking the user if they would like to proceed. You can squelch this warning
with the Warning, option.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisPath:
===============================================

  * visualize(Digraph,VisPath=>...)
    -- an option to define a path
    to save visualizations of Digraphs
  * visualize(Graph,VisPath=>...)
    -- an option to define a path to
    save visualizations of Graphs
  * visualize(Ideal,VisPath=>...)
    -- an option to define a path to
    save visualizations of Ideals
  * visualize(Poset,VisPath=>...)
    -- an option to define a path to
    save visualizations of Posets
  * visualize(SimplicialComplex,VisPath=>...)
    -- an option to
    define a path to save visualizations of simplicial complexes

Further information
===================

  * Default value: null
  * Method: visualize(SimplicialComplex),
    -- visualizes a simplicial complex in the
    browser
  * Option key: VisPath, -- an option to define a path to save
    visualizations
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1857:0.

visualize(SimplicialComplex,VisTemplate=>...) -- an option defining the template path
*************************************************************************************

  * Usage:
        H = visualize (S, VisPath => "/PATH/TO/TEMPLATE/")
  * Inputs:
      * S, an abstract simplicial complex (SimplicialComplexes),
        a simplicial complex

Description
===========

This option is used internally to pass paths from one method to another. A
savvy user would be able to use this option to create a personal template and
pass the path for Visualize.m2 to use.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named VisTemplate:
===================================================

  * visualize(Digraph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Graph,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Ideal,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(Poset,VisTemplate=>...)
    -- an option defining the
    template path
  * visualize(SimplicialComplex,VisTemplate=>...)
    -- an option
    defining the template path

Further information
===================

  * Default value: /home/macaulay/rpmbuild/BUILD/Macaulay2-1.25.11/M2/Macaulay2
    /packages/Visualize/templates/visSimplicialComplex/visSimplicialComplex2d-
    template.html
  * Method: visualize(SimplicialComplex),
    -- visualizes a simplicial complex in the
    browser
  * Option key: VisTemplate, -- an option defining the
    template path
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1962:0.

visualize(SimplicialComplex,Warning=>...) -- an option to squelch warnings
**************************************************************************

  * Usage:
        H = visualize (S, VisPath => "/PATH/TO/DIRECTORY/", Warning => false)
  * Inputs:
      * S, an abstract simplicial complex (SimplicialComplexes),
        a simplicial complex

Description
===========

When using the option VisPath, a warning is produced if files
will be overwritten. Warning is used to squelch these warnings. The default
value is true, meaning the warning will be displayed.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named Warning:
===============================================

  * visualize(Digraph,Warning=>...)
    -- an option to squelch
    warnings
  * visualize(Graph,Warning=>...)
    -- an option to squelch warnings
  * visualize(Ideal,Warning=>...)
    -- an option to squelch warnings
  * visualize(Poset,Warning=>...)
    -- an option to squelch warnings
  * visualize(SimplicialComplex,Warning=>...)
    -- an option to
    squelch warnings

Further information
===================

  * Default value: true (Macaulay2Doc),
  * Method: visualize(SimplicialComplex),
    -- visualizes a simplicial complex in the
    browser
  * Option key: Warning, -- an option to squelch warnings
-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:2069:0.

Warning -- an option to squelch warnings
****************************************

Description
===========

When using the option VisPath, a warning is produced if files
will be overwritten. Warning is used to squelch these warnings. The default
value is true, meaning the warning will be displayed.

See also
========

  * Basic Workflow for Visualize
  * visualize(Graph) -- visualizes a graph in a
    modern browser
  * visualize(Digraph) -- visualizes a digraph
    in the browser
  * visualize(Poset) -- visualizes a poset in the
    browser
  * visualize(SimplicialComplex), --
    visualizes a simplicial complex in the browser
  * visualize(Ideal) -- visualizes an ideal in the
    browser

Functions with optional argument named Warning:
===============================================

  * visualize(Digraph,Warning=>...)
    -- an option to squelch
    warnings
  * visualize(Graph,Warning=>...)
    -- an option to squelch warnings
  * visualize(Ideal,Warning=>...)
    -- an option to squelch warnings
  * visualize(Poset,Warning=>...)
    -- an option to squelch warnings
  * visualize(SimplicialComplex,Warning=>...)
    -- an option to
    squelch warnings

For the programmer
==================

The object Warning, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Visualize.m2:1736:0.