=====Material for the Workshop=====
This page contains material used during the polymake Workshop.

====GEN====

=== Simple Computations With Polytopes ===
There are numerous standard constructions of polytopes. To have something computed means to ask for a (polytope's) property.  Visualization is triggered via calling user_methods like VISUAL or SCHLEGEL. Syntactically these also look like properties. Convex hull (and other) computations are implicit.
<code>
$c=cube(3);
print $c->FACETS;
print_constraints($c);
print $c->F_VECTOR;
$c_polar=polarize($c);
print $c_polar->F_VECTOR;
$c_polar->VISUAL;
product(n_gon(5),n_gon(7))->SCHLEGEL(FACET=>1,EdgeColor=>"blue");
</code>

=== Rule Based Computation ===

New properties are derived from known ones via rules.  The status of an object (here a permutahedron) is described via the set of properties known.  Asking for a new property forces polymake to compute a sequence of rules (forming a schedule) which are then applied to the object.  Usually, this is automatic.  However, it is possible to inspect what is going on before any actual computation takes place.
<code>
$p=permutahedron(3);
print join(", ", $p->list_properties);
$schedule=$p->get_schedule("SIMPLE");
print join("\n", $schedule->list);
$schedule->apply($p);
print join(", ", $p->list_properties);
print $p->SIMPLE;
</code>

=== Getting Help ===

The online help uses text placed near the respective implementations.

<code>
help 'objects';
help 'objects/Polytope';
$t=typeof $c;
print join(", ", sorted_uniq(sort { $a cmp $b } map { keys %{$_->properties} } $t, @{$t->super}));
</code>

=== Long Integer Arithmetic ===

The exact integer (and rational) arithmetic is based on the GMP:

<code>
$f = new Integer(1);
for ($i = new Integer(100); $i>0; --$i) { $f *= $i; }
print $f;
</code>

=== New: Polynomials ===

polymake has a new class for polynomials.  This is mainly a container without much functionality.  While standard operators are defined, beware that they still follow the standard Perl precedences.
<code>
$r=new Ring("x","y");
($x,$y)=$r->variables;
$p=1*(1+$x*$y)-1*($x+($y^2))+2*(($x^2)+$y);
$N=newton($p);
print $N->VERTICES;
print fac($N->DIM)*$N->VOLUME;
</code>

=== Perl Power ===

The benefit of using a standard programming language such as Perl is that one can use standard libraries for basic needs.  Here is an example showing how to benchmark two different convex hull algorithms/codes on the same example.
<code>
use Benchmark qw(:all);
$r=rand_sphere(3,1000,seed=>1); $t=timeit(1,'$r->FACETS;'); print timestr($t);
$r=rand_sphere(3,1000,seed=>1); prefer_now("beneath_beyond"); $t=timeit(1,'$r->FACETS;'); print timestr($t);
</code>
This code does not work in a script file (.pl) because of polymake's modifications to Perl. You rather want to use something like this.
<code>
use Benchmark qw(:all);
use application 'polytope';

my $r=rand_sphere(3,100,seed=>1);

sub getfacets{
  $r->FACETS;
}

sub myBenchmark{
  my $t=Benchmark::timeit(1,"getfacets"); 
  print timestr($t);
}
</code>


=== Other Kinds of Objects ===

polymake's object/rule concept is not restricted to polytopes.  Here are a few example computations with finite simplicial complexes,
<code>
application 'topaz';
$rp2=projective_plane();
print $rp2->HOMOLOGY;
print $rp2->CONNECTED;
print rows_labeled($rp2->HOMOLOGY);
$t=torus();
print $t->FACETS;
$t->VISUAL;
</code>

The entire script used for the introduction presentation:
{{:gen.script|}}
====BEG====

{{:beg.demo|BEG}}
====EXT====

The example extension created during the tutorial: {{:example.zip|}}

The demo file used for the new application Foo: {{:foo.demo|}}
====APP====
{{:app.script|}}

====SEM====

===Objects Are Immutable===
<code>
application "polytope";
$p=new Polytope<Rational>(POINTS=>cube(3)->VERTICES/new Vector<Rational>([1,2,2,2]));
print $p->VERTICES;
</code>

===Objects Are Equivalence Classes===
<code>
$p=new Polytope<Rational>(POINTS=>[[1,0],[1,1]]);
print $p->VOLUME;
$q=new Polytope<Rational>(INEQUALITIES=>$p->FACETS);
print equal_polyhedra($p,$q);
print $p->VERTICES_IN_FACETS;
$r=new Polytope<Rational>(VERTICES_IN_FACETS=>$p->VERTICES_IN_FACETS);
print $r->VOLUME;
print equal_polyhedra($p,$r);
print isomorphic($p,$r);
</code>

===Take It to Extremes===
<code>
@fs = map { 8 } 1..24;
$g=new Graph(BIPARTITE=>1);
$s=new Polytope<Rational>(COMBINATORIAL_DIM=>4, FACET_SIZES=>\@fs, GRAPH=>$g);
print $s->CUBICAL;
</code>

===Users Are Responsible===
<code>
$t=new Polytope<Rational>(COMBINATORIAL_DIM=>3,N_VERTICES=>2);
$t=new Polytope<Rational>(N_VERTICES=>-5);
print $t->N_VERTICES;
check_poly(cube(3)->VERTICES_IN_FACETS,verbose=>1);
</code>

===Polytope Is Dervived From Cone===
<code>
$c=cube(3);
print $c->VERTICES;
print $c->CONE_DIM, " ", $c->CONE_AMBIENT_DIM;
print $c->DIM, " ", $c->AMBIENT_DIM;
</code>
===Unbounded Polyhedra===
<code>
$q=new Polytope<Rational>(INEQUALITIES=>$c->FACETS->minor(~[$c->N_FACETS-1],All));
print $q->BOUNDED;
print $q->FAR_FACE, " ", $q->N_VERTICES;
print $q->VERTICES_IN_FACETS;
$q2=orthantify($q);
print $q2->POSITIVE;
$q3=bound($q2);
print $q3->BOUNDED;
print isomorphic($q,$q3);
$q3->VISUAL;
</code>

===Non-trivial Lineality Space===
<code>
$q=new Polytope<Rational>(INEQUALITIES=>$c->FACETS->minor(~[4..5],All));
print $q->N_VERTICES;
print $q->VERTICES_IN_FACETS;
print $q->F_VECTOR;
</code>


====VIS====

In the visual tutorial we will take a tour through the visualization opportunities given by polymake. You can try it on your own using the command file {{:vis.demo|}} and the supplementary file {{:vis.zip|}} containing two polytope files and one polymake script.

===Polytope visualization===
Every visualization tutorial starts with a cube -- this one doesn't. We prefer truncated octahedra.
<code>
prefer 'jreality';
$oct = cross(3);
$oct_trunc = truncation($oct,All);
$oct_trunc->VISUAL;
</code>

===Visualizing the truncation===
Now we compose the octahedron with the truncated octahedron to understand what exactly happened.
<code>
compose($oct->VISUAL,$oct_trunc->VISUAL);
compose($oct->VISUAL(FacetStyle=>"hidden",VertexStyle=>"hidden"),$oct_trunc->VISUAL);
$oct_trunc->VISUAL->TRIANGULATION;
</code>

===Visualizing lattice points==
The truncated cross polytope only contains one lattice point, but after scaling it by a factor of two it contains more. The color of the lattice points indicates whether the points lie on a facet or strictly in the interior.
<code>
$oct_trunc->VISUAL->LATTICE;
$T = new Matrix<Rational>([ [1/2, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]);
$oct_scaled = new Polytope<Rational>(VERTICES => ($oct_trunc->VERTICES)*$T);
$oct_scaled->VISUAL->LATTICE_COLORED;
</code>

===Visualizing in higher dimensions===
A simple visualization of the graph of the truncated 4-cross polytope using our spring embedder.
<code>
$cr4 = cross(4);
$cr4_trunc = truncation($cr4,All);
$cr4_trunc->VISUAL_GRAPH;
</code>

===Visualizing with linear objective===
We select one of the facets corresponding to a cut off vertex and make the defining inequality the linear objective of a linear program. The VERTEX_COLORS indicate the value of the objective function at the vertices. But we can even set the vertex labels to the proper value using a small perl subroutine.
<code>
print $cr4_trunc->VERTICES_IN_FACETS;
print rows_numbered($cr4_trunc->VERTICES_IN_FACETS);
$lp = new LinearProgram<Rational>(LINEAR_OBJECTIVE=>${$cr4_trunc->FACETS}[16]);
$cr4_trunc->LP = $lp;
$cr4_trunc->VISUAL_GRAPH->VERTEX_COLORS;
$l = $lp->LINEAR_OBJECTIVE;
$cr4_trunc->VISUAL_GRAPH(NodeLabels=> sub { my $i = shift; my $v = ${$cr4_trunc->VERTICES}[$i]; my $val = $l*$v; return $val;} )->VERTEX_COLORS;
</code>

===Changing face colors===
We use a small subroutine to color a soccerball in a traditional way or to create a terribly colored disco-ball.
<code>
$soccerball = load("soccerball.poly");
$soccerball->VISUAL(FacetColor => sub { $i = shift; $s = ${$soccerball->VERTICES_IN_FACETS}[$i]; if($s->size == 5) { return "black"; } else { return "white"; } });
rand_sphere(3,100)->VISUAL(FacetColor => sub { return new RGB(rand,rand,rand); }, VertexColor => sub { return new RGB(rand,rand,rand); }, EdgeStyle => "hidden");
</code>

===Schlegel diagrams===
The Schlegel diagram is the projection of a polytope onto one of its faces. The zoom factor determines the distance of the center of projection from the projection facet. In dimension 3 we may visualize the entire construction and illustrate the influence of the zoom factor. In dimension 4 it is possible to add all the 3 dimensional facets to the Schlegel diagram.

<code>
$cr4_trunc->SCHLEGEL(ZOOM=>".6");
$oct_trunc->SCHLEGEL(ZOOM=>".5")->CONSTRUCTION;
compose($oct_trunc->SCHLEGEL(ZOOM=>".5",EdgeColor=>"orange")->CONSTRUCTION, $oct_trunc->SCHLEGEL(ZOOM=>".7")->CONSTRUCTION);
$cr4_trunc->SCHLEGEL(ZOOM=>".5")->SOLID(FacetTransparency=>".9");
</code>

===Tight spans===
The tight span is an unbounded polyhedron associated with a finite metric space. In our case the metric is generated by some genes of bees. The resulting tight span is high dimensional, but we can visualize its graph with edge colors hinting at the dimension of the faces the edges are contained in.
<code>
$ts = load("bees.poly");
$ts->VISUAL_BOUNDED_GRAPH->EDGE_COLORS;
</code>

===Tropical polytopes===
We can also visualize tropical polytopes and hypersurfaces.
<code>
application 'tropical';
$tcyc = cyclic(3,5);
$tcyc->VISUAL_PSEUDOVERTEX_GRAPH;
$ths = new Hypersurface(MONOMIALS=>[[1,1,2,1],[0,1,3,1],[0,3,2,0],[1,2,1,1]],COEFFICIENTS=>[1,3,2,2]);
$ths->VISUAL;
</code>

===Fans===
The normal fan consists of all normal cones at the vertices of a polytope. A little script properly visualizes the normal cones at the vertices of the polytope.
<code>
application 'fan';
$nf = normal_fan($oct_trunc);
$nf->VISUAL;
script("visual_normal_fan",$oct_trunc);
</code>

====PRL====
The documented [[user_guide:perl_continued|PRL-tutorial]].
All examples in one file:\\
{{:prl.script|}} {{:points.demo|}}
====CAL====

{{:callable.tbz|Example files for the callable library}}
{{:cal_pres.pdf|Presentation}}
====CPP====

{{:cpp_pres.pdf|Presentation}}
====PTL====