diff --git a/bin/parse-problem-doc.pl b/bin/parse-problem-doc.pl
new file mode 100755
index 0000000000..84128cad37
--- /dev/null
+++ b/bin/parse-problem-doc.pl
@@ -0,0 +1,162 @@
+#!/usr/bin/env perl
+
+use strict;
+use warnings;
+use experimental 'signatures';
+use feature 'say';
+
+my $pg_root;
+
+BEGIN {
+	use Mojo::File qw(curfile);
+	$pg_root = curfile->dirname->dirname;
+}
+
+use lib "$pg_root/lib";
+
+use Mojo::Template;
+use File::Basename qw(fileparse basename);
+use Getopt::Long;
+use File::Copy qw(copy);
+use YAML::XS qw(DumpFile);
+use Pod::Simple::Search;
+
+use SampleProblemParser qw(parseSampleProblem generateMetadata);
+
+my $problem_dir = "$pg_root/tutorial/sample-problems";
+
+my ($out_dir, $pod_root, $pg_doc_home);
+my $verbose = 0;
+
+GetOptions(
+	"d|problem_dir=s" => \$problem_dir,
+	"o|out_dir=s"     => \$out_dir,
+	"v|verbose"       => \$verbose,
+	"p|pod_root=s"    => \$pod_root,
+	"h|pg_doc_home=s" => \$pg_doc_home,
+);
+
+die "out_dir, pod_root, and pg_doc_home must be provided.\n"
+	unless $out_dir && $pod_root && $pg_doc_home;
+
+my $mt           = Mojo::Template->new(vars => 1);
+my $template_dir = "$pg_root/tutorial/templates";
+
+(undef, my $macro_files) = Pod::Simple::Search->new->inc(0)->survey("$pg_root/macros");
+my $macro_locations = { map { basename($_) => ($_ =~ s!$pg_root/macros/!!r) =~ s/\.pl/.html/r } keys %$macro_files };
+
+my @problem_types = qw(sample technique snippet);
+
+$pod_root .= '/pg/macros';
+mkdir $out_dir unless -d $out_dir;
+
+# Build a hash of all PG files for linking.
+my $index_table = generateMetadata($problem_dir, macro_locations => $macro_locations, verbose => $verbose);
+
+for (keys %$index_table) {
+	renderSampleProblem(
+		$_ =~ s/.pg$//r,
+		metadata        => $index_table,
+		macro_locations => $macro_locations,
+		pod_root        => $pod_root,
+		pg_doc_home     => $pg_doc_home,
+		url_extension   => '.html',
+		problem_dir     => $problem_dir,
+		out_dir         => $out_dir,
+		template_dir    => $template_dir,
+		mt              => $mt,
+		verbose         => $verbose
+	);
+}
+
+sub renderSampleProblem ($filename, %global) {
+	my $relative_dir = $global{metadata}{"$filename.pg"}{dir};
+	my $path         = "$global{problem_dir}/$relative_dir/$filename.pg";
+	say "Processing file: $path" if $global{verbose};
+	my $parsed_file = parseSampleProblem($path, %global);
+
+	mkdir "$global{out_dir}/$relative_dir" unless -d "$global{out_dir}/$relative_dir";
+
+	say "Printing to '$global{out_dir}/$relative_dir/$filename.html'" if $global{verbose};
+	open(my $html_fh, '>:encoding(UTF-8)', "$global{out_dir}/$relative_dir/$filename.html")
+		or die qq{Could not open output file "$global{out_dir}/$relative_dir/$filename.html": $!};
+	print $html_fh $global{mt}->render_file("$global{template_dir}/problem-template.mt",
+		{ %$parsed_file, %global, filename => "$filename.pg" });
+	close $html_fh;
+
+	# Write the code to a separate file
+	open(my $pg_fh, '>:encoding(UTF-8)', "$global{out_dir}/$relative_dir/$filename.pg")
+		or die qq{Could not open output file "$global{out_dir}/$relative_dir/$filename.pg": $!};
+	print $pg_fh $parsed_file->{code};
+	close $pg_fh;
+	say "Printing pg file to '$global{out_dir}/$relative_dir/$filename.pg'" if $global{verbose};
+	return;
+}
+
+# Ouput index files.
+for (qw(categories subjects macros techniques)) {
+	my $options = {
+		metadata     => $index_table,
+		template_dir => $template_dir,
+		out_dir      => $out_dir,
+		mt           => $mt,
+		verbose      => $verbose,
+	};
+	my $params = buildIndex($_, %$options);
+	writeIndex($params, %$options);
+}
+
+sub buildIndex ($type, %options) {
+	my %labels = (
+		categories => 'Categories',
+		subjects   => 'Subject Areas',
+		macros     => 'Problems by Macro',
+		techniques => 'Problem Techniques'
+	);
+
+	my $list = {};
+	if ($type =~ /^(categories|subjects|macros)$/) {
+		for my $sample_file (keys %{ $options{metadata} }) {
+			for my $category (@{ $options{metadata}{$sample_file}{$type} }) {
+				$list->{$category}{ $options{metadata}{$sample_file}{name} } =
+					"$options{metadata}{$sample_file}{dir}/" . ($sample_file =~ s/\.pg$/.html/r);
+			}
+		}
+	} elsif ($type eq 'techniques') {
+		for my $sample_file (keys %{ $options{metadata} }) {
+			if (grep { $_ eq 'technique' } @{ $options{metadata}{$sample_file}{types} }) {
+				$list->{ $options{metadata}{$sample_file}{name} } =
+					"$options{metadata}{$sample_file}{dir}/" . ($sample_file =~ s/\.pg$/.html/r);
+			}
+		}
+	}
+
+	return {
+		label  => $labels{$type},
+		list   => $list,
+		type   => $type,
+		output => "$options{out_dir}/$type.html"
+	};
+}
+
+sub writeIndex ($params, %options) {
+	say "Creating $params->{label} index" if $options{verbose};
+	if (open my $FH, '>:encoding(UTF-8)', $params->{output}) {
+		print $FH $options{mt}->render_file(
+			"$options{template_dir}/general-layout.mt",
+			{
+				sidebar      => $options{mt}->render_file("$options{template_dir}/general-sidebar.mt", $params),
+				main_content => $options{mt}->render_file("$options{template_dir}/general-main.mt",    $params),
+				active       => $params->{type}
+			}
+		);
+		close $FH;
+	}
+	return;
+}
+
+# Copy the PG.js file and CSS file into the output directory.
+copy("$pg_root/tutorial/js/PG.js",               $out_dir);
+copy("$pg_root/tutorial/css/sample-problem.css", $out_dir);
+
+1;
diff --git a/lib/SampleProblemParser.pm b/lib/SampleProblemParser.pm
new file mode 100644
index 0000000000..6cce81e38f
--- /dev/null
+++ b/lib/SampleProblemParser.pm
@@ -0,0 +1,231 @@
+################################################################################
+# WeBWorK Online Homework Delivery System
+# Copyright © 2000-2023 The WeBWorK Project, https://github.com/openwebwork
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of either: (a) the GNU General Public License as published by the
+# Free Software Foundation; either version 2, or (at your option) any later
+# version, or (b) the "Artistic License" which comes with this package.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See either the GNU General Public License or the
+# Artistic License for more details.
+################################################################################
+
+package SampleProblemParser;
+use parent qw(Exporter);
+
+use strict;
+use warnings;
+use experimental 'signatures';
+use feature 'say';
+
+use File::Basename qw(dirname basename);
+use File::Find qw(find);
+use Pandoc;
+
+our @EXPORT_OK = qw(parseSampleProblem generateMetadata);
+
+=head1 NAME
+
+SampleProblemParser - Parse the documentation in a sample problem in the /doc
+directory.
+
+=head2 C<parseSampleProblem>
+
+Parse a PG file with extra documentation comments. The input is the file and a
+hash of global variables:
+
+=over
+
+=item C<metadata>: A reference to a hash which has information (name, directory,
+types, subjects, categories) of every sample problem file.
+
+=item C<macro_locations>: A reference to a hash of macros to include as links
+within a problem.
+
+=item C<pod_root>: The root directory of the POD.
+
+=item C<pg_doc_home>: The url of the pg_doc home.
+
+=item C<url_extension>: The html url extension (including the dot) to use for pg
+doc links.  The default is the empty string.
+
+=back
+
+=cut
+
+sub parseSampleProblem ($file, %global) {
+	my $filename = basename($file);
+	open(my $FH, '<:encoding(UTF-8)', $file) or do {
+		warn qq{Could not open file "$file": $!};
+		return {};
+	};
+	my @file_contents = <$FH>;
+	close $FH;
+
+	my (@blocks,  @doc_rows, @code_rows, @description);
+	my (%options, $descr,    $type,      $name);
+
+	$global{url_extension} //= '';
+
+	while (my $row = shift @file_contents) {
+		chomp($row);
+		$row =~ s/\t/    /g;
+		if ($row =~ /^#:%\s*(categor(y|ies)|types?|subjects?|see_also|name)\s*=\s*(.*)\s*$/) {
+			# skip this, already parsed.
+		} elsif ($row =~ /^#:%\s*(.*)?/) {
+			# The row has the form #:% section = NAME.
+			# This should parse the previous named section and then reset @doc_rows and @code_rows.
+			push(
+				@blocks,
+				{
+					%options,
+					doc  => pandoc->convert(markdown => 'html', join("\n", @doc_rows)),
+					code => join("\n", @code_rows)
+				}
+			) if %options;
+			%options   = split(/\s*:\s*|\s*,\s*|\s*=\s*|\s+/, $1);
+			@doc_rows  = ();
+			@code_rows = ();
+		} elsif ($row =~ /^#:/) {
+			# This section is documentation to be parsed.
+			$row = $row =~ s/^#://r;
+
+			# Parse any LINK/PODLINK/PROBLINK commands in the documentation.
+			if ($row =~ /(POD|PROB)?LINK\('(.*?)'\s*(,\s*'(.*)')?\)/) {
+				my $link_text = defined($1) ? $1 eq 'POD' ? $2 : $global{metadata}{$2}{name} : $2;
+				my $url =
+					defined($1)
+					? $1 eq 'POD'
+						? "$global{pod_root}/" . $global{macro_locations}{ $4 // $2 }
+						: "$global{pg_doc_home}/$global{metadata}{$2}{dir}/" . ($2 =~ s/.pg$/$global{url_extension}/r)
+					: $4;
+				$row = $row =~ s/(POD|PROB)?LINK\('(.*?)'\s*(,\s*'(.*)')?\)/[$link_text]($url)/gr;
+			}
+
+			push(@doc_rows, $row);
+		} elsif ($row =~ /^##\s*(END)?DESCRIPTION\s*$/) {
+			$descr = $1 ? 0 : 1;
+		} elsif ($row =~ /^##/ && $descr) {
+			push(@description, $row =~ s/^##\s*//r);
+			push(@code_rows,   $row);
+		} else {
+			push(@code_rows, $row);
+		}
+	}
+
+	# The last @doc_rows must be parsed then added to the @blocks.
+	push(
+		@blocks,
+		{
+			%options,
+			doc  => pandoc->convert(markdown => 'html', join("\n", @doc_rows)),
+			code => join("\n", @code_rows)
+		}
+	);
+
+	return {
+		name        => $global{metadata}{$filename}{name},
+		blocks      => \@blocks,
+		code        => join("\n", map { $_->{code} } @blocks),
+		description => join("\n", @description)
+	};
+}
+
+=head2 C<generateMetadata>
+
+Build a hash of metadata for all PG files in the given directory.  A reference
+to the hash that is built is returned.
+
+=cut
+
+sub generateMetadata ($problem_dir, %options) {
+	my $index_table = {};
+
+	find(
+		{
+			wanted => sub {
+				say "Reading file: $File::Find::name" if $options{verbose};
+
+				if ($File::Find::name =~ /\.pg$/) {
+					my $metadata = parseMetadata($File::Find::name, $problem_dir, $options{macro_locations});
+					unless (@{ $metadata->{types} }) {
+						warn "The type of sample problem is missing for $File::Find::name.";
+						return;
+					}
+					unless ($metadata->{name}) {
+						warn "The name attribute is missing for $File::Find::name.";
+						return;
+					}
+					$index_table->{ basename($File::Find::name) } = $metadata;
+				}
+			}
+		},
+		$problem_dir
+	);
+
+	return $index_table;
+}
+
+my @macros_to_skip = qw(
+	PGML.pl
+	PGcourse.pl
+	PGstandard.pl
+);
+
+sub parseMetadata ($path, $problem_dir, $macro_locations = {}) {
+	open(my $FH, '<:encoding(UTF-8)', $path) or do {
+		warn qq{Could not open file "$path": $!};
+		return {};
+	};
+	my @file_contents = <$FH>;
+	close $FH;
+
+	my @problem_types = qw(sample technique snippet);
+
+	my $metadata = { dir => (dirname($path) =~ s/$problem_dir\/?//r) =~ s/\/*$//r };
+
+	while (my $row = shift @file_contents) {
+		if ($row =~ /^#:%\s*(categor(y|ies)|types?|subjects?|see_also|name)\s*=\s*(.*)\s*$/) {
+			# The row has the form #:% categories = [cat1, cat2, ...].
+			my $label = lc($1);
+			my @opts  = $3 =~ /\[(.*)\]/ ? map { $_ =~ s/^\s*|\s*$//r } split(/,/, $1) : ($3);
+			if ($label =~ /types?/) {
+				for my $opt (@opts) {
+					warn "The type of problem must be one of @problem_types"
+						unless grep { lc($opt) eq $_ } @problem_types;
+				}
+				$metadata->{types} = [ map { lc($_) } @opts ];
+			} elsif ($label =~ /^categor/) {
+				$metadata->{categories} = \@opts;
+			} elsif ($label =~ /^subject/) {
+				$metadata->{subjects} = [ map { lc($_) } @opts ];
+			} elsif ($label eq 'name') {
+				$metadata->{name} = $opts[0];
+			} elsif ($label eq 'see_also') {
+				$metadata->{related} = \@opts;
+			}
+		} elsif ($row =~ /loadMacros\(/) {
+			chomp($row);
+			# Parse the macros, which may be on multiple rows.
+			my $macros = $row;
+			while ($row && $row !~ /\);\s*$/) {
+				$row = shift @file_contents;
+				chomp($row);
+				$macros .= $row;
+			}
+			# Split by commas and pull out the quotes.
+			my @macros = map {s/['"\s]//gr} split(/\s*,\s*/, $macros =~ s/loadMacros\((.*)\)\;$/$1/r);
+			$metadata->{macros} = [];
+			for my $macro (@macros) {
+				push(@{ $metadata->{macros} }, $macro) unless grep { $_ eq $macro } @macros_to_skip;
+			}
+		}
+	}
+
+	return $metadata;
+}
+
+1;
diff --git a/tutorial/css/sample-problem.css b/tutorial/css/sample-problem.css
new file mode 100644
index 0000000000..66daac22e7
--- /dev/null
+++ b/tutorial/css/sample-problem.css
@@ -0,0 +1,27 @@
+pre.CodeMirror {
+	background-color: #fcfaf1;
+}
+.explanation {
+	--bs-code-color: #971556;
+}
+.preamble {
+	background-color: lightblue;
+}
+.setup {
+	background-color: #ddffdd;
+}
+.statement {
+	background-color: #eeb08199;
+}
+.answer {
+	background-color: #ffffdd;
+}
+.solution {
+	background-color: #ffb6c199;
+}
+.hint {
+	background-color: rgb(239, 207, 251);
+}
+.perl {
+	color: darkred;
+}
diff --git a/tutorial/js/PG.js b/tutorial/js/PG.js
new file mode 100644
index 0000000000..62de45cfd7
--- /dev/null
+++ b/tutorial/js/PG.js
@@ -0,0 +1,1460 @@
+// Bassed off of CodeMirror mode perl file:
+// https://github.com/codemirror/CodeMirror/blob/master/mode/perl/perl.js
+
+'use strict';
+
+(() => {
+	CodeMirror.defineMode("PG",function(){
+		// http://perldoc.perl.org
+		const PERL={					//   null - magic touch
+								//   1 - keyword
+								//   2 - def
+								//   3 - atom
+								//   4 - operator
+								//   5 - variable-2 (predefined)
+								//   [x,y] - x=1,2,3; y=must be defined if x{...}
+							//	PERL operators
+			'->'				:   4,
+			'++'				:   4,
+			'--'				:   4,
+			'**'				:   4,
+								//   ! ~ \ and unary + and -
+			'=~'				:   4,
+			'!~'				:   4,
+			'*'				:   4,
+			'/'				:   4,
+			'%'				:   4,
+			'x'				:   4,
+			'+'				:   4,
+			'-'				:   4,
+			'.'				:   4,
+			'<<'				:   4,
+			'>>'				:   4,
+								//   named unary operators
+			'<'				:   4,
+			'>'				:   4,
+			'<='				:   4,
+			'>='				:   4,
+			'lt'				:   4,
+			'gt'				:   4,
+			'le'				:   4,
+			'ge'				:   4,
+			'=='				:   4,
+			'!='				:   4,
+			'<=>'				:   4,
+			'eq'				:   4,
+			'ne'				:   4,
+			'cmp'				:   4,
+			'~~'				:   4,
+			'&'				:   4,
+			'|'				:   4,
+			'^'				:   4,
+			'&&'				:   4,
+			'||'				:   4,
+			'//'				:   4,
+			'..'				:   4,
+			'...'				:   4,
+			'?'				:   4,
+			':'				:   4,
+			'='				:   4,
+			'+='				:   4,
+			'-='				:   4,
+			'*='				:   4,	//   etc. ???
+			','				:   4,
+			'=>'				:   4,
+			'::'				:   4,
+								//   list operators (rightward)
+			'not'				:   4,
+			'and'				:   4,
+			'or'				:   4,
+			'xor'				:   4,
+							//	PERL predefined variables (I know, what this is a paranoid idea, but may be needed for people, who learn PERL, and for me as well, ...and may be for you?;)
+			'BEGIN'				:   [5,1],
+			'END'				:   [5,1],
+			'PRINT'				:   [5,1],
+			'PRINTF'			:   [5,1],
+			'GETC'				:   [5,1],
+			'READ'				:   [5,1],
+			'READLINE'			:   [5,1],
+			'DESTROY'			:   [5,1],
+			'TIE'				:   [5,1],
+			'TIEHANDLE'			:   [5,1],
+			'UNTIE'				:   [5,1],
+			'STDIN'				:    5,
+			'STDIN_TOP'			:    5,
+			'STDOUT'			:    5,
+			'STDOUT_TOP'			:    5,
+			'STDERR'			:    5,
+			'STDERR_TOP'			:    5,
+			'$ARG'				:    5,
+			'$_'				:    5,
+			'@ARG'				:    5,
+			'@_'				:    5,
+			'$LIST_SEPARATOR'		:    5,
+			'$"'				:    5,
+			'$PROCESS_ID'			:    5,
+			'$PID'				:    5,
+			'$$'				:    5,
+			'$REAL_GROUP_ID'		:    5,
+			'$GID'				:    5,
+			'$('				:    5,
+			'$EFFECTIVE_GROUP_ID'		:    5,
+			'$EGID'				:    5,
+			'$)'				:    5,
+			'$PROGRAM_NAME'			:    5,
+			'$0'				:    5,
+			'$SUBSCRIPT_SEPARATOR'		:    5,
+			'$SUBSEP'			:    5,
+			'$;'				:    5,
+			'$REAL_USER_ID'			:    5,
+			'$UID'				:    5,
+			'$<'				:    5,
+			'$EFFECTIVE_USER_ID'		:    5,
+			'$EUID'				:    5,
+			'$>'				:    5,
+//			'$a'				:    5,
+//			'$b'				:    5,
+			'$COMPILING'			:    5,
+			'$^C'				:    5,
+			'$DEBUGGING'			:    5,
+			'$^D'				:    5,
+			'${^ENCODING}'			:    5,
+			'$ENV'				:    5,
+			'%ENV'				:    5,
+			'$SYSTEM_FD_MAX'		:    5,
+			'$^F'				:    5,
+			'@F'				:    5,
+			'${^GLOBAL_PHASE}'		:    5,
+			'$^H'				:    5,
+			'%^H'				:    5,
+			'@INC'				:    5,
+			'%INC'				:    5,
+			'$INPLACE_EDIT'			:    5,
+			'$^I'				:    5,
+			'$^M'				:    5,
+			'$OSNAME'			:    5,
+			'$^O'				:    5,
+			'${^OPEN}'			:    5,
+			'$PERLDB'			:    5,
+			'$^P'				:    5,
+			'$SIG'				:    5,
+			'%SIG'				:    5,
+			'$BASETIME'			:    5,
+			'$^T'				:    5,
+			'${^TAINT}'			:    5,
+			'${^UNICODE}'			:    5,
+			'${^UTF8CACHE}'			:    5,
+			'${^UTF8LOCALE}'		:    5,
+			'$PERL_VERSION'			:    5,
+			'$^V'				:    5,
+			'${^WIN32_SLOPPY_STAT}'		:    5,
+			'$EXECUTABLE_NAME'		:    5,
+			'$^X'				:    5,
+			'$1'				:    5, // - regexp $1, $2...
+			'$MATCH'			:    5,
+			'$&'				:    5,
+			'${^MATCH}'			:    5,
+			'$PREMATCH'			:    5,
+			'$`'				:    5,
+			'${^PREMATCH}'			:    5,
+			'$POSTMATCH'			:    5,
+			"$'"				:    5,
+			'${^POSTMATCH}'			:    5,
+			'$LAST_PAREN_MATCH'		:    5,
+			'$+'				:    5,
+			'$LAST_SUBMATCH_RESULT'		:    5,
+			'$^N'				:    5,
+			'@LAST_MATCH_END'		:    5,
+			'@+'				:    5,
+			'%LAST_PAREN_MATCH'		:    5,
+			'%+'				:    5,
+			'@LAST_MATCH_START'		:    5,
+			'@-'				:    5,
+			'%LAST_MATCH_START'		:    5,
+			'%-'				:    5,
+			'$LAST_REGEXP_CODE_RESULT'	:    5,
+			'$^R'				:    5,
+			'${^RE_DEBUG_FLAGS}'		:    5,
+			'${^RE_TRIE_MAXBUF}'		:    5,
+			'$ARGV'				:    5,
+			'@ARGV'				:    5,
+			'ARGV'				:    5,
+			'ARGVOUT'			:    5,
+			'$OUTPUT_FIELD_SEPARATOR'	:    5,
+			'$OFS'				:    5,
+			'$,'				:    5,
+			'$INPUT_LINE_NUMBER'		:    5,
+			'$NR'				:    5,
+			'$.'				:    5,
+			'$INPUT_RECORD_SEPARATOR'	:    5,
+			'$RS'				:    5,
+			'$/'				:    5,
+			'$OUTPUT_RECORD_SEPARATOR'	:    5,
+			'$ORS'				:    5,
+			'$\\'				:    5,
+			'$OUTPUT_AUTOFLUSH'		:    5,
+			'$|'				:    5,
+			'$ACCUMULATOR'			:    5,
+			'$^A'				:    5,
+			'$FORMAT_FORMFEED'		:    5,
+			'$^L'				:    5,
+			'$FORMAT_PAGE_NUMBER'		:    5,
+			'$%'				:    5,
+			'$FORMAT_LINES_LEFT'		:    5,
+			'$-'				:    5,
+			'$FORMAT_LINE_BREAK_CHARACTERS' :    5,
+			'$:'				:    5,
+			'$FORMAT_LINES_PER_PAGE'	:    5,
+			'$='				:    5,
+			'$FORMAT_TOP_NAME'		:    5,
+			'$^'				:    5,
+			'$FORMAT_NAME'			:    5,
+			'$~'				:    5,
+			'${^CHILD_ERROR_NATIVE}'	:    5,
+			'$EXTENDED_OS_ERROR'		:    5,
+			'$^E'				:    5,
+			'$EXCEPTIONS_BEING_CAUGHT'	:    5,
+			'$^S'				:    5,
+			'$WARNING'			:    5,
+			'$^W'				:    5,
+			'${^WARNING_BITS}'		:    5,
+			'$OS_ERROR'			:    5,
+			'$ERRNO'			:    5,
+			'$!'				:    5,
+			'%OS_ERROR'			:    5,
+			'%ERRNO'			:    5,
+			'%!'				:    5,
+			'$CHILD_ERROR'			:    5,
+			'$?'				:    5,
+			'$EVAL_ERROR'			:    5,
+			'$@'				:    5,
+			'$OFMT'				:    5,
+			'$#'				:    5,
+			'$*'				:    5,
+			'$ARRAY_BASE'			:    5,
+			'$['				:    5,
+			'$OLD_PERL_VERSION'		:    5,
+			'$]'				:    5,
+							//	PERL blocks
+			'if'				:[1,1],
+			elsif				:[1,1],
+			'else'				:[1,1],
+			'while'				:[1,1],
+			unless				:[1,1],
+			until				:[1,1],
+			'for'				:[1,1],
+			foreach				:[1,1],
+							//	PERL functions
+			'abs'				:1,	// - absolute value function
+			accept				:1,	// - accept an incoming socket connect
+			alarm				:1,	// - schedule a SIGALRM
+			'atan2'				:1,	// - arctangent of Y/X in the range -PI to PI
+			bind				:1,	// - binds an address to a socket
+			binmode				:1,	// - prepare binary files for I/O
+			bless				:1,	// - create an object
+			bootstrap			:1,	//
+			'break'				:1,	// - break out of a "given" block
+			caller				:1,	// - get context of the current subroutine call
+			chdir				:1,	// - change your current working directory
+			chmod				:1,	// - changes the permissions on a list of files
+			chomp				:1,	// - remove a trailing record separator from a string
+			chop				:1,	// - remove the last character from a string
+			chown				:1,	// - change the ownership on a list of files
+			chr				:1,	// - get character this number represents
+			chroot				:1,	// - make directory new root for path lookups
+			close				:1,	// - close file (or pipe or socket) handle
+			closedir			:1,	// - close directory handle
+			connect				:1,	// - connect to a remote socket
+			'continue'			:[1,1], // - optional trailing block in a while or foreach
+			'cos'				:1,	// - cosine function
+			crypt				:1,	// - one-way passwd-style encryption
+			dbmclose			:1,	// - breaks binding on a tied dbm file
+			dbmopen				:1,	// - create binding on a tied dbm file
+			'default'			:1,	//
+			defined				:1,	// - test whether a value, variable, or function is defined
+			'delete'			:1,	// - deletes a value from a hash
+			die				:1,	// - raise an exception or bail out
+			'do'				:1,	// - turn a BLOCK into a TERM
+			dump				:1,	// - create an immediate core dump
+			each				:1,	// - retrieve the next key/value pair from a hash
+			endgrent			:1,	// - be done using group file
+			endhostent			:1,	// - be done using hosts file
+			endnetent			:1,	// - be done using networks file
+			endprotoent			:1,	// - be done using protocols file
+			endpwent			:1,	// - be done using passwd file
+			endservent			:1,	// - be done using services file
+			eof				:1,	// - test a filehandle for its end
+			'eval'				:1,	// - catch exceptions or compile and run code
+			'exec'				:1,	// - abandon this program to run another
+			exists				:1,	// - test whether a hash key is present
+			exit				:1,	// - terminate this program
+			'exp'				:1,	// - raise I to a power
+			fcntl				:1,	// - file control system call
+			fileno				:1,	// - return file descriptor from filehandle
+			flock				:1,	// - lock an entire file with an advisory lock
+			fork				:1,	// - create a new process just like this one
+			format				:1,	// - declare a picture format with use by the write() function
+			formline			:1,	// - internal function used for formats
+			getc				:1,	// - get the next character from the filehandle
+			getgrent			:1,	// - get next group record
+			getgrgid			:1,	// - get group record given group user ID
+			getgrnam			:1,	// - get group record given group name
+			gethostbyaddr			:1,	// - get host record given its address
+			gethostbyname			:1,	// - get host record given name
+			gethostent			:1,	// - get next hosts record
+			getlogin			:1,	// - return who logged in at this tty
+			getnetbyaddr			:1,	// - get network record given its address
+			getnetbyname			:1,	// - get networks record given name
+			getnetent			:1,	// - get next networks record
+			getpeername			:1,	// - find the other end of a socket connection
+			getpgrp				:1,	// - get process group
+			getppid				:1,	// - get parent process ID
+			getpriority			:1,	// - get current nice value
+			getprotobyname			:1,	// - get protocol record given name
+			getprotobynumber		:1,	// - get protocol record numeric protocol
+			getprotoent			:1,	// - get next protocols record
+			getpwent			:1,	// - get next passwd record
+			getpwnam			:1,	// - get passwd record given user login name
+			getpwuid			:1,	// - get passwd record given user ID
+			getservbyname			:1,	// - get services record given its name
+			getservbyport			:1,	// - get services record given numeric port
+			getservent			:1,	// - get next services record
+			getsockname			:1,	// - retrieve the sockaddr for a given socket
+			getsockopt			:1,	// - get socket options on a given socket
+			given				:1,	//
+			glob				:1,	// - expand filenames using wildcards
+			gmtime				:1,	// - convert UNIX time into record or string using Greenwich time
+			'goto'				:1,	// - create spaghetti code
+			grep				:1,	// - locate elements in a list test true against a given criterion
+			hex				:1,	// - convert a string to a hexadecimal number
+			'import'			:1,	// - patch a module's namespace into your own
+			index				:1,	// - find a substring within a string
+			'int'				:1,	// - get the integer portion of a number
+			ioctl				:1,	// - system-dependent device control system call
+			'join'				:1,	// - join a list into a string using a separator
+			keys				:1,	// - retrieve list of indices from a hash
+			kill				:1,	// - send a signal to a process or process group
+			last				:1,	// - exit a block prematurely
+			lc				:1,	// - return lower-case version of a string
+			lcfirst				:1,	// - return a string with just the next letter in lower case
+			length				:1,	// - return the number of bytes in a string
+			'link'				:1,	// - create a hard link in the filesystem
+			listen				:1,	// - register your socket as a server
+			local				: 2,	// - create a temporary value for a global variable (dynamic scoping)
+			localtime			:1,	// - convert UNIX time into record or string using local time
+			lock				:1,	// - get a thread lock on a variable, subroutine, or method
+			'log'				:1,	// - retrieve the natural logarithm for a number
+			lstat				:1,	// - stat a symbolic link
+			m				:null,	// - match a string with a regular expression pattern
+			map				:1,	// - apply a change to a list to get back a new list with the changes
+			mkdir				:1,	// - create a directory
+			msgctl				:1,	// - SysV IPC message control operations
+			msgget				:1,	// - get SysV IPC message queue
+			msgrcv				:1,	// - receive a SysV IPC message from a message queue
+			msgsnd				:1,	// - send a SysV IPC message to a message queue
+			my				: 2,	// - declare and assign a local variable (lexical scoping)
+			'new'				:1,	//
+			next				:1,	// - iterate a block prematurely
+			no				:1,	// - unimport some module symbols or semantics at compile time
+			oct				:1,	// - convert a string to an octal number
+			open				:1,	// - open a file, pipe, or descriptor
+			opendir				:1,	// - open a directory
+			ord				:1,	// - find a character's numeric representation
+			our				: 2,	// - declare and assign a package variable (lexical scoping)
+			pack				:1,	// - convert a list into a binary representation
+			'package'			:1,	// - declare a separate global namespace
+			pipe				:1,	// - open a pair of connected filehandles
+			pop				:1,	// - remove the last element from an array and return it
+			pos				:1,	// - find or set the offset for the last/next m//g search
+			print				:1,	// - output a list to a filehandle
+			printf				:1,	// - output a formatted list to a filehandle
+			prototype			:1,	// - get the prototype (if any) of a subroutine
+			push				:1,	// - append one or more elements to an array
+			q				:null,	// - singly quote a string
+			qq				:null,	// - doubly quote a string
+			qr				:null,	// - Compile pattern
+			quotemeta			:null,	// - quote regular expression magic characters
+			qw				:null,	// - quote a list of words
+			qx				:null,	// - backquote quote a string
+			rand				:1,	// - retrieve the next pseudorandom number
+			read				:1,	// - fixed-length buffered input from a filehandle
+			readdir				:1,	// - get a directory from a directory handle
+			readline			:1,	// - fetch a record from a file
+			readlink			:1,	// - determine where a symbolic link is pointing
+			readpipe			:1,	// - execute a system command and collect standard output
+			recv				:1,	// - receive a message over a Socket
+			redo				:1,	// - start this loop iteration over again
+			ref				:1,	// - find out the type of thing being referenced
+			rename				:1,	// - change a filename
+			require				:1,	// - load in external functions from a library at runtime
+			reset				:1,	// - clear all variables of a given name
+			'return'			:1,	// - get out of a function early
+			reverse				:1,	// - flip a string or a list
+			rewinddir			:1,	// - reset directory handle
+			rindex				:1,	// - right-to-left substring search
+			rmdir				:1,	// - remove a directory
+			s				:null,	// - replace a pattern with a string
+			say				:1,	// - print with newline
+			scalar				:1,	// - force a scalar context
+			seek				:1,	// - reposition file pointer for random-access I/O
+			seekdir				:1,	// - reposition directory pointer
+			select				:1,	// - reset default output or do I/O multiplexing
+			semctl				:1,	// - SysV semaphore control operations
+			semget				:1,	// - get set of SysV semaphores
+			semop				:1,	// - SysV semaphore operations
+			send				:1,	// - send a message over a socket
+			setgrent			:1,	// - prepare group file for use
+			sethostent			:1,	// - prepare hosts file for use
+			setnetent			:1,	// - prepare networks file for use
+			setpgrp				:1,	// - set the process group of a process
+			setpriority			:1,	// - set a process's nice value
+			setprotoent			:1,	// - prepare protocols file for use
+			setpwent			:1,	// - prepare passwd file for use
+			setservent			:1,	// - prepare services file for use
+			setsockopt			:1,	// - set some socket options
+			shift				:1,	// - remove the first element of an array, and return it
+			shmctl				:1,	// - SysV shared memory operations
+			shmget				:1,	// - get SysV shared memory segment identifier
+			shmread				:1,	// - read SysV shared memory
+			shmwrite			:1,	// - write SysV shared memory
+			shutdown			:1,	// - close down just half of a socket connection
+			'sin'				:1,	// - return the sine of a number
+			sleep				:1,	// - block for some number of seconds
+			socket				:1,	// - create a socket
+			socketpair			:1,	// - create a pair of sockets
+			'sort'				:1,	// - sort a list of values
+			splice				:1,	// - add or remove elements anywhere in an array
+			'split'				:1,	// - split up a string using a regexp delimiter
+			sprintf				:1,	// - formatted print into a string
+			'sqrt'				:1,	// - square root function
+			srand				:1,	// - seed the random number generator
+			stat				:1,	// - get a file's status information
+			state				:1,	// - declare and assign a state variable (persistent lexical scoping)
+			study				:1,	// - optimize input data for repeated searches
+			'sub'				:1,	// - declare a subroutine, possibly anonymously
+			'substr'			:1,	// - get or alter a portion of a string
+			symlink				:1,	// - create a symbolic link to a file
+			syscall				:1,	// - execute an arbitrary system call
+			sysopen				:1,	// - open a file, pipe, or descriptor
+			sysread				:1,	// - fixed-length unbuffered input from a filehandle
+			sysseek				:1,	// - position I/O pointer on handle used with sysread and syswrite
+			system				:1,	// - run a separate program
+			syswrite			:1,	// - fixed-length unbuffered output to a filehandle
+			tell				:1,	// - get current seekpointer on a filehandle
+			telldir				:1,	// - get current seekpointer on a directory handle
+			tie				:1,	// - bind a variable to an object class
+			tied				:1,	// - get a reference to the object underlying a tied variable
+			time				:1,	// - return number of seconds since 1970
+			times				:1,	// - return elapsed time for self and child processes
+			tr				:null,	// - transliterate a string
+			truncate			:1,	// - shorten a file
+			uc				:1,	// - return upper-case version of a string
+			ucfirst				:1,	// - return a string with just the next letter in upper case
+			umask				:1,	// - set file creation mode mask
+			undef				:1,	// - remove a variable or function definition
+			unlink				:1,	// - remove one link to a file
+			unpack				:1,	// - convert binary structure into normal perl variables
+			unshift				:1,	// - prepend more elements to the beginning of a list
+			untie				:1,	// - break a tie binding to a variable
+			use				:1,	// - load in a module at compile time
+			utime				:1,	// - set a file's last access and modify times
+			values				:1,	// - return a list of the values in a hash
+			vec				:1,	// - test or set particular bits in a string
+			wait				:1,	// - wait for any child process to die
+			waitpid				:1,	// - wait for a particular child process to die
+			wantarray			:1,	// - get void vs scalar vs list context of current subroutine call
+			warn				:1,	// - print debugging info
+			when				:1,	//
+			write				:1,	// - print a picture record
+			y				:null,	// - transliterate a string
+		};
+		//	PG Keywords and Variables
+		const PGstyle = 'atom';
+		const PGkeyword = 'keyword';
+		const PGcmds = new Set([
+			'DOCUMENT',
+			'ENDDOCUMENT',
+			'loadMacros',
+			'TEXT',
+			'SOLUTION',
+			'HINT',
+			'STATEMENT',
+			'COMMENT',
+			'MODES',
+			'htmlLink',
+			'helpLink',
+			'knowlLink',
+			'image',
+			'Context',
+			'Compute',
+			'Real',
+			'Formula',
+			'String',
+			'List',
+			'Complex',
+			'Point',
+			'Vector',
+			'Matrix',
+			'Interval',
+			'Set',
+			'Fraction',
+			'ANS',
+			'NAMED_ANS',
+			'WEIGHTED_ANS',
+			'MultiAnswer',
+			'Value',
+			'random',
+			'list_random',
+			'non_zero_random',
+			'NchooseK',
+		]);
+		const PGvars = new Set([
+			'BR',
+			'RBR',
+			'PAR',
+			'LQ',
+			'RQ',
+			'BM',
+			'EM',
+			'BDM',
+			'EDM',
+			'LTS',
+			'GTS',
+			'LTE',
+			'GTE',
+			'BEGIN_ONE_COLUMN',
+			'END_ONE_COLUMN',
+			'SOL',
+			'SOLUTION',
+			'HINT',
+			'COMMENT',
+			'US',
+			'SPACE',
+			'NBSP',
+			'NDASH',
+			'MDASH',
+			'BLABEL',
+			'ELABEL',
+			'BBOLD',
+			'EBOLD',
+			'BITALIC',
+			'EITALIC',
+			'BUL',
+			'EUL',
+			'BCENTER',
+			'ECENTER',
+			'BLTR',
+			'ELTR',
+			'BKBD',
+			'EKBD',
+			'HR',
+			'LBRACE',
+			'RBRACE',
+			'LB',
+			'RB',
+			'DOLLAR',
+			'PERCENT',
+			'CARET',
+			'PI',
+			'E',
+			'LATEX',
+			'TEX',
+			'APOS',
+			'showPartialCorrectAnswers',
+			'refreshCachedImages',
+			'ITEM',
+			'ITEMSEP'
+		]);
+
+		const RXstyle="string-2";
+		const RXmodifiers=/[goseximacplud]/;		// NOTE: "m", "s", "y" and "tr" need to correct real modifiers for each regexp type
+
+		function tokenChain(stream,state,chain,style,tail,tokener){	// NOTE: chain.length > 2 is not working now (it's for s[...][...]geos;)
+			state.chain=null;				//							    12	 3tail
+			state.style=null;
+			state.tail=null;
+			state.tokenize=function(stream,state){
+				var e=false,c,i=0;
+				while(c=stream.next()){
+					if(c===chain[i]&&!e){
+						if(chain[++i]!==undefined){
+							state.chain=chain[i];
+							state.style=style;
+							state.tail=tail;}
+						else if(tail)
+							stream.eatWhile(tail);
+						state.tokenize=tokener || tokenPerl;
+						return style;}
+					e=!e&&c=="\\";}
+				return style;};
+			return state.tokenize(stream,state);}
+
+		function tokenSOMETHING(stream,state,string){
+			state.tokenize=function(stream,state){
+				if(stream.string==string)
+					state.tokenize=tokenPerl;
+				stream.skipToEnd();
+				return "string";};
+			return state.tokenize(stream,state);}
+
+		// EV3 block formatting
+		function tokenEV3(stream,state,string,style,prevState){
+			state.tokenize = function(stream,state) {
+				if (prevState && prevState.mode == "math") {
+					var reg = new RegExp("^\\\\"+string);
+				} else {
+					var reg = new RegExp("^"+string);
+				}
+				if (stream.match(reg)) {
+					if (!prevState) {
+						state.tokenize = tokenPerl;
+						return PGstyle;
+					} else {
+						state.tokenize = function(stream,state) {
+							return tokenEV3(stream,state,prevState.string,
+								prevState.style,prevState.prevState);
+						}
+					}
+					if (string.includes("BOLD"))
+						return PGstyle + " strong";
+					if (string.includes("ITALIC"))
+						return PGstyle + " em";
+					if (prevState.endstyle)
+						return prevState.endstyle;
+					return style;
+				} else {
+					state.tokenize = function(stream,state) {
+						return tokenEV3(stream,state,string,style,prevState);
+					}
+				}
+
+				const newPrevState = {};
+				if (prevState) {
+					newPrevState.prevState = JSON.parse(JSON.stringify(prevState));
+				} else {
+					newPrevState.prevState = null;
+				}
+				newPrevState.style = style;
+				newPrevState.string = string;
+
+				if (prevState && prevState.mode == "cmd") { // Some additional formatting for perl code blocks
+					newPrevState.mode = "cmd";
+					if (stream.match(/^[$@%]{/)) { // ${, @{, %{ nested blocks
+						style = "variable";
+						state.tokenize = function(stream,state) {
+							return tokenEV3(stream,state,"\\}",style,newPrevState);
+						}
+						return style;
+					}
+					if (stream.match(/^\(/)) { // Nested ( ) blocks
+						newPrevState.endstyle = "variable";
+						state.tokenize = function(stream,state) {
+							return tokenEV3(stream,state,"\\)",style,newPrevState);
+						}
+						return "variable";
+					}
+					if (stream.match(/^\[/)) { // Nested [ ] blocks
+						newPrevState.endstyle = "variable";
+						state.tokenize = function(stream,state) {
+							return tokenEV3(stream,state,"\\]",style,newPrevState);
+						}
+						return "variable";
+					}
+					if (stream.match(/^\{/)) { // Nested { } blocks
+						newPrevState.endstyle = "variable";
+						state.tokenize = function(stream,state) {
+							return tokenEV3(stream,state,"\\}",style,newPrevState);
+						}
+						return "variable";
+					}
+					if (stream.match(/^\w+/)) { // Check for PG keywords
+						if (PGcmds.has(stream.current()))
+							return PGkeyword;
+						else
+							return style;
+					}
+					if (stream.match(/^['"]/)) { // Quotes
+						return tokenChain(stream,state,[stream.current()],"string",null,function(stream,state) {
+							tokenEV3(stream,state,string,style,prevState) });
+					}
+					if (stream.match(/^[=,;/\*><%&|.~?:+/-]/)) { // Catch some perl operators
+						return "variable";
+					}
+				}
+
+				if (stream.match(/^\\\(/)) { // \(...\) TeX block
+					if (prevState) {
+						style = "error";
+					} else {
+						style = "comment";
+					}
+					state.tokenize = function(stream,state) {
+						newPrevState.mode = "math";
+						return tokenEV3(stream,state,"\\)",style,newPrevState);
+					}
+				} else if (stream.match(/^\\\[/)) { // \[...\] TeX block
+					if (prevState) {
+						style = "error";
+					} else {
+						style = "comment";
+					}
+					state.tokenize = function(stream,state) {
+						newPrevState.mode = "math";
+						return tokenEV3(stream,state,"\\]",style,newPrevState);
+					}
+				} else if (stream.match(/^\\{/)) { // \{...\} Perl code block
+					if (prevState) {
+						style = "error";
+					} else {
+						style = "variable-2";
+					}
+					state.tokenize = function(stream,state) {
+						newPrevState.mode = "cmd";
+						return tokenEV3(stream,state,"\\\\}",style,newPrevState);
+					}
+				} else if (stream.match(/^``/)) { // ``...`` math object math
+					if (prevState && prevState.mode != "math") {
+						style = "error";
+					} else {
+						style = "variable-3";
+					}
+					state.tokenize = function(stream,state) {
+						return tokenEV3(stream,state,"``",style,newPrevState);
+					}
+				} else if (stream.match(/^`/)) { // `...` math object math
+					if (prevState && prevState.mode != "math") {
+						style = "error";
+					} else {
+						style = "variable-3";
+					}
+					state.tokenize = function(stream,state) {
+						return tokenEV3(stream,state,"`([^`]|$)",style,newPrevState,"tick");
+					}
+				} else if (stream.match(/^(\$BBOLD|\${BBOLD})/)) { // Bold
+					style = style = " strong";
+					state.tokenize = function(stream,state) {
+						return tokenEV3(stream,state,"(\\$EBOLD|\\${EBOLD})",style,newPrevState);
+					}
+					return PGstyle + " strong";
+				} else if (stream.match(/^(\$BITALIC|\${BITALIC})/)) { // Italic
+					style = style + " em";
+					state.tokenize = function(stream,state) {
+						return tokenEV3(stream,state,"(\\$EITALIC|\\${EITALIC})",style,newPrevState);
+					}
+					return PGstyle + " em";
+				} else if (stream.match(/^[$@%]\w+/)) { // PG Variables
+					if (PGvars.has(stream.current().substring(1)))
+						return PGstyle;
+					return "variable";
+				} else if (stream.match(/^[$@%]{\w+}/)) { // ${foo} PG variables
+					if (PGvars.has(stream.current().slice(2,-1)))
+						return PGstyle;
+					return "variable";
+				} else if (stream.match(/^ +$/)) { // Trailing white space
+					return "trailingspace";
+				} else if (stream.match(/^[\[\]\\ (){}$@%`]/)) { // Advance a single character if special
+					return style;
+				} else { // Otherwise advance through all non special characters
+					if (prevState && prevState.mode == "cmd") { // Only eat through words in perl code mode
+						if (stream.match(/\w+/))
+							return style;
+						else
+							stream.next();
+					} else {
+						stream.eatWhile(/[^\[\]\\ (){}$@%`]/);
+					}
+				}
+				return style;
+			}
+			return state.tokenize(stream,state);
+		}
+
+		// No additional formatting inside comment block, only looks for end string.
+		// Currently only used for comments and ``` code blocks.
+		// The final stream.match and stream.eatWhile may need updated if used for other blocks.
+		function tokenPGMLComment(stream,state,string,style,prevState){
+			state.tokenize = function(stream,state) {
+				var reg = new RegExp("^"+string);
+				if (stream.match(reg)) {
+					state.tokenize = function(stream,state) {
+						return tokenPGML(stream,state,prevState.string,
+							prevState.style,prevState.prevState);
+					}
+					return style;
+				} else {
+					state.tokenize = function(stream,state) {
+						return tokenPGMLComment(stream,state,string,style,prevState);
+					}
+				}
+				if (stream.match(/^[\]%`]/))
+					return style;
+				stream.eatWhile(/[^\]%`]/);
+				return style;
+			}
+			return state.tokenize(stream,state);
+		}
+
+		// PGML subblock which has limited formatting options compared to main block.
+		// This block nests {} and [] blocks, for correct pairing in variables and commands.
+		function tokenPGMLSubBlock(stream,state,string,style,prevState){
+			state.tokenize = function(stream,state) {
+				var reg = new RegExp("^"+string);
+				if (stream.match(reg)) {
+					// Needed to ensure ':   ' verbatim lines exit out if ended with a secondary subblock.
+					if (stream.eol() && prevState.subblock && prevState.prevState && prevState.prevState.stopeol) {
+						state.tokenize = function(stream,state) {
+							return tokenPGMLSubBlock(stream,state,prevState.prevState.string,
+								prevState.prevState.style,prevState.prevState.prevState);
+						}
+					} else if (stream.eol() && prevState.prevState && prevState.prevState.stopeol) {
+						state.tokenize = function(stream,state) {
+							return tokenPGML(stream,state,prevState.prevState.string,
+								prevState.prevState.style,prevState.prevState.prevState);
+						}
+					} else if (prevState.subblock){
+						state.tokenize = function(stream,state) {
+							return tokenPGMLSubBlock(stream,state,prevState.string,
+								prevState.style,prevState.prevState);
+						}
+					} else {
+						state.tokenize = function(stream,state) {
+							return tokenPGML(stream,state,prevState.string,
+								prevState.style,prevState.prevState);
+						}
+					}
+					if (prevState.mode == "var" || prevState.mode == "cmd")
+						stream.match(/^\*{1,3}([^\*]|$)/);
+					if (prevState.mode == "calc") {
+						if (!stream.match(/^\*(\s|$)/))
+							stream.match(/^\{.+\}/);
+					}
+					if (prevState.endstyle)
+						return prevState.endstyle;
+					return style;
+				} else {
+					state.tokenize = function(stream,state) {
+						return tokenPGMLSubBlock(stream,state,string,style,prevState);
+					}
+				}
+
+				var newPrevState = {};
+				if (prevState) {
+					newPrevState.prevState = JSON.parse(JSON.stringify(prevState));
+				} else {
+					newPrevState.prevState = null;
+				}
+				newPrevState.style = style;
+				newPrevState.string = string;
+				newPrevState.subblock = true;
+				if (prevState.mode)
+					newPrevState.mode = prevState.mode;
+
+				if (prevState.mode == "cmd") { // Some formatting for [@ ... @] blocks
+					if (stream.match(/^[$@%]\w+/)) { // $, @, % variables
+						if (PGvars.has(stream.current().substring(1)))
+							return PGstyle;
+						else
+							return "variable";
+					}
+					if (stream.match(/^[$@%]{\w+}/)) { // ${foo}, @{foo}, %{foo} variables
+						if (PGvars.has(stream.current().slice(2,-1)))
+							return PGstyle;
+						else
+							return "variable";
+					}
+					if (stream.match(/^[$@%]{/)) { // ${, @{, %{ nested blocks
+						style = "variable";
+						state.tokenize = function(stream,state) {
+							return tokenPGMLSubBlock(stream,state,"\\}",style,newPrevState);
+						}
+						return style;
+					}
+					if (stream.match(/^\(/)) { // Nested ( ) blocks
+						newPrevState.endstyle = "variable";
+						state.tokenize = function(stream,state) {
+							return tokenPGMLSubBlock(stream,state,"\\)",style,newPrevState);
+						}
+						return "variable";
+					}
+					if (stream.match(/^\w+/)) { // Check for PG keywords
+						if (PGcmds.has(stream.current()))
+							return PGkeyword;
+						else
+							return style;
+					}
+					if (stream.match(/^['"]/)) { // Quotes
+						return tokenChain(stream,state,[stream.current()],"string",null,function(stream,state) {
+							tokenPGMLSubBlock(stream,state,string,style,prevState) });
+					}
+					if (stream.match(/^[=,;/\*><%$&|.~?:]/)) // Catch some perl operators
+						return "variable";
+				}
+
+				if (stream.match(/^\[\$/)) { // Variable
+					const p = stream.pos;
+					if (stream.match(/^\w+/) && PGvars.has(stream.current().substring(2)) && stream.eat(']')) {
+						stream.match(/^\*{1,3}/);
+						return PGstyle;
+					} else {
+						stream.pos = p;
+					}
+					style = "variable";
+					state.tokenize = function(stream,state) {
+						newPrevState.mode = "var";
+						return tokenPGMLSubBlock(stream,state,"\\]",style,newPrevState);
+					}
+				} else if (stream.match(/^\[/)) { // Nested [ ] blocks
+					if (prevState.mode == "cmd")
+						newPrevState.endstyle = "variable";
+					state.tokenize = function(stream,state) {
+						return tokenPGMLSubBlock(stream,state,"\\]",style,newPrevState);
+					}
+					if (prevState.mode == "cmd")
+						return "variable";
+				} else if (stream.match(/^\{/)) { // Nested { } blocks
+					if (prevState.mode == "cmd")
+						newPrevState.endstyle = "variable";
+					state.tokenize = function(stream,state) {
+						return tokenPGMLSubBlock(stream,state,"\\}",style,newPrevState);
+					}
+					if (prevState.mode == "cmd")
+						return "variable";
+				} else if (stream.match(/^\w+\s*/)) { // Grab next word before going forward
+					return style;
+				} else { // Catchall to advanced one character if no match was found.
+					stream.eat(/./);
+				}
+				return style;
+			}
+			return state.tokenize(stream,state);
+		}
+
+		// Main PGML block. Can nest to allow subblocks with PGML formatting in them.
+		function tokenPGML(stream,state,string,style,prevState){
+			state.tokenize = function(stream,state) {
+				var reg = new RegExp("^"+string);
+				if (stream.match(reg)) {
+					if (!prevState) {
+						state.tokenize = tokenPerl;
+						return PGkeyword;
+					// Needed to ensure ':   ' verbatim lines exit out if ended with a secondary block.
+					} else if (stream.eol() && prevState.prevState && prevState.prevState.stopeol) {
+						state.tokenize = function(stream,state) {
+							return tokenPGML(stream,state,prevState.prevState.string,
+								prevState.prevState.style,prevState.prevState.prevState);
+						}
+					} else {
+						state.tokenize = function(stream,state) {
+							return tokenPGML(stream,state,prevState.string,
+								prevState.style,prevState.prevState);
+						}
+					}
+					return style;
+				} else {
+					state.tokenize = function(stream,state) {
+						return tokenPGML(stream,state,string,style,prevState);
+					}
+				}
+
+				var newPrevState = {};
+				if (prevState) {
+					newPrevState.prevState = JSON.parse(JSON.stringify(prevState));
+				} else {
+					newPrevState.prevState = null;
+				}
+				newPrevState.style = style;
+				newPrevState.string = string;
+
+				if (stream.sol()) {
+					if (stream.match(/^ *(>> +)?[ivxlIVXL]+[.)] /) ||
+							stream.match(/^ *(>> +)?\d+[.)] /) ||
+							stream.match(/^ *(>> +)?\w[.)] /) ||
+							stream.match(/^ *(>> +)?[*\-+o] /)) { // Lists
+						return "atom strong";
+					}
+					if (stream.match(/^ *[\-=]{3,}/)) { // Rules
+						stream.match(/^\{[^}]*\}/);
+						stream.match(/^\{[^}]*\}/);
+						return "hr";
+					}
+					if (stream.match(/^ *(>> +)?#{1,}.*$/)) // Headers
+						return "header";
+					if (stream.match(/^ *>> /)) // Justification
+						return "atom strong";
+					if (stream.match(/^ *:   /)) { // Single line verbatim
+						style = "tag";
+						state.tokenize = function(stream,state) {
+							newPrevState.stopeol = true;
+							return tokenPGML(stream,state,".$",style,newPrevState);
+						}
+						return style;
+					}
+				}
+
+				if (stream.match(/^\[:{1,3}/)) { // Algebra notation math
+					style = "variable-3";
+					const endstring = stream.current().substring(1) + "\\]";
+					state.tokenize = function(stream,state) {
+						newPrevState.mode = "calc";
+						return tokenPGMLSubBlock(stream,state,endstring,style,newPrevState);
+					}
+				} else if (stream.match(/^\[`{1,3}/)) { // TeX notation math
+					style = "comment";
+					const endstring = stream.current().substring(1) + "\\]";
+					state.tokenize = function(stream,state) {
+						newPrevState.mode = "tex";
+						return tokenPGMLSubBlock(stream,state,endstring,style,newPrevState);
+					}
+				} else if (stream.match(/^\[\|+/)) { // Verbatim 
+					style = "tag";
+					const endstring = stream.current().substring(1) + "\\]";
+					state.tokenize = function(stream,state) {
+						return tokenPGML(stream,state,endstring,style,newPrevState);
+					}
+				} else if (!prevState && stream.match(/^```/)) { // Multiline verbatim / code
+					style = "tag";
+					state.tokenize = function(stream,state) {
+						return tokenPGMLComment(stream,state,"```",style,newPrevState);
+					}
+				} else if (stream.match(/^\[%/)) { // Comment
+					style = "bracket";
+					state.tokenize = function(stream,state) {
+						return tokenPGMLComment(stream,state,"%\\]",style,newPrevState);
+					}
+				} else if (stream.match(/^\[@/)) { // Perl code
+					style = "variable-2";
+					state.tokenize = function(stream,state) {
+						newPrevState.mode = "cmd";
+						return tokenPGMLSubBlock(stream,state,"@\\]",style,newPrevState);
+					}
+				} else if (stream.match(/^\[\$/)) { // Variable
+					const p = stream.pos;
+					if (stream.match(/^[\w\d_]+/) && PGvars.has(stream.current().substring(2)) && stream.eat(']')) {
+						stream.match(/^\*{1,3}/);
+						return PGstyle;
+					} else {
+						stream.pos = p;
+					}
+					style = "variable";
+					state.tokenize = function(stream,state) {
+						newPrevState.mode = "var";
+						return tokenPGMLSubBlock(stream,state,"\\]",style,newPrevState);
+					}
+				} else if (stream.match(/^\[_+\]/)) { // Answer blank
+					if (stream.match(/^\*?\{/)) {
+						state.tokenize = function(stream,state) {
+							return tokenPGMLSubBlock(stream,state,"\\}","builtin",newPrevState);
+						}
+					}
+					return "builtin";
+				} else if (stream.match(/<< *$/)) { // Justification
+					return "atom strong";
+				} else if (stream.match(/^(\*_|_\*)\w/)) { // Bold and italic
+					style = style + " strong em";
+					const endstring = (stream.current().charAt(1) + stream.current().charAt(0)).replace(/\*/, "\\*");
+					state.tokenize = function(stream,state) {
+						return tokenPGML(stream,state,endstring,style,newPrevState);
+					}
+				} else if (stream.match(/^\*{1,3}\w/)) { // Bold
+					style = style + " strong";
+					const endstring = stream.current().slice(0,-1).replace(/\*/g, "\\*");
+					state.tokenize = function(stream,state) {
+						return tokenPGML(stream,state,endstring,style,newPrevState);
+					}
+				} else if (stream.match(/^_{1,3}\w/)) { // Italic
+					style = style + " em";
+					const endstring = stream.current().slice(0,-1);
+					state.tokenize = function(stream,state) {
+						return tokenPGML(stream,state,endstring,style,newPrevState);
+					}
+				} else if (stream.match(/^ +$/)) { // Trailing whitespace
+					return "trailingspace";
+				} else if (stream.match(/[A-Za-z0-9]+\s*/)) { // Grab next word before going forward
+					return style;
+				} else { // Catchall to advanced one character if no match was found.
+					stream.eat(/./);
+				}
+				return style;
+			};
+
+			return state.tokenize(stream,state);
+		}
+
+		function tokenPerl(stream,state){
+			if(stream.eatSpace())
+				return null;
+			if(state.chain)
+				return tokenChain(stream,state,state.chain,state.style,state.tail);
+			if(stream.match(/^(\-?((\d[\d_]*)?\.\d+(e[+-]?\d+)?|\d+\.\d*)|0x[\da-fA-F_]+|0b[01_]+|\d[\d_]*(e[+-]?\d+)?)/))
+				return 'number';
+			if(stream.match(/^<<(?=[_a-zA-Z])/)){		       // NOTE: <<SOMETHING\n...\nSOMETHING\n
+				stream.eatWhile(/\w/);
+				return tokenSOMETHING(stream,state,stream.current().substr(2));}
+			if(stream.sol()&&stream.match(/^\=item(?!\w)/)){// NOTE: \n=item...\n=cut\n
+				return tokenSOMETHING(stream,state,'=cut');}
+
+			if(stream.match(/^BEGIN_TEXT\s*$/)) {
+				state.tokenize = function(stream,state) {
+					return tokenEV3(stream,state,"END_TEXT","meta");
+				}
+				return PGkeyword;
+			}
+			if(stream.match(/^BEGIN_HINT\s*$/)) {
+				state.tokenize = function(stream,state) {
+					return tokenEV3(stream,state,"END_HINT","meta");
+				}
+				return PGkeyword;
+			}
+			if(stream.match(/^BEGIN_SOLUTION\s*$/)) {
+				state.tokenize = function(stream,state) {
+					return tokenEV3(stream,state,"END_SOLUTION","meta");
+				}
+				return PGkeyword;
+			}
+			if(stream.match(/^BEGIN_PGML\s*$/)) {
+				state.tokenize = function(stream,state) {
+					return tokenPGML(stream,state,"END_PGML","meta");
+				}
+				return PGkeyword;
+			}
+			if(stream.match(/^BEGIN_PGML_HINT\s*$/)) {
+				state.tokenize = function(stream,state) {
+					return tokenPGML(stream,state,"END_PGML_HINT","meta");
+				}
+				return PGkeyword;
+			}
+			if(stream.match(/^BEGIN_PGML_SOLUTION\s*$/)) {
+				state.tokenize = function(stream,state) {
+					return tokenPGML(stream,state,"END_PGML_SOLUTION","meta");
+				}
+				return PGkeyword;
+			}
+
+			var ch=stream.next();
+			if(ch=='"'||ch=="'"){				// NOTE: ' or " or <<'SOMETHING'\n...\nSOMETHING\n or <<"SOMETHING"\n...\nSOMETHING\n
+				if(prefix(stream, 3)=="<<"+ch){
+					var p=stream.pos;
+					stream.eatWhile(/\w/);
+					var n=stream.current().substr(1);
+					if(n&&stream.eat(ch))
+						return tokenSOMETHING(stream,state,n);
+					stream.pos=p;}
+				return tokenChain(stream,state,[ch],"string");}
+			if(ch=="q"){
+				var c=look(stream, -2);
+				if(!(c&&/\w/.test(c))){
+					c=look(stream, 0);
+					if(c=="x"){
+						c=look(stream, 1);
+						if(c=="("){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
+						if(c=="["){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
+						if(c=="{"){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
+						if(c=="<"){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}
+						if(/[\^'"!~\/]/.test(c)){
+							eatSuffix(stream, 1);
+							return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers);}}
+					else if(c=="q"){
+						c=look(stream, 1);
+						if(c=="("){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,[")"],"string");}
+						if(c=="["){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,["]"],"string");}
+						if(c=="{"){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,["}"],"string");}
+						if(c=="<"){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,[">"],"string");}
+						if(/[\^'"!~\/]/.test(c)){
+							eatSuffix(stream, 1);
+							return tokenChain(stream,state,[stream.eat(c)],"string");}}
+					else if(c=="w"){
+						c=look(stream, 1);
+						if(c=="("){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,[")"],"bracket");}
+						if(c=="["){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,["]"],"bracket");}
+						if(c=="{"){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,["}"],"bracket");}
+						if(c=="<"){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,[">"],"bracket");}
+						if(/[\^'"!~\/]/.test(c)){
+							eatSuffix(stream, 1);
+							return tokenChain(stream,state,[stream.eat(c)],"bracket");}}
+					else if(c=="r"){
+						c=look(stream, 1);
+						if(c=="("){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
+						if(c=="["){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
+						if(c=="{"){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
+						if(c=="<"){
+							eatSuffix(stream, 2);
+							return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}
+						if(/[\^'"!~\/]/.test(c)){
+							eatSuffix(stream, 1);
+							return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers);}}
+					else if(/[\^'"!~\/(\[{<]/.test(c)){
+						if(c=="("){
+							eatSuffix(stream, 1);
+							return tokenChain(stream,state,[")"],"string");}
+						if(c=="["){
+							eatSuffix(stream, 1);
+							return tokenChain(stream,state,["]"],"string");}
+						if(c=="{"){
+							eatSuffix(stream, 1);
+							return tokenChain(stream,state,["}"],"string");}
+						if(c=="<"){
+							eatSuffix(stream, 1);
+							return tokenChain(stream,state,[">"],"string");}
+						if(/[\^'"!~\/]/.test(c)){
+							return tokenChain(stream,state,[stream.eat(c)],"string");}}}}
+			if(ch=="m"){
+				var c=look(stream, -2);
+				if(!(c&&/\w/.test(c))){
+					c=stream.eat(/[(\[{<\^'"!~\/]/);
+					if(c){
+						if(/[\^'"!~\/]/.test(c)){
+							return tokenChain(stream,state,[c],RXstyle,RXmodifiers);}
+						if(c=="("){
+							return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
+						if(c=="["){
+							return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
+						if(c=="{"){
+							return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
+						if(c=="<"){
+							return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}}}}
+			if(ch=="s"){
+				var c=/[\/>\]})\w]/.test(look(stream, -2));
+				if(!c){
+					c=stream.eat(/[(\[{<\^'"!~\/]/);
+					if(c){
+						if(c=="[")
+							return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
+						if(c=="{")
+							return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
+						if(c=="<")
+							return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
+						if(c=="(")
+							return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
+						return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}
+			if(ch=="y"){
+				var c=/[\/>\]})\w]/.test(look(stream, -2));
+				if(!c){
+					c=stream.eat(/[(\[{<\^'"!~\/]/);
+					if(c){
+						if(c=="[")
+							return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
+						if(c=="{")
+							return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
+						if(c=="<")
+							return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
+						if(c=="(")
+							return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
+						return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}
+			if(ch=="t"){
+				var c=/[\/>\]})\w]/.test(look(stream, -2));
+				if(!c){
+					c=stream.eat("r");if(c){
+					c=stream.eat(/[(\[{<\^'"!~\/]/);
+					if(c){
+						if(c=="[")
+							return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
+						if(c=="{")
+							return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
+						if(c=="<")
+							return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
+						if(c=="(")
+							return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
+						return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}}
+			if(ch=="`"){
+				return tokenChain(stream,state,[ch],"variable-2");}
+			if(ch=="/"){
+				if(!/~\s*$/.test(prefix(stream)))
+					return "operator";
+				else
+					return tokenChain(stream,state,[ch],RXstyle,RXmodifiers);}
+			if(ch=="$"){
+				var p=stream.pos;
+				if(stream.eatWhile(/\w/)&&PGvars.has(stream.current().substring(1)))
+					return PGstyle;
+				else
+					stream.pos=p;
+				if(stream.eatWhile(/\d/)||stream.eat("{")&&stream.eatWhile(/\d/)&&stream.eat("}"))
+					return "variable-2";
+				else
+					stream.pos=p;}
+			if(/[$@%]/.test(ch)){
+				var p=stream.pos;
+				if(stream.eat("^")&&stream.eat(/[A-Z]/)||!/[@$%&]/.test(look(stream, -2))&&stream.eat(/[=|\\\-#?@;:&`~\^!\[\]*'"$+.,\/<>()]/)){
+					var c=stream.current();
+					if(PERL[c])
+						return "variable-2";}
+				stream.pos=p;}
+			if(/[$@%&]/.test(ch)){
+				if(stream.eatWhile(/[\w$]/)||stream.eat("{")&&stream.eatWhile(/[\w$]/)&&stream.eat("}")){
+					var c=stream.current();
+					if(PERL[c])
+						return "variable-2";
+					else
+						return "variable";}}
+			if(ch=="#"){
+				if(look(stream, -2)!="$"){
+					stream.skipToEnd();
+					return "comment";}}
+			if(ch=="-"&&look(stream, -2)!=" "&&stream.match(/>\w+/))
+					return "variable";
+			if(/[:+\-\^*$&%@=<>!?|\/~\.]/.test(ch)){
+				var p=stream.pos;
+				stream.eatWhile(/[:+\-\^*$&%@=<>!?|\/~\.]/);
+				if(PERL[stream.current()])
+					return "operator";
+				else
+					stream.pos=p;}
+			if(ch=="_"){
+				if(stream.pos==1){
+					if(suffix(stream, 6)=="_END__"){
+						return tokenChain(stream,state,['\0'],"comment");}
+					else if(suffix(stream, 7)=="_DATA__"){
+						return tokenChain(stream,state,['\0'],"variable-2");}
+					else if(suffix(stream, 7)=="_C__"){
+						return tokenChain(stream,state,['\0'],"string");}}}
+			if(/\w/.test(ch)){
+				var p=stream.pos;
+				if(look(stream, -2)=="{"&&(look(stream, 0)=="}"||stream.eatWhile(/\w/)&&look(stream, 0)=="}"))
+					return "string";
+				else
+					stream.pos=p;
+				if(stream.match(/\w* *=>/))
+					return "string";}
+			if(/[A-Z]/.test(ch)){
+				var l=look(stream, -2);
+				var p=stream.pos;
+				stream.eatWhile(/[A-Z_]/);
+				if(/[\da-z]/.test(look(stream, 0))){
+					stream.pos=p;}
+				else{
+					var c=PERL[stream.current()];
+					var isPG = PGcmds.has(stream.current());
+					if(!c && !isPG)
+						return "meta";
+					if(isPG)
+						return PGkeyword;
+					if(c[1])
+						c=c[0];
+					if(l!=":"){
+						if(c==1)
+							return "keyword";
+						else if(c==2)
+							return "def";
+						else if(c==3)
+							return "atom";
+						else if(c==4)
+							return "operator";
+						else if(c==5)
+							return "variable-2";
+						else
+							return "meta";}
+					else
+						return "meta";}}
+			if(/[a-zA-Z_]/.test(ch)){
+				var l=look(stream, -2);
+				stream.eatWhile(/\w/);
+				var c=PERL[stream.current()];
+				var isPG = PGcmds.has(stream.current());
+				if(!c && !isPG)
+					return "meta";
+				if(isPG)
+					return PGkeyword;
+				if(c[1])
+					c=c[0];
+				if(l!=":"){
+					if(c==1)
+						return "keyword";
+					else if(c==2)
+						return "def";
+					else if(c==3)
+						return "atom";
+					else if(c==4)
+						return "operator";
+					else if(c==5)
+						return "variable-2";
+					else
+						return "meta";}
+				else
+					return "meta";}
+			return null;}
+
+		return {
+			startState: function() {
+				return {
+					tokenize: tokenPerl,
+					chain: null,
+					style: null,
+					tail: null
+				};
+			},
+			token: function(stream, state) {
+				return (state.tokenize || tokenPerl)(stream, state);
+			},
+			lineComment: '#'
+		};
+	});
+	
+	CodeMirror.registerHelper("wordChars", "perl", /[\w$]/);
+	
+	CodeMirror.defineMIME("text/x-perl", "perl");
+	
+	// it's like "peek", but need for look-ahead or look-behind if index < 0
+	function look(stream, c){
+		return stream.string.charAt(stream.pos+(c||0));
+	}
+	
+	// return a part of prefix of current stream from current position
+	function prefix(stream, c){
+		if(c){
+			var x=stream.pos-c;
+			return stream.string.substr((x>=0?x:0),c);}
+		else{
+			return stream.string.substr(0,stream.pos-1);
+		}
+	}
+	
+	// return a part of suffix of current stream from current position
+	function suffix(stream, c){
+		var y=stream.string.length;
+		var x=y-stream.pos+1;
+		return stream.string.substr(stream.pos,(c&&c<y?c:x));
+	}
+	
+	// eating and vomiting a part of stream from current position
+	function eatSuffix(stream, c){
+		var x=stream.pos+c;
+		var y;
+		if(x<=0)
+			stream.pos=0;
+		else if(x>=(y=stream.string.length-1))
+			stream.pos=y;
+		else
+			stream.pos=x;
+	}
+	
+})();
diff --git a/tutorial/sample-problems/Algebra/AlgebraicFractionAnswer.pg b/tutorial/sample-problems/Algebra/AlgebraicFractionAnswer.pg
new file mode 100644
index 0000000000..a7b9cbe1de
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/AlgebraicFractionAnswer.pg
@@ -0,0 +1,134 @@
+## DESCRIPTION
+## Algebraic fraction answer requiring simplification
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'algebraic fraction answer')
+
+#:% name = Algebraic Fraction Answer
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [fraction]
+
+#:% section = preamble
+#: We include the macros file `niceTables.pl` to be able to display the answer boxes
+#: on top of each other (as a fraction).
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl', 'PGML.pl',
+    'niceTables.pl', 'parserMultiAnswer.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: We define MathObjects formulas `$num` and `$den` that are the correct
+#: numerator and denominator for the answer, as well as some bogus answers
+#: `$numbogus` and `$denbogus` that result from not finding a common
+#: denominator. We use `MultiAnswer` to manipulate both student answers at
+#: the same time. In `$multians` we allow for answers to be left blank,
+#: which requires one of two things: either we disable the error message or
+#: do type checking on the students input by using `ref($f1) eq ref($f1stu)`
+#: to see if the correct numerator `$f1` and the student numerator `$f1stu`
+#: have the same type. We used the code
+#: `Context()->{error}{msg}{"Operands of '*' can't be words"} = ' ';` to
+#: disable the error message because this method allows the
+#: "Simplify your answer" feature to work more reliably. We also allow for
+#: the student to enter the fraction as either
+#: `(6y-3)/(y-2)` or `(3-6y)/(2-y)`, since both are correct and it is not
+#: clear that one is preferable to the other, which requires that we check
+#: `$f1 == $f1stu || -$f1 == $f1stu`. Here `||` is perl's "or" operator. We
+#: provide some custom answer hints by testing for bogus numerators and
+#: denominators and displaying answer messages via
+#: `$self->setMessage(1, "Simplify your answer further");`,
+#: where the 1 stands for the first answer blank.
+#:
+#: The fraction answer is created using a `LayoutTable` from `niceTables.pl`.
+#: The outer `LayoutTable` has a single row with the mathematical expression
+#: and then another `LayoutTable` that formats the fraction with a bottom
+#: horizontal line. The padding is changed to improve the look of the fraction.
+Context()->variables->are(y => 'Real');
+Context()->{error}{msg}{"Operands of '*' can't be words"} = ' ';
+
+do {
+    $a = random(2, 8, 2);
+    $b = random(3, 9, 2);
+    $c = random(1, 9, 1);
+} until ($a * $c != $b);
+
+$num = Formula("$a y - $b");
+$den = Formula("y - $c");
+
+$numbogus = Formula("$a*y+$b");
+$denbogus = Formula("(y-$c)*($c-y)");
+
+$multians = MultiAnswer($num, $den)->with(
+    singleResult      => 0,
+    allowBlankAnswers => 1,
+    checker           => sub {
+        my ($correct, $student, $self) = @_;
+        my ($f1stu, $f2stu) = @{$student};
+        my ($f1,    $f2)    = @{$correct};
+
+        if (($f1 == $f1stu && $f2 == $f2stu)
+            || (-$f1 == $f1stu && -$f2 == $f2stu))
+        {
+            return [ 1, 1 ];
+        } elsif ($f1 == $f1stu || -$f1 == $f1stu) {
+            return [ 1, 0 ];
+        } elsif (($numbogus == $f1stu || -$numbogus == $f1stu)
+            || ($denbogus == $f2stu || -$denbogus == $f2stu))
+        {
+            $self->setMessage(1, "Find a common denominator first");
+            $self->setMessage(2, "Find a common denominator first");
+            return [ 0, 0 ];
+        } elsif ($f2 == $f2stu || -$f2 == $f2stu) {
+            return [ 0, 1 ];
+        } elsif ($f1 * $f2stu == $f1stu * $f2) {
+            $self->setMessage(1, "Simplify your answer further");
+            $self->setMessage(2, "Simplify your answer further");
+            return [ 0, 0 ];
+        } else {
+            return [ 0, 0 ];
+        }
+    }
+);
+
+$frac = LayoutTable(
+    [ [
+        "\(\displaystyle\frac{$a y}{y-$c} + \frac{$b}{$c - y}=\)",
+        LayoutTable(
+            [ [ [ ans_rule(4), bottom => 1 ] ], [ ans_rule(4) ], ],
+            padding => [ 0.5, 0 ],
+        )
+    ] ],
+    padding => [ 0, 0.5 ],
+    valign  => 'middle',
+);
+
+#:% section = statement
+#: Everything is as usual. Insert the fraction and answer blanks using `$showfraction`.
+BEGIN_PGML
+Perform the indicated operations. Express your answer in reduced form.
+
+[$frac]*
+
+END_PGML
+
+#:% section = answer
+#: It is necessary to use the answer evaluator `ANS` since
+#: `ans_rule` was used to produce answer blanks.
+ANS($multians->cmp());
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/AnswerBlankInExponent.pg b/tutorial/sample-problems/Algebra/AnswerBlankInExponent.pg
new file mode 100644
index 0000000000..f140382582
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/AnswerBlankInExponent.pg
@@ -0,0 +1,72 @@
+## DESCRIPTION
+## Answer blank in the exponent
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'answer blank in the exponent')
+
+#:% name = Answer Blank in the Exponent
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [exponent]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We want the only variables to be `a` and `b` and choose a random power.
+#:
+#: The exponential layout is in HTML using a pair of adjacent `span` elements
+#: with the right one shifted up using the CSS style `vertical-align`.
+#: In hardcopy mode, we use the LaTeX exponent.
+Context()->variables->are(a => 'Real', b => 'Real');
+
+$n = random(3, 9);
+
+# TeX
+$expression = "a^{$n} b^{$n}";
+
+# MathObjects
+$base     = Formula("a*b");
+$exponent = Formula("$n");
+
+# Display exponents nicely
+$exp = MODES(
+    HTML => "<span>\(\displaystyle $expression= \Big(\)"
+        . ans_rule(4)
+        . '\(\Big)\)</span><span style="vertical-align: 12pt;">'
+        . ans_rule(4)
+        . '</span>',
+    TeX => "\( \displaystyle $expression = ("
+        . ans_rule(4) . ")^{"
+        . ans_rule(4) . "}\)"
+);
+
+#:% section = statement
+#: We insert exponential stored as `$exp`.
+BEGIN_PGML
+Rewrite the following using a single exponent.
+
+[$exp]*
+END_PGML
+
+#:% section = answer
+#: Because the answer blanks are traditional ans_rule, then we need to use this
+#: style of answer checking.
+ANS($base->cmp());
+ANS($exponent->cmp());
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/AnswerUpToMultiplication.pg b/tutorial/sample-problems/Algebra/AnswerUpToMultiplication.pg
new file mode 100644
index 0000000000..fdc3758d9f
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/AnswerUpToMultiplication.pg
@@ -0,0 +1,57 @@
+## DESCRIPTION
+## Answers up to multiplication
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'answer up to multiplication')
+
+#:% name = Answer up to a Constant Multiple
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [answer, adaptive parameters]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The answer checker uses a local context with an adaptive parameter to check
+#: if the student answer is a parameter `C0` multiple of the correct answer.
+#: For more on adaptive parameters, see
+#: [AdaptiveParameters](../problem-techniques/AdaptiveParameters.html).
+
+$ans = Compute('(x + 1)(x - 2)')->cmp(
+    checker => sub {
+        my ($correct, $student, $self) = @_;
+        return 0 if $student == 0;
+        my $context = Context()->copy;
+        $context->flags->set(no_parameters => 0);
+        $context->variables->add('C0' => 'Parameter');
+        my $c0 = Formula($context, 'C0');
+        $student = Formula($context, $student);
+        $correct = Formula($context, "$c0 * $correct");
+        return $correct == $student;
+    }
+);
+
+#:% section = statement
+BEGIN_PGML
+Find a quadratic equation in terms of the variable
+[`x`] with roots [`-1`] and [`2`].
+
+[`y =`] [_]{$ans}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/DomainRange.pg b/tutorial/sample-problems/Algebra/DomainRange.pg
new file mode 100644
index 0000000000..4199484de9
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/DomainRange.pg
@@ -0,0 +1,95 @@
+## DESCRIPTION
+## Domain and range of a function using inequalities
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'domain and range using inequalities')
+
+#:% name = Domain and Range of a Function
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [domain]
+
+#:% section = preamble
+#: The `contextInequalities.pl` macro is used for inequality answers.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextInequalities.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Different contexts can be used for different answers in a problem.
+#: Calling Context('Inequalities-Only') creates a new instance of the context.
+#: The two contexts in this problem have different variables defined.  The
+#: first only has the variable "x", and the second only has the variable "y".
+#: Note that calling `->variables->are(x => 'Real')` for the first instance is
+#: actually unnecessary since "x" is the only variable in the context by
+#: default.  It is only shown here for emphasis.
+
+#: For the first part, the "Inequalities-Only" context is used.  That context
+#: requires students to enter their answer using inequalities.  If the
+#: "Inequalities" context had been used instead, then students would also be
+#: able to enter answers using interval notation. For more details, please see
+#: `contextInequalities.pl`.
+#:
+#: Calling Context('Inequalities-Only') creates a new instance of the context.
+#: The first two contexts in this problem have different variables defined.  The
+#: first only has the variable "x", and the second only has the variable "y".
+#: Note that calling `->variables->are(x => 'Real')` for the first instance is
+#: actually unnecessary since "x" is the only variable in the context by
+#: default.  It is only shown here for emphasis.
+#:
+#: Setting the context flag `formatStudentAnswer => 'parsed'` insists that the
+#: `parsed` student answers be displayed and no further reduction or evaluation
+#: is done.  Generally this means the student answer is displayed much as it is
+#: entered.  In particular in this instance it prevents the student's answer
+#: from being reduced to a decimal.
+#:
+#: For the second part, the "Interval" context is used instead.  Change to this
+#; context by calling `Context('Interval')`. Note that `inf` is built-in for
+#: infinte intervals.
+$a = random(1, 6);
+
+Context('Inequalities-Only')->variables->are(x => 'Real');
+Context()->flags->set(formatStudentAnswer => 'parsed');
+
+$domain = Compute("x >= $a");
+
+Context('Inequalities-Only')->variables->are(y => 'Real');
+Context()->flags->set(formatStudentAnswer => 'parsed');
+
+$range = Compute('y >= 0');
+
+# Interval version of the same domain and range.
+Context('Interval');
+$domain_interval = Compute("[$a, inf)");
+$range_interval  = Compute('[0, inf)');
+
+#:% section = statement
+BEGIN_PGML
+Suppose [`f(x) = \sqrt(x - [$a])`].
+
+Enter inequalities for the domain and range of [`f`].
+
+Domain: [_]{$domain}{15}
+
+Range: [_]{$range}{15}
+
+Use interval notation to give the domain and range of [`f`].
+
+Domain: [____]{$domain_interval}
+
+Range: [____]{$range_interval}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/DynamicGraph.pg b/tutorial/sample-problems/Algebra/DynamicGraph.pg
new file mode 100644
index 0000000000..e3751968c4
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/DynamicGraph.pg
@@ -0,0 +1,88 @@
+## DESCRIPTION
+## Dynamically generated graph of a function
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'dynamic graph')
+
+#:% name = Dynamic Graph
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [graph]
+
+#:% section = preamble
+#: The dynamic graph is generated with `PGtikz.pl`, so this is needed.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGtikz.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The code between `$graph->BEGIN_TIKZ` and `END_TIKZ` are tikz commands.  Information
+#: on tikz can be found at the [homepage for tikz](https://tikz.dev) and details on
+#: using tikz within pg problems can be found in PODLINK('PGtikz.pl').
+#:
+#: This problem creates a parabola with random intercepts.
+#:
+#: Some notes about the command in the `TIKZ` block:
+#:
+#: * The first `\filldraw` command produces a frame around the plotting region
+#: * The first two `\draw` commands draw the axes as well as the axis labels.
+#:    The `->` gives the lines arrows in that direction and the `thick` makes
+#:    the lines a bit thicker.
+#: * The two `\foreach` commands produce the tick marks and labels.
+#: * The last `\draw` command produces the graph of the function. The `domain`
+#:    option gives the plotting domain and the `smooth` attempts to make the
+#:    resulting graph smooth.  Lastly, the function itself needs to be in
+#:    `{}` in order for the function to be computed correctly.
+$a = random(1, 4);    # negative of left x-intercept
+$b = random(2, 4);    # right x-intercept
+$c = random(2, 6);    # y-intercept
+
+$k = -$c / ($a * $b);
+
+$graph = createTikZImage();
+$graph->tikzLibraries('arrows.meta');
+$graph->BEGIN_TIKZ
+\tikzset{>={Stealth[scale=1.5]}}
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-6,7) rectangle (6,-1);
+\draw[->,thick] (-6,0) -- (6,0) node[above left,outer sep=3pt] {\(x\)};
+\foreach \x in {-5,...,-1,1,2,...,5}
+    \draw(\x,5pt) -- (\x,-5pt) node [below] {\(\x\)};
+\draw[->,thick] (0,-1) -- (0,7) node[below right,outer sep=3pt] {\(y\)};
+\foreach \y in {1,...,6}
+    \draw (5pt,\y) -- (-5pt,\y) node[left] {\(\y\)};
+\draw[blue,ultra thick] plot[domain=-6:6,smooth] (\x,{$k*(\x+$a)*(\x-$b)});
+END_TIKZ
+
+#:% section = statement
+#: Note that the tikz graph in `$graph` to be shown is placed in the `image` function
+#: and since this is a function, it must go in a `[@ ... @]*` block.
+BEGIN_PGML
+Use the graph to find the missing values. There may be more than one correct
+answer, in which case you should enter your answers as a comma separated list.
+If there are no correct answers, enter NONE.
+
+[@ image($graph, width => 400, tex_size => 600) @]*
+
+a) [`f(0) =`] [__]{$c}
+
+b) [`f\Big(`] [__]{List(-$a, $b)} [`\Big) = 0`]
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/EquationDefiningFunction.pg b/tutorial/sample-problems/Algebra/EquationDefiningFunction.pg
new file mode 100644
index 0000000000..424b3d5085
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/EquationDefiningFunction.pg
@@ -0,0 +1,49 @@
+## DESCRIPTION
+## An equation defining a function
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('algebra', 'equation defining a function')
+
+#:% name = Answer is an Equation
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [equation, function, answers]
+
+#:% section = preamble
+#: We need to include the macro file `parserAssignment.pl`.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserAssignment.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We must allow assignment, and declare any function names we wish to use. For
+#: more details and examples in other MathObjects contexts, see
+#: PODLINK('parserAssignment.pl').
+Context()->variables->are(x => 'Real', y => 'Real');
+parser::Assignment->Allow;
+parser::Assignment->Function('f');
+
+$eqn = Formula('y = 5x + 2');
+$fun = Formula('f(x) = 3x^2 + 2x');
+
+#:% section = statement
+BEGIN_PGML
+Enter [`[$eqn]`]: [_]{$eqn}{10}
+
+Enter [`[$fun]`]: [_]{$fun}{10}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/EquationImplicitFunction.pg b/tutorial/sample-problems/Algebra/EquationImplicitFunction.pg
new file mode 100644
index 0000000000..41f0a5fc6e
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/EquationImplicitFunction.pg
@@ -0,0 +1,78 @@
+## DESCRIPTION
+## An equation implicitly defining a function
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'equation implicitly defining a function')
+
+#:% name = Implicit Function as an Equation
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [implicit function]
+
+#:% section = preamble
+#: The macro `parserImplicitEquation.pl` allows the entry of equations.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',             'PGML.pl',
+    'parserImplicitEquation.pl', 'PGcourse.pl'
+);
+
+#:% section = setup
+#: We quash some error messages by redefining them to be a blank string ' ' (notice
+#: the space). Since the circle will always be contained in a rectangle with two
+#: opposite corners at (-4, -4) and (10, 10), we set the limits for the variables x
+#: and y to be outside of this rectangle. The ImplicitEquation object allows us to
+#: specify as many solutions as we like, and doing so should improve the accuracy of
+#: the answer evaluator.
+#:
+#: If your equation is linear of the form `x = 3`, `4x + 3y = 12`, or
+#: `4x + 3y + 5z = 21` for example, you should use the `parserImplicitPlane.pl`
+#: context and answer evaluator instead.
+Context('ImplicitEquation');
+Context()->{error}{msg}{"Can't find any solutions to your equation"} = ' ';
+Context()->{error}{msg}{"Can't generate enough valid points for comparison"} =
+    ' ';
+
+Context()->variables->set(
+    x => { limits => [ -6, 11 ] },
+    y => { limits => [ -6, 11 ] },
+);
+
+$a = random(1, 5);
+$b = random(1, 5);
+$r = random(2, 5);
+$p = Compute("($a,$b)");
+
+$answer = ImplicitEquation(
+    "(x-$a)^2 + (y-$b)^2 = $r^2",
+    solutions => [
+        [ $a,                    $b + $r ],
+        [ $a,                    $b - $r ],
+        [ $a + $r,               $b ],
+        [ $a - $r,               $b ],
+        [ $a + $r * sqrt(2) / 2, $b + $r * sqrt(2) / 2 ],
+    ]
+);
+
+#:% section = statement
+BEGIN_PGML
+Enter an equation for a circle in the [`xy`]-plane
+of radius [`[$r]`] centered at [`[$p]`].
+
+[_]{$answer}{25}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/ExpandedPolynomial.pg b/tutorial/sample-problems/Algebra/ExpandedPolynomial.pg
new file mode 100644
index 0000000000..33a8811d6c
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/ExpandedPolynomial.pg
@@ -0,0 +1,72 @@
+## DESCRIPTION
+## This problem gives the student a quadratic in factored form and asks for
+## the equivalent in expanded/general form.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('algebra', 'expanded polynomial')
+
+#:% name = Expanded Polynomial
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [polynomial]
+
+#:% section = preamble
+#: We must load `contextLimitedPolynomial.pl`
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',               'PGML.pl',
+    'contextLimitedPolynomial.pl', 'PGcourse.pl'
+);
+
+#:% section = setup
+#: The macro contextLimitedPolynomial.pl provides two contexts:
+#:
+#:```{#contexts .perl}
+#: Context('LimitedPolynomial');
+#: Context('LimitedPolynomial-Strict');
+#:```
+#: The strict version does not allow any mathematical operations within coefficients,
+#: so `(5+3)x` must be simplified to `8x`. For more details, see PODLINK('contextLimitedPolynomial.pl').
+#:
+#: We use the LimitedPolynomial-Strict context, construct the coefficients $b and $c
+#: as Perl reals, and then construct $expandedform using these pre-computed coefficients.
+#: This is because the `LimitedPolynomial-Strict` context balks at answers that are not
+#: already simplified completely. Notice that we called the `->reduce()` method on the
+#: expanded form of the polynomial, which will ensure that the polynomial will be
+#: displayed as `x^2 - 6x + 4` instead of `x^2 + -6x + 4`.
+Context('Numeric');
+$h          = 3;
+$k          = 5;
+$vertexform = Compute("(x-$h)^2-$k");
+
+# Expanded form
+Context('LimitedPolynomial-Strict');
+$b            = -2 * $h;
+$c            = $h**2 - $k;
+$expandedform = Formula("x^2 + $b x + $c")->reduce();
+
+#:% section = statement
+#: To help students understand how to format their answers, we give an example
+#: `ax^2+bx+c` of what the answer should look like.
+BEGIN_PGML
+The quadratic expression [`[$vertexform]`] is written in vertex form.
+Write the expression in expanded form [`ax^2 + bx + c`].
+
+[_]{$expandedform}{20}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/FactoredPolynomial.pg b/tutorial/sample-problems/Algebra/FactoredPolynomial.pg
new file mode 100644
index 0000000000..195d627d24
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/FactoredPolynomial.pg
@@ -0,0 +1,68 @@
+## DESCRIPTION
+## Factored polynomial
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('algebra', 'factored polynomial')
+
+#:% name = Factored Polynomial
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [polynomial]
+
+#:% section = preamble
+#: We require additional contexts provided by `contextPolynomialFactors.pl` and `contextLimitedPowers.pl`
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',               'PGML.pl',
+    'contextPolynomialFactors.pl', 'contextLimitedPowers.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: For the factored form we need to change to the `PolynomialFactors-Strict` context
+#: and restrict the allowed powers to either 0 or 1 using the `LimitedPowers::OnlyIntegers`
+#: block of code. Note: restricting all exponents to 0 or 1 means that repeated factors
+#: will have to be entered in the form `k(ax+b)(ax+b)` instead of `k(ax+b)^2`. Also,
+#: restricting all exponents to 0 or 1 means that the polynomial must factor as a
+#: product of linear factors (no irreducible quadratic factors can appear). Of course,
+#: we could allow exponents to be 0, 1, or 2, but then students would be allowed to
+#: enter reducible quadratic factors. There are no restrictions on the coefficients, i.e.,
+#: the quadratic could have any nonzero leading coefficient. We set `singleFactors => 0`
+#: so that repeated, non-simplified factors do not generate errors.
+# Expanded form
+Context('Numeric');
+$poly = Compute('8x^2 + 28x + 12');
+
+# Factored form
+Context('PolynomialFactors-Strict');
+Context()->flags->set(singleFactors => 0);
+LimitedPowers::OnlyIntegers(
+    minPower => 0,
+    maxPower => 1,
+    message  => 'either 0 or 1',
+);
+$factored = Compute('4(2x+1)(x+3)');
+
+#:% section = statement
+#: We should explicitly tell students to enter answers in the form `k(ax+b)(cx+d)`.
+BEGIN_PGML
+Write the quadratic expression [`[$poly]`] in factored form [`k(ax+b)(cx+d)`].
+
+[_]{$factored}{20}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/FractionAnswer.pg b/tutorial/sample-problems/Algebra/FractionAnswer.pg
new file mode 100644
index 0000000000..8397d1d22c
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/FractionAnswer.pg
@@ -0,0 +1,58 @@
+## DESCRIPTION
+## Fraction answer
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'fraction answer')
+
+#:% name = Fraction Answer
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [fraction]
+
+#:% section = preamble
+#: The macro `contextFraction.pl` must be loaded.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextFraction.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The macro `contextFraction.pl` provides four contexts:
+#:
+#:```{#contexts .perl}
+#: Context('Fraction');
+#: Context('Fraction-NoDecimals');
+#: Context('LimitedFraction');
+#: Context('LimitedProperFraction');
+#:```
+#: For the differences among these, see the POD documentation for
+#: PODLINK('contextFraction.pl').
+Context('Fraction-NoDecimals');
+
+$answer = Compute('3/2');
+
+#:% section = statement
+#: There are many context flags that control how fraction answers are checked.
+#: See the POD documentation for PODLINK('contextFraction.pl').
+BEGIN_PGML
+Simplify [``\frac{6}{4}``].
+
+Answer = [_]{$answer->cmp(
+    studentsMustReduceFractions => 1,
+    reduceFractions => 1,
+    allowMixedNumbers => 0
+)}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Factor and cancel to obtain [`\displaystyle [$answer]`].
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/FunctionDecomposition.pg b/tutorial/sample-problems/Algebra/FunctionDecomposition.pg
new file mode 100644
index 0000000000..abaa3d185a
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/FunctionDecomposition.pg
@@ -0,0 +1,61 @@
+## DESCRIPTION
+## Decompose a function into two functions
+## ENDDESCRIPTION
+
+## KEYWORDS('algebra', 'function decomposition')
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+
+#:% name = Function Decomposition
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [composition]
+
+#:% section = preamble
+#: We need to include the macro file `answerComposition.pl`, which provides an answer
+#: checker that determines if two functions compose to form a given function. This
+#: can be used in problems where you ask a student to break a given function into a
+#: composition of two simpler functions, neither of which is allowed to be the
+#: identity function.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'answerComposition.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We will ask the students for a function `f(u)` and and function `g(x)` such
+#: that `f(g(x))` is a given function.  Therefore, we need to make `u` a
+#: variable and define `$f` and `$g`.
+Context()->variables->add(u => 'Real');
+
+$a = random(2, 9);
+
+$f = Formula("sqrt(u)");
+$g = Formula("x^2+$a");
+
+#:% section = statement
+BEGIN_PGML
+Express the function [`y = \sqrt{x^2 + [$a]}`] as a composition [`y = f(g(x))`]
+of two simpler functions [`y = f(u)`] and [`u = g(x)`].
+
+* [`f(u) =`] [_]{ width => 15 }
+
+* [`g(x) =`]  [_]{ width => 15 }
+END_PGML
+
+#:% section = answer
+#: We use the `COMPOSITION_ANS()` routine to evaluate both answer blanks. It is
+#: possible to use the same variable for both answer blanks. See
+#: PODLINK('answerComposition.pl') for more options and details.
+COMPOSITION_ANS($f, $g, vars => [ 'u', 'x' ], showVariableHints => 1);
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/GraphToolCircle.pg b/tutorial/sample-problems/Algebra/GraphToolCircle.pg
new file mode 100644
index 0000000000..2b0761e645
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/GraphToolCircle.pg
@@ -0,0 +1,103 @@
+## DESCRIPTION
+## Interactive graphing tool problem that asks the student to plot a circle.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Date(05/28/2023)
+## Institution(Missouri Western State University)
+## Author(Glenn Rice)
+## KEYWORDS('graphs', 'circles')
+
+#:% name = Graph Tool, plotting a circle
+#:% type = [Sample, technique]
+#:% subject = [algebra, precalculus]
+#:% categories = [graph]
+
+#:% section = preamble
+#: This example shows how to get student input in the form of a graph (a circle)
+#: by using interactive graphing tools. Load the parserGraphTool.pl macro for
+#: this.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserGraphTool.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The variables `$h`, `$k` and `$r` randomly pick a center and radius of the circle.
+#:
+#: The lines
+#:
+#:```{#equation .perl}
+#: Context()->variables->add(y => 'Real');
+#: $circle_eq_lhs = Formula("(x - $h)^2 + (y - $k)^2")->reduce;
+#:```
+#:
+#: define the equation of the circle that is shown in the problem and solution.
+#:
+#: The `GraphTool` method creates the graph tool object. The only argument is
+#: the correct answer. This is a string that contains a list of objects that
+#: the student will be expected to graph. Each object is a brace delimited list
+#: of the attributes of the object. The first attribute in each list is the
+#: type of object to be graphed, `circle` in this case. What the remaining
+#: attributes are depend on the type. For a circle the second attribute is
+#: whether the object is to be `solid` or `dashed`, the third attribute is the
+#: center of the circle, and the fourth attribute is a point on the circle.
+#:
+#: The `->with` method is then used to set options for the `GraphTool` object.
+#: In this case the options that are set are:
+#:
+#: * `bBox`: This is an array reference of four values xmin, ymax, xmax, ymin
+#: indicating the upper left and lower right corners of the visible graph.
+#:
+#: There is a default checker for the GraphTool that will mark correct a
+#: student answer that 'looks' like the correct one. This means that if
+#: a student adds two circles that are equivalent with one solid and one
+#: dashed, that if the solid one is plotted second, credit will be given.
+#: For simple graphs, the default should be sufficient. See
+#: PROBLINK('GraphToolCustomChecker.pg') for an example of how to use a custom
+#: checker.
+#:
+#: For more details, see the PODLINK('POD documentation','parserGraphTool.pl')
+$h = non_zero_random(-5, 5);
+$k = non_zero_random(-5, 5);
+$r = random(1, 4);
+
+Context()->variables->add('y' => 'Real');
+$circle_eq_lhs = Formula("(x-$h)^2 + (y-$k)^2")->reduce;
+
+$gt = GraphTool("{circle, solid, ($h, $k), ($h + $r, $k)}")
+    ->with(bBox => [ -11, 11, 11, -11 ]);
+
+#:% section = statement
+#: This asks to graph the circle given by the equation. The code
+#: `[_]{$gt}` inserts the GraphTool.
+BEGIN_PGML
+Graph the circle given by the following equation.
+
+    [`[$circle_eq_lhs] = [$r ** 2]`]
+
+[_]{$gt}
+END_PGML
+
+#:% section = solution
+#: The solution describes how to obtain the graph of the circle from the
+#: equation.
+#:
+#: The line `[@ $gt->generateAnswerGraph @]*` inserts the correct answer
+#: graph.
+BEGIN_PGML_SOLUTION
+The equation of the circle of the form:
+
+    [`[$circle_eq_lhs] = [$r ** 2]`]
+
+has a center at [`([$h],[$k])`] and radius [$r].  To enter the graph, click the
+circle tool, then click the center at [`([$h],[$k])`] and then click a second
+point that is [$r] units from the center.  This is easist going left, right, up
+or down from the center.
+
+The solution is
+[@ $gt->generateAnswerGraph @]*
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/GraphToolCubic.pg b/tutorial/sample-problems/Algebra/GraphToolCubic.pg
new file mode 100644
index 0000000000..dc02f1c6d0
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/GraphToolCubic.pg
@@ -0,0 +1,98 @@
+## DESCRIPTION
+## Interactive graphing tool problem that asks the student to plot a cubic.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Date(05/28/2023)
+## Institution(Missouri Western State University)
+## Author(Glenn Rice)
+## KEYWORDS('graphs', 'circles')
+
+#:% name = Graph Tool, plotting a cubic
+#:% type = [Sample, technique]
+#:% subject = [algebra, precalculus]
+#:% categories = [graph]
+
+#:% section = preamble
+#: This example shows how to get student input in the form of a graph (a cubic)
+#: by using interactive graphing tools. Load the parserGraphTool.pl macro for
+#: this.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',      'PGML.pl',
+    'parserGraphTool.pl', 'contextFraction.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: A cubic is created with 3 random zeros and a random y-intercept.
+#:
+#: The `GraphTool` method creates the graph tool object. The only argument is
+#: the correct answer. This is a string that contains a list of objects that
+#: the student will be expected to graph. Each object is a brace delimited list
+#: of the attributes of the object. The first attribute in each list is the
+#: type of object to be graphed, `cubic` in this case. What the remaining
+#: attributes are depend on the type. For a cubic the second attribute is
+#: whether the object is to be `solid` or `dashed`, the remaining attributes
+#: are four distinct points of the cubic.
+#:
+#: The `->with` method is then used to set options for the `GraphTool` object.
+#: In this case the options that are set are:
+#:
+#: * `bBox`: This is an array reference of four values xmin, ymax, xmax, ymin
+#: indicating the upper left and lower right corners of the visible graph.
+#: * `availableTools`: This determines which tools will be available for the
+#: student to use.
+#:
+#: There is a default checker for the GraphTool that will mark correct a
+#: student answer that 'looks' like the correct one. For simple graphs,
+#: the default should be sufficient. See PROBLINK('GraphToolCustomChecker.pg')
+#: for an example of how to use a custom checker.
+
+Context('Fraction');
+
+$x1 = random(-8, -4);
+$x2 = non_zero_random(-3, -3);
+$x3 = random(4, 8);
+
+$y0 = non_zero_random(-3, 3);
+
+$k = Fraction($y0, -$x1 * $x2 * $x3);
+
+$gt =
+    GraphTool("{cubic, solid, ($x1, 0), ($x2, 0), ($x3, 0), (0, $y0)}")->with(
+        bBox           => [ -11, 11, 11, -11 ],
+        availableTools => [
+            'PointTool',  'LineTool',
+            'CircleTool', 'QuadraticTool',
+            'CubicTool',  'FillTool',
+            'SolidDashTool'
+        ],
+    );
+
+#:% section = statement
+#: This asks to graph the cubic throw the given points. The code
+#: `[_]{$gt}` inserts the GraphTool.
+BEGIN_PGML
+Graph the cubic function [``p(x) = [$k](x-[$x1])(x-[$x2])(x-[$x3])``]
+
+[_]{$gt}
+END_PGML
+
+#:% section = solution
+#: The solution describes how to obtain the graph of the circle from the
+#: equation.
+BEGIN_PGML_SOLUTION
+To graph the cubic, you'll need 4 points.  Because of the form, there are
+3 zeros [`([$x1],0), ([$x2],0)`] and [`([$x3],0)`].  Any other point can be
+chosen, but another easy one is the [`y`]-intercept, which by evaluating
+[`p(0)=[$y0]`], then select [`(0,[$y0])`].
+
+The solution is
+[@ $gt->generateAnswerGraph @]*
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/GraphToolCustomChecker.pg b/tutorial/sample-problems/Algebra/GraphToolCustomChecker.pg
new file mode 100644
index 0000000000..c5647d1012
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/GraphToolCustomChecker.pg
@@ -0,0 +1,167 @@
+## DESCRIPTION
+## Interactive graphing tool problem with a custom checker.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Date(05/28/2023)
+## Institution(Missouri Western State University)
+## Author(Glenn Rice)
+## KEYWORDS('graphs', 'circles')
+
+#:% name = Graph Tool, custom checker
+#:% type = [Sample, technique]
+#:% subject = [algebra, precalculus]
+#:% categories = [graph]
+
+#:% section = preamble
+#: This example shows how to get student input in the form of a graph (a circle)
+#: by using interactive graphing tools, and demonstrates the usage of a custom
+#: checker.  Load the `parserGraphTool.pl` macro for this.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserGraphTool.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The variables `$h`, `$k` and `$r` randomly pick a center and radius of the circle.
+#:
+#: The lines
+#:
+#: ```{#equation .perl}
+#: Context()->variables->add(y => 'Real');
+#: $circle_eq_lhs = Formula("(x - $h)^2 + (y - $k)^2")->reduce;
+#: ```
+#:
+#: define the equation of the circle that is shown in the problem and solution.
+#:
+#: The `GraphTool` method creates the graph tool object. The only argument is
+#: the correct answer. This is a string that contains a list of objects that
+#: the student will be expected to graph. Each object is a brace delimited list
+#: of the attributes of the object. The first attribute in each list is the
+#: type of object to be graphed, `circle` in this case. What the remaining
+#: attributes are depend on the type. For a circle the second attribute is
+#: whether the object is to be `solid` or `dashed`, the third attribute is the
+#: center of the circle, and the fourth attribute is a point on the circle.
+#:
+#: The `->with` method is then used to set options for the `GraphTool` object.
+#: In this case the options that are set are:
+#:
+#: * `bBox`: this is an array reference of four values xmin, ymax, xmax, ymin
+#: indicating the upper left and lower right corners of the visible graph.
+#: * `cmpOptions`: this is a hash of options passed to the cmp method for checking
+#: the answer.
+#:
+#: The option
+#:
+#: ```{#cmp-options .perl}
+#: cmpOptions => { list_checker => sub { ... } }
+#: ```
+#:
+#: defines a list checker. The list checker is passed the `$correct` answer
+#: which will be a MathObject list of lists containing the attributes of the
+#: correct graph objects as described above, and the `$student` answer which
+#: will be a MathObject list of lists containing the attributes of the objects
+#: the student graphed. Note that this checker allows the student to graph the
+#: correct circle multiple times. The idea is that the graph is graded based on
+#: appearance. No matter how many times the student graphs the correct circle,
+#: the resulting graph appears the same.
+
+$h = non_zero_random(-5, 5);
+$k = non_zero_random(-5, 5);
+$r = random(1, 4);
+
+Context()->variables->add(y => 'Real');
+$circle_eq_lhs = Formula("(x - $h)^2 + (y - $k)^2")->reduce;
+
+$gt = GraphTool("{circle, solid, ($h, $k), ($h + $r, $k)}")->with(
+    bBox       => [ -11, 11, 11, -11 ],
+    cmpOptions => {
+        list_checker => sub {
+            my ($correct, $student, $ans, $value) = @_;
+            return 0 if $ans->{isPreview};
+
+            my $score = 0;
+            my @errors;
+            my $count = 1;
+
+            # Get the center and point that define the correct circle and
+            # compute the square of the radius.
+            my ($cx, $cy) = $correct->[0]->extract(3)->value;
+            my ($px, $py) = $correct->[0]->extract(4)->value;
+            my $r_squared = ($cx - $px)**2 + ($cy - $py)**2;
+
+            my $pointOnCircle = sub {
+                my $point = shift;
+                my ($x, $y) = $point->value;
+                return ($x - $cx)**2 + ($y - $cy)**2 == $r_squared;
+            };
+
+            # Iterate through the objects the student graphed and check to
+            # see if each is the correct circle.
+            for (@$student) {
+                my $nth = Value::List->NameForNumber($count++);
+
+                # This checks if the object graphed by the student is the same
+                # type as the correct object type (a circle in this case),
+                # has the same solid or dashed status, has the same center, and
+                # if the other point graphed is on the circle.
+                if ($_->extract(1) eq $correct->[0]->extract(1)
+                    && $_->extract(2) eq $correct->[0]->extract(2)
+                    && $_->extract(3) == $correct->[0]->extract(3)
+                    && $pointOnCircle->($_->extract(4)))
+                {
+                    $score += 1;
+                    next;
+                }
+
+                # Add messages for incorrect answers.
+
+                if ($_->extract(1) ne $correct->[0]->extract(1)) {
+                    push(@errors,
+                        "The $nth object graphed is not a circle");
+                    next;
+                }
+
+                if ($_->extract(2) ne $correct->[0]->extract(2)) {
+                    push(@errors,
+                        "The $nth object graphed should be a "
+                            . $correct->[0]->extract(2)
+                            . " circle.");
+                    next;
+                }
+
+                push(@errors, "The $nth object graphed is incorrect.");
+            }
+
+            return ($score, @errors);
+        }
+    }
+);
+
+#:% section = statement
+#: This asks to graph the circle given by the equation. The code
+#: `[_]{$gt}` inserts the GraphTool.
+BEGIN_PGML
+Graph the circle given by the following equation.
+
+    [`[$circle_eq_lhs] = [$r ** 2]`]
+
+[_]{$gt}
+END_PGML
+
+#:% section = solution
+#: The solution describes how to obtain the graph of the circle from the
+#: equation.
+BEGIN_PGML_SOLUTION
+The equation of the circle of the form:
+
+    [`[$circle_eq_lhs] = [$r ** 2]`]
+
+has a center at [`([$h],[$k])`] and radius [$r].  To enter the graph, click the
+circle tool, then click the center at [`([$h],[$k])`] and then click a second
+point that is [$r] units from the center.  This is easist going left, right, up
+or down from the center.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/GraphToolLine.pg b/tutorial/sample-problems/Algebra/GraphToolLine.pg
new file mode 100644
index 0000000000..a569ba3ffa
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/GraphToolLine.pg
@@ -0,0 +1,92 @@
+## DESCRIPTION
+## Interactive graphing tool problem that asks the student to plot a line.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Date(05/28/2023)
+## Institution(Missouri Western State University)
+## Author(Glenn Rice)
+## KEYWORDS('graphs', 'circles')
+
+#:% name = Graph Tool, plotting a line
+#:% type = [Sample, technique]
+#:% subject = [algebra, precalculus]
+#:% categories = [graph]
+
+#:% section = preamble
+#: This example shows how to get student input in the form of a graph (a line)
+#: by using interactive graphing tools. Load the parserGraphTool.pl macro for
+#: this.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserGraphTool.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: A cubic is created with 3 random zeros and a random y-intercept.
+#:
+#: The `GraphTool` method creates the graph tool object. The only argument is
+#: the correct answer. This is a string that contains a list of objects that
+#: the student will be expected to graph. Each object is a brace delimited list
+#: of the attributes of the object. The first attribute in each list is the
+#: type of object to be graphed, `line` in this case. What the remaining
+#: attributes are depend on the type. For a line the second attribute is
+#: whether the object is to be `solid` or `dashed`, and the remaining attibutes
+#: are two distinct points on the line.
+#:
+#: The `->with` method is then used to set options for the `GraphTool` object.
+#: In this case the options that are set are:
+#:
+#: * `bBox`: This is an array reference of four values xmin, ymax, xmax, ymin
+#: indicating the upper left and lower right corners of the visible graph.
+#: * `availableTools`: This determines which tools will be available for the
+#: student to use.
+#:
+#: There is a default checker for the GraphTool that will mark correct a
+#: student answer that 'looks' like the correct one. For simple graphs,
+#: the default should be sufficient. See PROBLINK('GraphToolCustomChecker.pg')
+#: for an example of how to use a custom checker.
+
+$x0   = non_zero_random(-6, 6);
+$y0   = non_zero_random(-6, 6);
+$line = nicestring([ $y0, $x0 ], [ 'x', 'y' ]);
+
+$gt = GraphTool("{line, solid, ($x0, 0), (0, $y0)}")->with(
+    bBox           => [ -11, 11, 11, -11 ],
+    availableTools => [
+        'PointTool',  'LineTool',
+        'CircleTool', 'QuadraticTool',
+        'CubicTool',  'FillTool',
+        'SolidDashTool'
+    ],
+);
+
+#:% section = statement.
+#: The code `[_]{$gt}` inserts the GraphTool.
+BEGIN_PGML
+On the graph below, plot the line [`[$line] = [$x0*$y0]`]
+
+[_]{$gt}
+
+END_PGML
+
+#:% section=solution
+
+BEGIN_PGML_SOLUTION
+Two points are needed off this line.  It could be put in slope-intercept form
+which would give a [`y`]-intercept and then a second point could be determined
+from the slope.
+
+Alternatively, the intercept form on the line is found by dividing the equation
+by the right hand side to
+[```\frac{x}{[$x0]}+ \frac{y}{[$y0]}=1```]
+and thus the [`x`]-intercept is number in the fraction under the [`x`] or
+ [$x0] and the [`y`]-intercept is the number in the fraction under the [`y`]
+ or [$y0].  The solution is
+
+[@ $gt->generateAnswerGraph @]*
+
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/GraphToolNumberLine.pg b/tutorial/sample-problems/Algebra/GraphToolNumberLine.pg
new file mode 100644
index 0000000000..86735a2349
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/GraphToolNumberLine.pg
@@ -0,0 +1,87 @@
+## DESCRIPTION
+## Interactive graphing tool problem that asks the student to plot a circle.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Date(05/28/2023)
+## Institution(Missouri Western State University)
+## Author(Glenn Rice)
+## KEYWORDS('graphs', 'circles')
+
+#:% name = Graph Tool, number line
+#:% type = [Sample, technique]
+#:% subject = [algebra, precalculus]
+#:% categories = [graph]
+
+#:% section = preamble
+#: This example shows how to get student input in the form of a graph
+#: by using interactive graphing tools. Load the `parserGraphTool.pl` macro for
+#: this.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserGraphTool.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Two intervals are created with random enpoints. The first
+#: one is a bounded interval, and the second an unbounded interval.
+#:
+#: The `GraphTool` method creates the graph tool object. The only argument is
+#: the correct answer. This is a string that contains a list of objects that
+#: the student will be expected to graph. Each object is a brace delimited list
+#: of the attributes of the object. The first attribute in each list is the
+#: type of object to be graphed, `interval` in this case. The remaining
+#: attributes depend on the type of graph object. For an `interval`, there is
+#: only one attribute which is the interval in standard interval notation.
+#:
+#: The `->with` method is then used to set options for the `GraphTool` object.
+#: In this case the options that are set are:
+#:
+#: * `numberLine` is set to 1 (true) to indicate this is a one-dimensional
+#: graph.
+#: * `bBox`: For a number line the bounding box is an array reference [xmin, xmax]
+#: containing the left and right limits of the visible graph.
+#: * `availableTools`: This determines which tools will be available for the
+#: student to use.
+#: * `ticksDistanceX`: The distance between tick marks in the x direction.
+#: * `minorTicksX`: The number of minor ticks to show. This can be 0.
+#: * `useBracketEnds`: 1 (true) means to use () and [] to denote the intervals
+#: a value of 0 means to use open and solid circles.
+$x1 = random(1, 5);
+
+$gt1 = GraphTool("{interval, (-$x1,$x1]}")->with(
+    availableTools =>
+        [ 'PointTool', 'IntervalTool', 'IncludeExcludePointTool' ],
+    numberLine     => 1,
+    bBox           => [ -6, 6 ],
+    ticksDistanceX => 1,
+    minorTicksX    => 0,
+    useBracketEnds => 1
+);
+
+$x2 = random(-5, 5);
+
+$gt2 = GraphTool("{interval, (-inf,$x2)}")->with(
+    availableTools =>
+        [ 'PointTool', 'IntervalTool', 'IncludeExcludePointTool' ],
+    numberLine     => 1,
+    bBox           => [ -6, 6 ],
+    ticksDistanceX => 1,
+    minorTicksX    => 0,
+    useBracketEnds => 0
+);
+
+#:% section = statement.
+#: The code `[_]{$gt}` inserts the GraphTool.
+BEGIN_PGML
+Graph the solution set for the linear inequality [`-[$x1] < x \leq [$x1]`].
+
+[_]{$gt1}
+
+Graph the solution set for the linear inequality [`x < [$x2]`].
+
+[_]{$gt2}
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/GraphToolPoints.pg b/tutorial/sample-problems/Algebra/GraphToolPoints.pg
new file mode 100644
index 0000000000..0a07e02abd
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/GraphToolPoints.pg
@@ -0,0 +1,75 @@
+## DESCRIPTION
+## Interactive graphing tool problem that asks the student to plot points.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Date(05/28/2023)
+## Institution(Missouri Western State University)
+## Author(Glenn Rice)
+## KEYWORDS('graphs', 'circles')
+
+#:% name = Graph Tool, plotting points
+#:% type = [Sample, technique]
+#:% subject = [algebra, precalculus]
+#:% categories = [graph]
+#:% see_also = [GraphToolCircle.pg, GraphToolCubic.pg, GraphToolLine.pg, GraphToolNumberLine.pg]
+
+#:% section = preamble
+#: This example shows how to get student input in the form of points
+#: by using interactive graphing tools. Load the `parserGraphTool.pl` macro for
+#: this.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserGraphTool.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Two points are created at random.
+#:
+#: The `GraphTool` method creates the graph tool object. The only argument is
+#: the correct answer. This is a string that contains a list of objects that
+#: the student will be expected to graph. Each object is a brace delimited list
+#: of the attributes of the object. The first attribute in each list is the
+#: type of object to be graphed, `point` in this case. What the remaining
+#: attributes are depend on the type. For a point, there is only one additional
+#: attribute which is the point itself.
+#:
+#: The `->with` method is then used to set options for the `GraphTool` object.
+#: In this case the options that are set are:
+#:
+#: * `bBox`: This is an array reference of four values `xmin, ymax, xmax, ymin`
+#: indicating the upper left and lower right corners of the visible graph.
+#: * `availableTools`: This determines which tools will be available for the
+#: student to use.
+#: * `showCoordinateHints`: Setting this to 0 turns off coordinate hints, which
+#: would show students the coordinates the cursor is over.
+#:
+#: For more details, see the PODLINK('POD documentation','parserGraphTool.pl')
+$x1 = non_zero_random(-5, 5);
+$y1 = non_zero_random(-5, 5);
+
+$x2 = non_zero_random(-5, 5);
+$y2 = non_zero_random(-5, 5);
+
+$gt = GraphTool("{point, ($x1, $y1)}", "{point, ($x2, $y2)}")->with(
+    availableTools      => ['PointTool'],
+    bBox                => [ -11, 11, 11, -11 ],
+    showCoordinateHints => 0,
+);
+
+#:% section = statement
+#: The code `[_]{$gt}` inserts the GraphTool.
+BEGIN_PGML
+Graph the points [`([$x1], [$y1])`] and [`([$x2], [$y2])`].
+
+[_]{$gt}
+END_PGML
+
+#:% section=solution
+
+BEGIN_PGML_SOLUTION
+
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/InequalityAnswer.pg b/tutorial/sample-problems/Algebra/InequalityAnswer.pg
new file mode 100644
index 0000000000..6b2a1c0cf0
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/InequalityAnswer.pg
@@ -0,0 +1,54 @@
+## DESCRIPTION
+## Answer is an inequality
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'answer is an inequality')
+
+#:% name = Answer as an Inequality
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [fraction]
+
+#:% section = preamble
+#: We must load `contextInequalities.pl`.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextInequalities.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We require students to use inequalities by using `Context('Inequalities-Only')`.
+#: If we had used `Context('Inequalities')` instead, then students could also enter
+#: their answer using interval notation. For more details, please see
+#: PODLINK('contextInequalities.pl').
+#:
+#: We use `formatStudentAnswer => 'parsed'` and `Compute()` so that the student's
+#: answer is left as a fraction rather than reduced to a decimal.
+Context('Inequalities-Only');
+Context()->flags->set(formatStudentAnswer => 'parsed');
+
+$a   = random(3, 9);
+$ans = Compute("x >= -10 / $a");
+
+#:% section = statement
+BEGIN_PGML
+Solve the inequality [``-[$a]x  \leq 10``].
+Enter your answer using inequality notation.
+
+[_]{$ans}
+
+[@ helpLink('inequalities') @]*
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/LinearInequality.pg b/tutorial/sample-problems/Algebra/LinearInequality.pg
new file mode 100644
index 0000000000..cba0884152
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/LinearInequality.pg
@@ -0,0 +1,55 @@
+## DESCRIPTION
+## Enter a linear inequality based on a description
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('algebra', 'linear inequality')
+
+#:% name = Linear Inequality
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [inequality]
+
+#:% section = preamble
+#: We include the macro file `parserLinearRelation.pl` to be able to the a
+#: LinearRelation object.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserLinearRelation.pl',
+    'PGcourse.pl');
+
+#:% section = setup
+Context("LinearRelation");
+
+do {
+    $a = random(2, 6);
+    $b = random(2, 6);
+} until ($a != $b);
+$ab = $a * $b;
+
+$lr = LinearRelation("$a x + $b y < $ab")->reduce;
+
+#:% section = statement
+#: Everything is as usual. Insert the fraction and answer blanks using `$showfraction`.
+BEGIN_PGML
+The line [`L`] that passes through the point [`([$b],0)`] and [`(0,[$a])`] divides
+the [`xy`]-plane.  What is the linear relation that describes the set of
+points in half-plane containing the origin?  Note, do not include the
+points on the line?
+
+[__]{$lr}
+
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+[`[$lr]`]
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/Logarithms.pg b/tutorial/sample-problems/Algebra/Logarithms.pg
new file mode 100644
index 0000000000..d11b26721c
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/Logarithms.pg
@@ -0,0 +1,64 @@
+## DESCRIPTION
+## Laws of logarithms
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'laws of logarithms')
+
+#:% name = Logarithms
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [logarithm]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We add the variables to the context and reset their limits since logarithms are
+#: not defined on the default domain [-1,1]. After defining `$answer`, then we
+#: undefine certain operators and functions so that students will have to simplify
+#: their answer. Since the answer requires multiplication no matter how it is written,
+#: we cannot prevent students from entering an answer such as `ln(x*x*x...)` instead
+#: of `$a * ln(x)`, but by choosing large values for `$a, $b, $c`, we can strongly
+#: discourage them from entering `ln(x*x*x...)`.
+Context()->variables->are(x => 'Real', y => 'Real', z => 'Real');
+Context()->variables->set(x => { limits => [ 2, 3 ] });
+Context()->variables->set(y => { limits => [ 2, 3 ] });
+Context()->variables->set(z => { limits => [ 2, 3 ] });
+
+$a = random(20, 40);
+$b = random(20, 40);
+do { $c = random(20, 40); } until ($c != $b);
+
+# TeX
+$expr =
+    "\displaystyle \ln \left( \frac{ x^{$a} y^{$b} }{ z^{$c} } \right)";
+
+$answer = Compute("$a * ln(x) + $b * ln(y) - $c * ln(z)");
+
+Context()->operators->undefine('/', '^', '**');
+Context()->functions->undefine('sqrt');
+
+#:% section = statement
+BEGIN_PGML
+Using laws of logarithms, write the expression below using sums and/or
+differences of logarithmic expressions which do not contain the logarithms of
+products, quotients, or powers.
+
+[`\displaystyle [$expr] =`] [_]{$answer}{20}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/PointAnswers.pg b/tutorial/sample-problems/Algebra/PointAnswers.pg
new file mode 100644
index 0000000000..3b4c2d6970
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/PointAnswers.pg
@@ -0,0 +1,58 @@
+## DESCRIPTION
+## Answers are lists of points
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'list of points')
+
+#:% name = Answers are a list of points
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [point, answers]
+
+#:% section = preamble
+#: We only need to load `contextLimitedPoint.pl` if we want to prevent operations between points.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextLimitedPoint.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We could have used `Context("Point");` instead, which would allow mathematical
+#: operations between points (such as adding points as if they were vectors). The
+#: x-intercepts are clearly a list of points. We used a list with only one element
+#: for the y-intercepts so that a student who mistakenly enters two points will be
+#: told their second point is incorrect. If we did not use a list for the y-intercepts,
+#: a student who enters two points would be given an error message instead.
+Context('LimitedPoint');
+
+$f = Compute("x^2 - 1");
+
+$xint = List(Point("(1, 0)"), Point("(-1, 0)"));
+$yint = List(Point("(0, -1)"));
+
+#:% section = statement
+#: Be sure to tell students the proper syntax for how to enter their answers.
+BEGIN_PGML
+Enter the [`x`]-intercept(s) and [`y`]-intercept(s) of [`y = [$f]`].  Enter a
+point as [`(a,b)`], including the parentheses.  If there is more than one
+correct answer, enter a comma separated list of points.
+
++ [`x`]-intercept(s): [_]{$xint}{15}
+
++ [`y`]-intercept(s): [_]{$yint}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+COMMENT('MathObject version. Uses PGML.');
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/ScalingTranslating.pg b/tutorial/sample-problems/Algebra/ScalingTranslating.pg
new file mode 100644
index 0000000000..a03891ef1a
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/ScalingTranslating.pg
@@ -0,0 +1,48 @@
+## DESCRIPTION
+## Scaling and translating functions
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'scaling and translating functions')
+
+#:% name = Scaling and Translating a Function
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [transformation]
+
+#:% section = preamble
+#: We must load `parserFunction.pl` so that we can add a named function to the context.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserFunction.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The `parserFunction` method allows us to add a named function to the context. We can
+#: define this function however we want, so we chose a function whose formula the
+#: students will not guess, whose domain is all real numbers, and which will have no
+#: issues during answer evaluation. Once a named function is added to the context, you
+#: can use it like you would any other named function.
+parserFunction(f => 'sin(e * x) + 5.5 * pi * x^2');
+
+$answer = Formula('f(x - 2) + 1');
+
+#:% section = statement
+BEGIN_PGML
+A function [`f(x)`] is shifted to the right [`2`] units and up [`1`] unit.  Find
+a formula for this shifted function in terms of the function [`f(x)`].
+
+[_]{$answer}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/SimpleFactoring.pg b/tutorial/sample-problems/Algebra/SimpleFactoring.pg
new file mode 100644
index 0000000000..bc26843ba8
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/SimpleFactoring.pg
@@ -0,0 +1,77 @@
+## DESCRIPTION
+## Factored polynomial
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('algebra', 'factored polynomial')
+
+#:% name = Simple factoring
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [polynomial]
+#:% see_also = [FactoredPolynomial.pg, ExpandedPolynomial.pg, FactoringAndExpanding.pg]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+#:% section = setup
+#: First, we create two random roots and then create the factors.  Note:
+#: the `->reduce` will help make `x-(-3)` into `x+3`.  In addition, we
+#: create the expanded form of the quadratic.
+#:
+#: Note that the argument of the List call are the objects in the list,
+#: which can be any MathObjects. Here we create a list of Formulas and a list
+#: of Reals (the numbers that we use in the second list will be promoted to
+#: Real MathObjects when the List is created).
+#:
+#: If, for example, there were no real roots, we should set
+#: `$roots = List("NONE");` so that students who enter a list of roots will not
+#: receive an error message about entering the wrong type of answer. If we were
+#: to use `$roots = String("NONE");` instead, students who enter anything
+#: other than a string (e.g., a list of numbers) will receive an error message.
+#:
+#: Similarly, if there were only one root at x=4, we would use
+#: `$roots = List(4);` instead of $roots = Real(4); to avoid sending error
+#: messages to students who enter multiple answers or NONE.
+($x0, $x1) = (non_zero_random(-6, 6), non_zero_random(-6, 6));
+$factor1 = Compute("x-$x0")->reduce;
+$factor2 = Compute("x-$x1")->reduce;
+$f       = Compute("x^2-($x0+$x1)x+$x0*$x1")->reduce;
+$factors = List($factor1, $factor2);
+$roots   = List($x0,      $x1);
+
+# If there were only one solution
+# $roots = List(4);
+
+# If there were no solutions
+# $roots = List("NONE");
+
+#:% section = statement
+BEGIN_PGML
+a) What are the factors of [`[$f]`]?
+
+    Factors = [__]{$factors}
+
+
+b) What are the roots of this equation?
+
+    Roots = [__]{$roots}
+
+_(Enter both answers as a comma-separated list.)_
+
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/SolutionForEquation.pg b/tutorial/sample-problems/Algebra/SolutionForEquation.pg
new file mode 100644
index 0000000000..d0c0889b59
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/SolutionForEquation.pg
@@ -0,0 +1,45 @@
+## DESCRIPTION
+## Answer is any solution to an equation
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'answer is any solution to an equation')
+
+#:% name = Solution for an Equation
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [algebra]
+
+#:% section = preamble
+#: The macro `parserSolutionFor.pl` must be loaded.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserSolutionFor.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We use `SolutionFor(equation, point)` to define this MathObject. For more
+#: details and options, see PODLINK('parserSolutionFor.pl').
+Context('Vector');
+
+$r      = random(3, 6);
+$answer = SolutionFor("x^2 + y^2 + z^2 = $r^2", [ $r, 0, 0 ]);
+
+$eqn = $answer->{f};
+
+#:% section = statement
+BEGIN_PGML
+A solution to the equation [`[$eqn]`] is [`(x, y, z) =`] [_]{$answer}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/StringOrOtherType.pg b/tutorial/sample-problems/Algebra/StringOrOtherType.pg
new file mode 100644
index 0000000000..4b897c674f
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/StringOrOtherType.pg
@@ -0,0 +1,57 @@
+## DESCRIPTION
+## Answer could be a string or another data type
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'answer is a string or other data type')
+
+#:% name = String or Other Type
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [strings]
+#:% see_also = [StringsInContext.pg]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: There are several predefined strings, such as NONE, DNE, INF, INFINITY. If you
+#: need another string added to the context, see PROBLINK('StringsInContext.pg').
+#:
+#: When `$answer = Formula('2x')` and a student enters the string `NONE`, they will
+#: not get any error message because when the answer checker expects a formula and
+#: gets a string it is set up not to balk. However, when `$answer = String('none')`
+#: and a student enters the formula `2x`, they will get an error message. This is
+#: because the answer checker is expecting a string and gets a formula, and when
+#: this happens it balks. We must use `typeMatch => Formula('x')` so that in the event
+#: the answer is a string, no error message will appear.
+$y = random(0, 4);
+
+if ($y < 4) {
+    $answer = String('none')->cmp(typeMatch => Formula('x'));
+} else {
+    $answer = Formula('2*x')->cmp(typeMatch => Formula('x'));
+}
+
+#:% section = statement
+BEGIN_PGML
+Is there a line through the points [`(0, 0)`], [`(1, 2)`], and [`(2, [$y])`]?
+If there is, enter the equation for this line.  If not, enter _NONE_.
+
+[`y =`] [_]{$answer}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/TableOfValues.pg b/tutorial/sample-problems/Algebra/TableOfValues.pg
new file mode 100644
index 0000000000..4af120d27d
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/TableOfValues.pg
@@ -0,0 +1,67 @@
+## DESCRIPTION
+## Function table of values
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'function table of values')
+
+#:% name = Table of Values
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [table]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'niceTables.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We create an empty array `@answer` and use a for loop to simplify filling it
+#: with values.
+#:
+#: The `DataTable` is from PODLINK('niceTables.pl').  This builds a simple table. The options
+#: `horizontalrules` and `texalignment` gives the borders around each of the cells.
+$f = Formula('3^(-x)');
+
+@answer = ();
+for $i (0 .. 2) {
+    $answer[$i] = $f->eval(x => $i);
+}
+
+$table = DataTable(
+    [
+        [ '\(x\)', '\(f(x)\)' ],
+        [ '\(0\)', ans_rule(4) ],
+        [ '\(1\)', ans_rule(4) ],
+        [ '\(2\)', ans_rule(4) ],
+    ],
+    horizontalrules => 1,
+    texalignment    => '|c|c|'
+);
+
+#:% section = statement
+BEGIN_PGML
+If [`f(x) = [$f]`], fill in the table of values with numbers.
+
+[@ $table @]*
+END_PGML
+
+#:% section = answer
+#: Because the answer blanks are built with `ans_rule` inside the table, we
+#: need to use the traditional `ANS` call here.
+for $i (0 .. 2) {
+    ANS($answer[$i]->cmp);
+}
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Algebra/UnorderedAnswers.pg b/tutorial/sample-problems/Algebra/UnorderedAnswers.pg
new file mode 100644
index 0000000000..3c27baf3c1
--- /dev/null
+++ b/tutorial/sample-problems/Algebra/UnorderedAnswers.pg
@@ -0,0 +1,57 @@
+## DESCRIPTION
+## Answers can be entered in any order into answer blanks
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'answers can be entered in any order')
+
+#:% name = Unordered Answers
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [answer]
+
+#:% section = preamble
+#: The macro `unorderedAnswer.pl` must be loaded.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'unorderedAnswer.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Because the answers have the variables x, y, and z, add the latter two.
+Context()->variables->add(y => 'Real', z => 'Real');
+
+$a = random(2, 9);
+
+$answer1 = Compute("x^$a");
+$answer2 = Compute("y^$a");
+$answer3 = Compute("z^$a");
+
+#:% section = statement
+BEGIN_PGML
+Rewrite the following expression without parentheses. Simplify your answer as
+much as possible.
+
+[`(xyz)^{[$a]} =`] [_____] [`\cdot`] [_____] [`\cdot`] [_____]
+END_PGML
+
+#:% section = answer
+#: We use `UNORDERED_ANS(checker1, checker2, ...);` to evaluate the answers. It is
+#: possible to withhold feedback and credit until everything is correct by using
+#: the standard problem grader, which awards no partial credit and full credit
+#: only when everything is correct.
+$showPartialCorrectAnswers = 0;
+
+UNORDERED_ANS($answer1->cmp, $answer2->cmp, $answer3->cmp);
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Complex/ComplexOperations.pg b/tutorial/sample-problems/Complex/ComplexOperations.pg
new file mode 100644
index 0000000000..7df510d8f6
--- /dev/null
+++ b/tutorial/sample-problems/Complex/ComplexOperations.pg
@@ -0,0 +1,67 @@
+## DESCRIPTION
+## This demonstrates basic operations with complex numbers.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('complex','addition','subtraction','absolute value')
+
+#:% name = Basic Operations of Complex numbers
+#:% type = [technique]
+#:% subject = [complex]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: To use complex numbers, we need to switch context with `Context('Complex')`.
+#: There are many ways to create a complex number.  Notice on the 4th one
+#: `i` is defined and can be used naturally.
+#:
+#: Also, the standard operations go through as expected.
+#: Notice that for the first two questions, we give the store the answer in
+#: a variable.
+Context('Complex');
+
+$z0 = Complex(non_zero_random(-5, 4), non_zero_random(-5, 5));
+$z1 = Complex([ -1, 4 ]);
+$z2 = Complex("2-4i");
+$z3 = 3 - 4 * i;
+
+$ans1 = $z0 + $z1;
+$a0   = non_zero_random(-4, 4);
+$a1   = random(1, 5);
+$ans2 = Compute("$a0*$z1-$a1*$z2");
+
+#:% section = statement
+#: Note that in the last three answer blanks, the correct answer is
+#: in the `{}` instead of stored as a variable, like the first two.
+#: Either method is correct and it varies on which to use.
+#: Recall that the perl power `**` is used in the last one.
+BEGIN_PGML
+Let [`z_0=[$z0]`], [`z_1=[$z1]`], [`z_2=[$z2]`] and [`z_3=[$z3]`]. Find
+
+[`z_0+z_1=`] [___]{$ans1}
+
+[`[$a0]z_1-[$a1]z_2=`] [_____]{$ans2}
+
+[`z_1z_2=`] [___]{$z1*$z2}
+
+[``\frac{z_3}{z_0}= ``] [___]{$z3/$z0}
+
+[`` z_2^2=``] [__]{$z2**2}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Complex/LimitedComplex.pg b/tutorial/sample-problems/Complex/LimitedComplex.pg
new file mode 100644
index 0000000000..ccb8ba02ee
--- /dev/null
+++ b/tutorial/sample-problems/Complex/LimitedComplex.pg
@@ -0,0 +1,79 @@
+## DESCRIPTION
+## This shows the capabilities of the LimitedComplex context.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('complex','addition','subtraction','absolute value')
+
+#:% name = Complex Numbers, Limited Input
+#:% type = [technique]
+#:% subject = [complex]
+
+#:% section = preamble
+#: This problems shows the capabilities of the `contextLimitedComplex.pl` macro
+#: so it must be loaded.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',            'PGML.pl',
+    'contextLimitedComplex.pl', 'PGcourse.pl'
+);
+
+#:% section = setup
+#: If we ask students to do operations with complex numbers, often we don't
+#: want those operations to be allowed in the answer.  In this case we set the
+#: `Context('LimitedComplex')`. If we define complex numbers, then perl operations
+#: will be allowed, but not operations in `Compute` functions.
+#:
+#: `LimitedComplex` will allow a single number entered (technically only one
+#: value of `i`) in either cartesian or polar form.  This problem gives the
+#: answer in polar to check that form.
+#:
+#: If you only want complex numbers to be entered in cartesian form you can use
+#: `Context('LimitedComplex-cartesian')` and if you only want students to
+#: enter numbers in polar form use `Context('LimitedComplex-polar')`.
+Context('LimitedComplex');
+
+$x0 = non_zero_random(-5, 5);
+$y0 = non_zero_random(-5, 5);
+$x1 = non_zero_random(-5, 5);
+$y1 = non_zero_random(-5, 5);
+
+$z0 = Complex($x0, $y0);
+$z1 = Complex($x1, $y1);
+
+$ans1 = $z0 + $z1;
+$ans2 = $z0 * $z1;
+
+# Determine the polar form of the answer to give a hint.  Since in
+# LimitedComplex, most functions are diasbled, so we work on the components.
+$arg0 = atan($y0 / $x0) + ($x0 > 0 ? ($y0 > 0 ? 0 : 2 * pi) : pi);
+$arg1 = atan($y1 / $x1) + ($x1 > 0 ? ($y1 > 0 ? 0 : 2 * pi) : pi);
+$abs0 = sqrt($x0**2 + $y0**2);
+$abs1 = sqrt($x1**2 + $y1**2);
+
+#:% section = statement
+BEGIN_PGML
+Let [`z_0=[$z0]`] and [`z_1=[$z1]`]. Find
+
+[`z_0+z_1=`] [___]{$ans1}
+
+[`z_0z_1=`] [___]{$ans2}
+
+You may not enter operations between numbers for these answers.  However,
+if you want the polar form (the second answer is [`[@ $abs0*$abs1 @] e^{[@ $arg0+$arg1 @]i}`])
+
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Complex/OtherOperations.pg b/tutorial/sample-problems/Complex/OtherOperations.pg
new file mode 100644
index 0000000000..422325521e
--- /dev/null
+++ b/tutorial/sample-problems/Complex/OtherOperations.pg
@@ -0,0 +1,62 @@
+## DESCRIPTION
+## Other complex operations.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('complex','addition','subtraction','absolute value')
+
+#:% name = Other Operations of Complex numbers
+#:% type = [technique]
+#:% subject = [complex]
+#:% see_also = [ComplexOperations.pg]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: To use complex numbers, we need to switch context with `Context('Complex')`.
+#: The problem PROBLINK('ComplexOperations.pg') showed different ways of
+#: creating complex numbers.
+#:
+#: This shows the functions `Re` (real part), `Im` (imaginary part), `abs`
+#: (absolute value or modulus -- distance from the origin), `arg` (the angle
+#: the point is from the positive real axis) and `conj`,
+#: (the complex conjugate)
+Context('Complex');
+
+$z0 = Complex(non_zero_random(-5, 4), non_zero_random(-5, 5));
+$z1 = Complex(non_zero_random(-5, 4), non_zero_random(-5, 5));
+$z2 = Complex(non_zero_random(-5, 4), non_zero_random(-5, 5));
+
+#:% section = statement
+#: All of the answers here are placed in the `{}` instead of making another
+#: variable.
+BEGIN_PGML
+Let [`z_0=[$z0]`], [`z_1=[$z1]`], and [`z_2=[$z2]`]. Find
+
+[`\text{Re}(z_0)=`] [___]{Re($z0)}
+
+[`\text{Im}(z_0)=`] [_____]{Im($z0)}
+
+[`|z_1|=`] [___]{abs($z1)}
+
+[`\text{arg}(z_1)=`] [___]{arg($z1)}
+
+[`\text{conj}(z_2)=`] [___]{conj($z2)}
+
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/DiffCalc/AnswerWithUnits.pg b/tutorial/sample-problems/DiffCalc/AnswerWithUnits.pg
new file mode 100644
index 0000000000..7550e9806c
--- /dev/null
+++ b/tutorial/sample-problems/DiffCalc/AnswerWithUnits.pg
@@ -0,0 +1,74 @@
+## DESCRIPTION
+## Answer is a number or formula with units
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('differential calculus', 'units')
+
+#:% name = Answer with Units
+#:% type = Sample
+#:% subject = differential calculus
+#:% categories = [units]
+
+#:% section = preamble
+#: We load `parserNumberWithUnits.pl` and `parserFormulaWithUnits.pl`.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',            'PGML.pl',
+    'parserNumberWithUnits.pl', 'parserFormulaWithUnits.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: We use the differentiation operator `->D('t')` and the evaluation method `->eval()` to
+#: construct the derivative and evaluate it as a function. If we were writing several
+#: questions like this with different height functions, using the differentiation and
+#: evaluation methods would really speed up the writing.
+Context()->variables->are(t => 'Real');
+
+$h  = Formula('-16 t^2 + 16');
+$v  = $h->D('t');
+$v1 = $v->eval(t => 1);
+$a  = $v->D('t');
+
+$ans1 = FormulaWithUnits("$v", 'ft/s');
+$ans2 = NumberWithUnits("$v1", 'ft/s');
+$ans3 = FormulaWithUnits("$a", 'ft/s^2');
+
+#:% section = statement
+#: Don't forget to use `helpLink('units')` so your students will have access to the
+#: complete list of units that WeBWorK understands.
+BEGIN_PGML
+Suppose the height of a falling object, in feet above the ground, is given
+by [`h(t) = [$h]`] for [`t \geq 0`], where time is measured in seconds.
+
+a. What is the velocity of the object?  Include units in your answer.
+
+    [_]{$ans1}{15}
+
+b. What is the velocity of the object when it hits the ground?  Include units in
+your answer.
+
+    [_]{$ans2}{15}
+
+c. What is the acceleration of the object?  Include units in your answer.
+
+    [_]{$ans3}{15}
+
+Note: use units in all answers. [@ helpLink('units') @]*
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/DiffCalc/DifferenceQuotient.pg b/tutorial/sample-problems/DiffCalc/DifferenceQuotient.pg
new file mode 100644
index 0000000000..d6913c3746
--- /dev/null
+++ b/tutorial/sample-problems/DiffCalc/DifferenceQuotient.pg
@@ -0,0 +1,52 @@
+## DESCRIPTION
+## Difference quotients
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('differential calculus', 'difference quotients')
+
+#:% name = Difference Quotient
+#:% type = Sample
+#:% subject = differential calculus
+#:% categories = [difference quotient]
+
+#:% section = preamble
+#: We need to include the macros file `parserDifferenceQuotient.pl`.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',               'PGML.pl',
+    'parserDifferenceQuotient.pl', 'PGcourse.pl'
+);
+
+#:% section = setup
+#: The routine DifferenceQuotient('function', 'variable') takes the simplified function
+#: and a variable name. If the variable is omitted, dx is used by default.
+$limit = DifferenceQuotient('2 * x + h', 'h');
+
+$fp = Compute('2 x');
+
+#:% section = statement
+BEGIN_PGML
+Simplify and then evaluate the limit.
+
+[``
+    \frac{d}{dx} \big( x^2 \big)
+    = \lim_{h \to 0} \frac{(x+h)^2-x^2}{h}
+    = \lim_{h \to 0} \Big(
+``] [_]{$limit}{15} [``\Big) =``] [_]{$fp}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/DiffCalc/DifferentiateFunction.pg b/tutorial/sample-problems/DiffCalc/DifferentiateFunction.pg
new file mode 100644
index 0000000000..2c831ebeed
--- /dev/null
+++ b/tutorial/sample-problems/DiffCalc/DifferentiateFunction.pg
@@ -0,0 +1,89 @@
+## DESCRIPTION
+## Difference quotients
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('differential calculus', 'difference quotients')
+
+#:% name = Differentiate a Function
+#:% type = Sample
+#:% subject = differential calculus
+#:% categories = [difference quotient]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The partial differentiation operator is `->D('x')`.
+#:
+#: The main difference between `eval()` and `substitute()` is
+#:
+#:   - `eval()` returns a `Real` (a number)
+#:   - `substitute()` returns a `Formula`
+#:
+#: Since plugging a particular number `$k` into the Formula `$f` returns a Formula `$k x`,
+#: if we had used the eval method `$ans2 = $fx->eval(k => $k);` instead of the `substitute`
+#: method, we would get errors because `$k x` is a Formula, not a Real. Note: You cannot
+#: use eval or substitute to perform function composition, i.e., you can only plug in
+#: numbers, not formulas.
+#:
+#: When the answer is a constant, we can use either the eval method, in which case the
+#: answer would be a Real, or the substitute method, in which case the answer would
+#: be a constant Formula. If you use the eval method, `$ans3 = $fx->eval(x => $a * pi, k => $k);`
+#: the answer will be a Real and will display as a single number in decimal format.
+#: If you use the substitute method instead, you have more control over how the answer
+#: will be displayed. In particular, the context flag reduceConstants controls whether
+#: the answer will be reduced to a single number in decimal format, the flag
+#: reduceConstantFunctions controls whether or not expressions such as `4 + 5 * 2` are
+#: reduced to 14, and setting the context flag `formatStudentAnswer => 'parsed'` will
+#: prevent the student's answer from being reduced to a single number in decimal
+#: format and will also display pi instead of 3.14159...
+#:
+#: For more details, see eval versus substitute, formatting correct answers, and
+#: constants in problems.
+Context()->variables->add(k => 'Real');
+Context()->flags->set(
+    reduceConstants         => 0,           # no decimals
+    reduceConstantFunctions => 1,           # simplify 4 + 5 * 2?
+    formatStudentAnswer     => 'parsed',    # no decimals
+);
+
+$a = random(6, 9);
+$k = random(3, 5);
+
+$f  = Formula('k x^2');
+$fx = $f->D('x');
+
+$ans1 = $fx;
+
+$ans2 = $fx->substitute(k => $k);    # formula
+# $ans2 = $fx->eval(k => $k); # gives errors, must eval to real
+
+$ans3 = $fx->substitute(x => $a * pi, k => $k);    # formula
+# $ans3 = $fx->eval(x => $a * pi, k => $k); # real
+
+#:% section = statement
+BEGIN_PGML
+Suppose [`f(x) = [$f]`] where [`k`] is a constant.
+
+a. [`f'(x) =`] [_____]{$ans1}
+
+b. If [`k = [$k]`] then [`f'(x) =`] [_____]{$ans2}
+
+c. If [`k = [$k]`] then [`f'([$a]\pi) =`] [_____]{$ans3}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/DiffCalc/LinearApprox.pg b/tutorial/sample-problems/DiffCalc/LinearApprox.pg
new file mode 100644
index 0000000000..d92ae3d8cb
--- /dev/null
+++ b/tutorial/sample-problems/DiffCalc/LinearApprox.pg
@@ -0,0 +1,70 @@
+## DESCRIPTION
+## Linear approximation
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('differential calculus', 'linear approximation')
+
+#:% name = Linear Approximation
+#:% type = Sample
+#:% subject = differential calculus
+#:% categories = [linear approximation]
+
+#:% section = preamble
+#: We load `parserAssignment.pl` to require students to enter their answer as an equation
+#: of the form `y = ...` We load `answerHints.pl` to provide customized answer hints,
+#: particularly for those students who enter the slope of the line instead of the
+#: equation of the line.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',  'PGML.pl',
+    'answerHints.pl', 'parserAssignment.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: We have to tell the context that we are allowing the assignment of a variable to a formula.
+#:
+#: We use answer hints to remind students to enter an equation for a line, not
+#: just the slope of the line.
+Context()->variables->add(y => 'Real');
+parser::Assignment->Allow;
+
+$a  = random(2, 5);
+$aa = $a**2;
+$a2 = 2 * $a;
+
+$f = Compute('sqrt(x)');
+
+$answer = Compute("y = $a + (1/$a2) * (x-$aa)");
+$cmp    = $answer->cmp()->withPostFilter(AnswerHints(
+    [ Formula("1/$a2"), Formula("y=1/$a2") ] => [
+        'Your answer should be an equation for a non-horizontal line.',
+        replaceMessage => 1
+    ],
+));
+
+#:% section = statement
+#: The variable `$cmp` is used in the answer blank, which call the compare method
+#: define in the setup section.
+BEGIN_PGML
+Find the linear approximation to [`f(x) = [$f]`] at [`x = [$aa]`].  Your
+answer should be an equation in the variables [`x`] and [`y`].
+
+[_]{$cmp}{10}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
+
diff --git a/tutorial/sample-problems/DiffCalcMV/ContourPlot.pg b/tutorial/sample-problems/DiffCalcMV/ContourPlot.pg
new file mode 100644
index 0000000000..c6b8ea3e44
--- /dev/null
+++ b/tutorial/sample-problems/DiffCalcMV/ContourPlot.pg
@@ -0,0 +1,81 @@
+## DESCRIPTION
+## Creating a contour plot
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('multivariable differential calculus', 'contour plot')
+
+#:% name = Contour Plot
+#:% type = [Sample, technique]
+#:% subject = multivariate calculus
+#:% categories = [plots]
+
+#:% section = preamble
+#: We will use `PGtikz.pl` for constructing the graph. The macro
+#: `parserPopUp.pl` is used to include the popup.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl', 'PGML.pl', 'parserPopUp.pl', 'PGtikz.pl',
+    'PGcourse.pl'
+);
+
+$showPartialCorrectAnswers = 0;
+
+#:% section = setup
+#: The contour plot is created with TikZ by overlaying circles with differing
+#: shades of blue. See the POD and the [TikZ manual](https://tikz.dev/) for more
+#: information.
+#:
+#: If the colored contour plot is not desired, replace the `\filldraw` line
+#: with the following:
+#:```{#change-contour .perl}
+#: \draw (0,0) circle [radius={sqrt(64-8*\n)}];
+#:```
+$graph = createTikZImage();
+$graph->tikzLibraries('arrows.meta');
+$graph->BEGIN_TIKZ
+\tikzset{>={Stealth[scale=2]}}
+\Large % Make the fonts a little bigger.
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-7,-7) rectangle (7,7);
+\foreach \n in {0,...,7} {
+    \pgfmathsetmacro\k{100-\n*10}
+    \filldraw[fill=blue!\k!white,fill opacity=0.5]
+        (0,0) circle [radius={sqrt(64-8*\n)}];
+}
+\draw[->] (-7,0) -- (7,0) node[above left,outer sep=3pt] {\(x\)};
+\foreach \x in {-6,...,-1,1,2,...,6}
+    \draw(\x,5pt) -- (\x,-5pt) node [below] {\(\x\)};
+\draw[->] (0,-7) -- (0,7) node[below right,outer sep=3pt] {\(y\)};
+\foreach \y in {-6,...,-1,1,2,...,6}
+    \draw (5pt,\y) -- (-5pt,\y) node[left] {\(\y\)};
+END_TIKZ
+
+$popup = DropDownTF('false', placeholder => 'Select One');
+
+#:% section = statement
+BEGIN_PGML
+Determine if the following statement is true or false.
+
+[_]{$popup} This could be a contour plot for [`f(x,y) = x^2 - y^2`].
+
+>> [@ image($graph, width => 300, height => 300, tex_size => 450) @]* <<
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/DiffCalcMV/ImplicitPlane.pg b/tutorial/sample-problems/DiffCalcMV/ImplicitPlane.pg
new file mode 100644
index 0000000000..de9d0066da
--- /dev/null
+++ b/tutorial/sample-problems/DiffCalcMV/ImplicitPlane.pg
@@ -0,0 +1,75 @@
+## DESCRIPTION
+## Multivariable differential calculus: answer is an equation for a plane
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('multivariable differential calculus', 'answer is an equation for a plane')
+
+#:% name = Implicit Plane
+#:% type = Sample
+#:% subject = multivariate calculus
+#:% categories = [implicit function]
+
+#:% section = preamble
+#: * The parserVectorUtils.pl macro is used for the non_zero_point3D function below.
+#: * The parserImplicitPlane.pl macro includes the context and the ImplicitPlane
+#:   function to parse and create implicit planes.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',          'PGML.pl',
+    'parserImplicitPlane.pl', 'parserVectorUtils.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: The first answer is a standard mulitivariable calculus question. There are several
+#: different ways to specify the input to `ImplicitPlane`, which are detailed in the POD
+#: documentation. It is also possible to do some more complicated manipulations with
+#: the vectors and points, which is detailed in the problem techniques section.
+#:
+#: When the `ImplicitPlane` context has only two variables, it rephrases error messages
+#: in terms of lines. If you want students to be able to enter an equation for a line
+#: in the most general form, or if you have a vertical line to check (or just a
+#: constant equation such as `x = 3`), you can use the `ImplicitPlane` context to reliably
+#: check these answers.
+Context('ImplicitPlane');
+Context()->variables->are(x => 'Real', y => 'Real', z => 'Real');
+
+$A = non_zero_point3D(-5, 5);
+$N = non_zero_vector3D(-5, 5);
+
+$ans1 = ImplicitPlane($A, $N);
+$ans2 = ImplicitPlane('4x + 3y = 12');
+$ans3 = ImplicitPlane('x = 3');
+
+#:% section = statement
+BEGIN_PGML
+a. Enter an equation for the plane through the point [`[$A]`] and perpendicular
+to [`[$N]`].
+
+    + [_]{$ans1}{15}
+
+b. Enter an equation for the line in the [`xy`]-plane with [`x`]-intercept [`3`]
+and [`y`]-intercept [`4`].
+
+    + [_]{$ans2}{15}
+
+c. Enter an equation for the vertical line in the [`xy`]-plane through the
+point [`(3,1)`].
+
+    + [_]{$ans3}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/DiffEq/GeneralSolutionODE.pg b/tutorial/sample-problems/DiffEq/GeneralSolutionODE.pg
new file mode 100644
index 0000000000..f8003f090f
--- /dev/null
+++ b/tutorial/sample-problems/DiffEq/GeneralSolutionODE.pg
@@ -0,0 +1,143 @@
+## DESCRIPTION
+## Use a custom answer checkers for ODEs to determine the general solution of a
+## Differential Equation
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('differential equations', 'custom answer checker')
+
+#:% name = General Solution to a Differential Equation
+#:% type = Sample
+#:% subject = differential equations
+#:% categories = [answers, custom]
+
+#:% section = preamble
+#: We load `parserAssignment.pl` to require student answers to be of the
+#: form `y = ...`.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserAssignment.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Add the arbitrary constants `c1, c2, c3` to the context as variables so that we can
+#: evaluate them later. Set the domain of function evaluation on these variables to
+#: something sensible. Use `parser::Assignment->Allow;` to allow equation answers of
+#: the form `y = ...`. See PODLINK('parserAssignment.pl') for additional information.
+#:
+#: For the checker, we use my `$stu = Formula($student->{tree}{rop});` to get the right
+#: side of the student answer (to get the left side, we could have used lop for the
+#: left operand). Use `Formula($stu->D('c1')) == Formula(0)` to check that the student
+#: actually has c1 in their answer.
+#:
+#: We substitute numerical values that the student is unlikely to choose for `c1, c2, c3`
+#: and then apply the Wronskian test for independence. Normally, we would check to see
+#: if the Wronskian was zero, but zero level tolerance in WeBWorK is much more
+#: stringent than non-zero level tolerance. So, we rearrange the terms of the
+#: Wronskian == 0 equation so that there are nonzero terms on both sides of the
+#: equation, and as a result we get a more reliable answer checker.
+#:
+#: Finally, we take several derivatives of the student answer and use them to check
+#: that the student answer actually satisfies the differential equation. Again, instead
+#: of checking (left side of ODE) == 0, we rearrange the terms of the differential
+#: equation to be of the form (some nonzero function) == (some other nonzero function)
+#: in order to get a more reliable answer checker.
+Context()->variables->add(
+    c1 => 'Real',
+    c2 => 'Real',
+    c3 => 'Real',
+    y  => 'Real',
+);
+Context()->flags->set(
+    formatStudentAnswer     => 'parsed',
+    reduceConstants         => 0,
+    reduceConstantFunctions => 0,
+);
+parser::Assignment->Allow;
+
+$a = list_random(2, 3, 5, 6, 7, 8);
+
+# char poly (r-1)(r^2 + $a)
+
+$answer = Compute("y = c1 e^x + c2 cos(sqrt($a) x) + c3 sin(sqrt($a) x)");
+
+$cmp = $answer->cmp(
+    checker => sub {
+
+        my ($correct, $student, $answerHash) = @_;
+        my $stu = Formula($student->{tree}{rop});
+
+        #  Check for arbitrary constants
+        Value->Error("Is your answer the most general solution?")
+            if (Formula($stu->D('c1')) == Formula(0)
+                || Formula($stu->D('c2')) == Formula(0)
+                || Formula($stu->D('c3')) == Formula(0));
+
+        #  Linear independence (Wronskian)
+        my $x = Real(1.43);
+
+        my $a11 =
+            $stu->eval('c1' => 1, 'c2' => 0, 'c3' => 0, x => $x, y => 0);
+        my $a12 =
+            $stu->eval('c1' => 0, 'c2' => 1, 'c3' => 0, x => $x, y => 0);
+        my $a13 =
+            $stu->eval('c1' => 0, 'c2' => 0, 'c3' => 1, x => $x, y => 0);
+
+        my $a21 = $stu->D('x')
+            ->eval('c1' => 1, 'c2' => 0, 'c3' => 0, x => $x, y => 0);
+        my $a22 = $stu->D('x')
+            ->eval('c1' => 0, 'c2' => 1, 'c3' => 0, x => $x, y => 0);
+        my $a23 = $stu->D('x')
+            ->eval('c1' => 0, 'c2' => 0, 'c3' => 1, x => $x, y => 0);
+
+        my $a31 = $stu->D('x', 'x')
+            ->eval('c1' => 1, 'c2' => 0, 'c3' => 0, x => $x, y => 0);
+        my $a32 = $stu->D('x', 'x')
+            ->eval('c1' => 0, 'c2' => 1, 'c3' => 0, x => $x, y => 0);
+        my $a33 = $stu->D('x', 'x')
+            ->eval('c1' => 0, 'c2' => 0, 'c3' => 1, x => $x, y => 0);
+
+        Value->Error(
+            'Your functions are not linearly independent or your answer is not complete'
+            )
+            if (
+                (
+                    $a11 * ($a22 * $a33 - $a32 * $a23) +
+                    $a13 * ($a21 * $a32 - $a31 * $a22)
+                ) == ($a12 * ($a21 * $a33 - $a31 * $a23))
+            );
+
+        #  Check that the student answer is a solution to the DE
+        my $stu1 = Formula($stu->D('x'));
+        my $stu2 = Formula($stu->D('x', 'x'));
+        my $stu3 = Formula($stu->D('x', 'x', 'x'));
+        return ($stu3 + $a * $stu1) == ($stu2 + $a * $stu);
+
+    }
+);
+
+#:% section = statement
+#: Give students detailed instructions about the format of the answer that is expected.
+BEGIN_PGML
+Find the general solution to
+[`y^{\,\prime\prime\prime} - y^{\,\prime\prime} + [$a] y^{\,\prime} - [$a] y = 0`].
+
+In your answer, use [`c_1`], [`c_2`] and [`c_3`] to denote arbitrary constants
+and [`x`] the independent variable.  Your answer should be an equation of the
+form [`y = \ldots`] and you should enter [`c_1`] as [|c1|]*,
+[`c_2`] as [|c2|]*, and [`c_3`] as [|c3|]*.
+
+[_]{$cmp}{30}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/DiffEq/HeavisideStep.pg b/tutorial/sample-problems/DiffEq/HeavisideStep.pg
new file mode 100644
index 0000000000..e4ba080d1d
--- /dev/null
+++ b/tutorial/sample-problems/DiffEq/HeavisideStep.pg
@@ -0,0 +1,119 @@
+## DESCRIPTION
+## Adding the Heaviside function to the context.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('differential equations', 'adding the Heaviside function to the context')
+
+#:% name = Heaviside or Step Function
+#:% type = Sample
+#:% subject = differential equations
+#:% categories = [heaviside-step]
+
+#:% section = preamble
+#: We load `parserFunction.pl` to make adding a named function to the context easier.
+#: Please see the POD documentation `parserFunction.pl`.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserFunction.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: We add the step function to the context with the name `step`. The function
+#: `step(t)` is the Heaviside function and takes the value 1 when $t > 0$, and the value
+#: 0 when $t \leq 0$. We will use the function `step` when evaluating the Heaviside function
+#: to obtain an answer that is a number.
+#:
+#: For more details on adding the Heaviside function to the context, see the forum
+#: discussion on the
+#: [Heaviside step function](https://webwork.maa.org/moodle/mod/forum/discuss.php?d=458).
+#:
+#: For the second question, since answers are checked numerically by comparing the student
+#: answer to the correct answer at several randomly points in the domain (the default is 5 points)
+#: in an interval (the default is `[-1,1]`), the function `step(t) = u(t)` is not very robust when
+#: checking answers using these defaults. For example, if a student types in the answer `u(t-0.1)` and
+#: the correct answer is u(t), there is a good chance that the student's answer will be marked correct,
+#: since the probability that a test point was chosen in the interval (0,0.1) is much less than 100%.
+#: Also, if the correct answer were u(t-5), then a student could enter the answer 0 and be marked correct
+#: because the correct answer is identically zero on the interval `[-1,1]`.
+#:
+#: To make the answer checking robust, in `$answer2` we specify a larger domain centered at `$a` using limits,
+#: we require four of the test points always be used, and that there should be 10 test points total (the
+#: four we specified and six others generated at random). Notice that we used the construction `$f->with(...)`
+#: to do this (using `$f->{test_at} = [[1],[2]]` would generate an error because the functions we added to the
+#: context aren't "blessed" with enough permissions to modify `$f` in that way).
+#:
+#: In part (b), since the students never actually see the values of the function u(t),
+#: we could have defined the function as
+#:
+#:```{#parser-function-call .perl}
+#: parserFunction("u(t)" => "1.5 * sin(e*t) + 5*pi/3 + arctan(t)");
+#:```
+#:
+#: If we had defined `u(t)` this way, we would not have had to add the function `step(t)` to the context
+#: and we could have used the defaults for the answer checker. Notice that the function `u(t)` is never
+#: zero, is not constant, is differentiable, and takes moderately sized values, which makes its answer
+#: checking very robust using the defaults for the answer checker. Further, because of the arctangent,
+#: it is not periodic and so `u(t)-u(t-a)` should never be identically zero. Also, the formula for `u(t)` is
+#: not something students are likely to input as an answer out of nowhere. The function `u(t)` is great as a
+#: named function that stands in for the Heaviside function when the answer is a function. However, if the
+#: answer is a number obtained by evaluating the Heaviside function, then step(t) should be used or the function
+#: `u(t)` should be properly defined as the Heaviside function for obvious reasons.
+Context()->variables->are(t => 'Real');
+Context()->functions->add(
+    step => {
+        class => 'Parser::Legacy::Numeric',
+        perl  => 'Parser::Legacy::Numeric::do_step'
+    },
+);
+
+parserFunction('u(t)' => 'step(t)');
+
+$a = random(3, 6);
+
+$f = Formula("5 u(t-$a)");
+
+$answer1 =
+    List($f->eval(t => $a - 1), $f->eval(t => $a), $f->eval(t => $a + 1));
+
+$answer2 = $f->with(
+    limits  => [ $a - 5, $a + 5 ],
+    test_at => [
+        [ $a - 1 ], [ $a - 0.0000001 ], [$a], [ $a + 0.0000001 ], [ $a + 1 ]
+    ],
+    num_points => 10,
+);
+
+#:% section = statement
+BEGIN_PGML
+Let [`u(t)`] be the Heaviside step function defined by
+[``
+    u(t) = \left\{
+        \begin{array}{lcl}
+            0 && \text{ if } x \leq 0, \\
+            1 && \text{ if } x > 0.
+        \end{array}
+    \right.
+``]
+
+a. Evaluate the function [`[$f]`] when [`t`] is [`[$a - 1]`], [`[$a]`], and
+[`[$a + 1]`] and enter your answers as a comma separated list.
+
+    + [_]{ $answer1->cmp(ordered => 1) }{15}
+
+b. Suppose the answer is the function [`[$f]`].
+
+    + [_]{$answer2}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/DiffEq/PrimesInFormulas.pg b/tutorial/sample-problems/DiffEq/PrimesInFormulas.pg
new file mode 100644
index 0000000000..890a05c774
--- /dev/null
+++ b/tutorial/sample-problems/DiffEq/PrimesInFormulas.pg
@@ -0,0 +1,62 @@
+## DESCRIPTION
+## Allowing primes in student answers.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('differential equations', 'allowing primes in student answers')
+
+#:% name = Primes in Formulas
+#:% type = Sample
+#:% subject = differential equations
+#:% categories = [answers]
+
+#:% section = preamble
+#: For this problem, we want to enter in differential equations, and the variables
+#: will be `y', y''` and the resulting equation will be implicit, so the macro
+#: `parserImplicitEquation.pl` is used.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',             'PGML.pl',
+    'parserImplicitEquation.pl', 'PGcourse.pl'
+);
+
+#:% section = setup
+#: We switch the context to `ImplicitEquation` and then includes the variable `y, y', y''`
+#: and `t`.  The line `Context()->variables->{namePattern} = qr/[ty]'*/i;` is used to make sure
+#: that primes can be included in the answer.
+Context('ImplicitEquation');
+Context()->variables->{namePattern} = qr/[ty]'*/i;
+Context()->variables->are(
+    'y'   => 'Real',
+    "y'"  => 'Real',
+    "y''" => 'Real',
+    't'   => 'Real',
+);
+
+$diffeq = ImplicitEquation("y'' + 2y' + y = cos(t)");
+
+#:% section = statement
+BEGIN_PGML
+Suppose this is a word problem that asks students to set up a differential
+equation and enter their differential equation as the answer.
+
+Enter your differential equation below in terms of [`y`], [`y^{\prime}`],
+[`y^{\prime\prime}`], [`t`].
+(Suppose the answer is the differential equation [`[$diffeq]`].)
+
+[_]{$diffeq}{20} [@ helpLink('equations') @]*
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/IntegralCalc/DoubleIntegral.pg b/tutorial/sample-problems/IntegralCalc/DoubleIntegral.pg
new file mode 100644
index 0000000000..4a7e296883
--- /dev/null
+++ b/tutorial/sample-problems/IntegralCalc/DoubleIntegral.pg
@@ -0,0 +1,188 @@
+## DESCRIPTION
+## Setting up double integrals
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('Integrals', 'setting up double integrals')
+
+#:% name = Double Integral
+#:% type = Sample
+#:% subject = multivariate calculus
+#:% categories = [double integral]
+
+#:% section = preamble
+#: Since there are multiple answer blanks that are dependent upon each other, we use `parserMultiAnswer.pl`.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserMultiAnswer.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: There are two separate cases: integrating with respect to dx dy (which we call case
+#: 0) or with respect to dy dx (which we call case 1). The zeroth and first entries
+#: in each of the arrays `@id, @od, @A, @B, @C, @D` hold the values for case 0 and case 1,
+#: respectively. We used constant limits of integration to keep this example easy to follow,
+#: but we encourage you to write questions over non-rectangular regions.
+#:
+#: The `$multians` object has been compartmentalized, so you shouldn't need to change it
+#: unless you want to fiddle with the weighted score for each answer blank (by changing
+#: the return values). The return values are set so that the percentages come out nicely.
+Context()->variables->are(
+    x  => 'Real',
+    dx => 'Real',
+    y  => 'Real',
+    dy => 'Real'
+);
+Context()->flags->set(reduceConstants => 0);
+
+# limits of integration
+
+$a = random(1, 5, 1);
+$b = $a + random(1, 4, 1);
+do { $c = random(1, 5, 1); }      until ($c != $a);
+do { $d = $c + random(1, 4, 1); } until ($d != $b);
+
+# integrand and volume
+
+$f = Formula('x * y');
+$V = Formula("($b^2-$a^2) * ($d^2-$c^2) / 4");
+
+# differentials and limits of integration
+# Case 0, element 0 of each array below, is if the order of integration is dx dy
+# Case 1, element 1 of each array below, is if the order of integration is dy dx
+# 'id' and 'od' stand for inner and outer differential
+
+@id = (Formula('dx'), Formula('dy'));    # (case 0, case 1)
+@od = (Formula('dy'), Formula('dx'));    # (case 0, case 1)
+
+# A = outer integral, lower limit
+# B = outer integral, upper limit
+# C = inner integral, lower limit
+# D = inner integral, upper limit
+
+@A = (Formula($c), Formula($a));    # (case 0, case 1)
+@B = (Formula($d), Formula($b));    # (case 0, case 1)
+@C = (Formula($a), Formula($c));    # (case 0, case 1)
+@D = (Formula($b), Formula($d));    # (case 0, case 1)
+
+$multians = MultiAnswer($f, $id[0], $od[0], $A[0], $B[0], $C[0], $D[0])->with(
+    singleResult => 1,
+    checker      => sub {
+        my ($correct, $student, $self) = @_;
+        my ($fstu, $idstu, $odstu, $Astu, $Bstu, $Cstu, $Dstu) =
+            @{$student};
+        if (
+            (
+                $f == $fstu
+                && $id[0] == $idstu
+                && $od[0] == $odstu
+                && $A[0] == $Astu
+                && $B[0] == $Bstu
+                && $C[0] == $Cstu
+                && $D[0] == $Dstu
+            )
+            || ($f == $fstu
+                && $id[1] == $idstu
+                && $od[1] == $odstu
+                && $A[1] == $Astu
+                && $B[1] == $Bstu
+                && $C[1] == $Cstu
+                && $D[1] == $Dstu)
+            )
+        {
+            return 1;
+        } elsif (
+            (
+                $f == $fstu
+                && $id[0] == $idstu
+                && $od[0] == $odstu
+                && ($A[0] != $Astu || $B[0] != $Bstu)
+                && $C[0] == $Cstu
+                && $D[0] == $Dstu
+            )
+            || ($f == $fstu
+                && $id[1] == $idstu
+                && $od[1] == $odstu
+                && ($A[1] != $Astu || $B[1] != $Bstu)
+                && $C[1] == $Cstu
+                && $D[1] == $Dstu)
+            || ($f == $fstu
+                && $id[0] == $idstu
+                && $od[0] == $odstu
+                && $A[0] == $Astu
+                && $B[0] == $Bstu
+                && ($C[0] != $Cstu || $D[0] != $Dstu))
+            || ($f == $fstu
+                && $id[1] == $idstu
+                && $od[1] == $odstu
+                && $A[1] == $Astu
+                && $B[1] == $Bstu
+                && ($C[1] != $Cstu || $D[1] != $Dstu))
+            )
+        {
+            $self->setMessage(1, 'Check your limits of integration.');
+            return 0.94;
+        } elsif (
+            (
+                $f == $fstu
+                && $id[0] == $idstu
+                && $od[0] == $odstu
+                && ($A[0] != $Astu || $B[0] != $Bstu)
+                && ($C[0] != $Cstu || $D[0] != $Dstu)
+            )
+            || ($f == $fstu
+                && $id[1] == $idstu
+                && $od[1] == $odstu
+                && ($A[1] != $Astu || $B[1] != $Bstu)
+                && ($C[1] != $Cstu || $D[1] != $Dstu))
+            )
+        {
+            $self->setMessage(1,
+                'Check your limits of integration and order of integration.'
+            );
+            return 0.47;
+        } else {
+            return 0;
+        }
+    }
+);
+
+#:% section = statement
+#: The only interesting thing to note here is that you must use `$multians` for each
+#: answer blank (except the last one, which is independent.)
+BEGIN_PGML
+Set up a double integral in rectangular coordinates for calculating the volume
+of the solid under the graph of the function [`f(x,y) = [$f]`] over the region
+[`[$a] \leq x \leq [$b]`] and [`[$c] \leq y \leq [$d]`].
+
+_Instructions:_ Please enter the integrand in the first answer box . Depending
+on the order of integration you choose, enter _dx_ and _dy_ in either order into
+the second and third answer boxes with only one _dx_ or _dy_ in each box . Then,
+enter the limits of integration and evaluate the integral to find the volume.
+
+[``\int_A^B \int_C^D``] [_]{$multians}{10} [_]{$multians}{5} [_]{$multians}{5}
+
+A = [_]{$multians}{10}
+
+B = [_]{$multians}{10}
+
+C = [_]{$multians}{10}
+
+D = [_]{$multians}{10}
+
+Volume = [_]{$V}{10}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+COMMENT('Allows integration in either order.');
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/IntegralCalc/GraphShading.pg b/tutorial/sample-problems/IntegralCalc/GraphShading.pg
new file mode 100644
index 0000000000..91e8682b10
--- /dev/null
+++ b/tutorial/sample-problems/IntegralCalc/GraphShading.pg
@@ -0,0 +1,84 @@
+## DESCRIPTION
+## Dynamically generated graph of a function with shading
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('calculus', 'dynamic graph with shading')
+
+#:% name = Graph Shading
+#:% type = Sample
+#:% subject = integral calculus
+#:% categories = [plots]
+
+#:% section = preamble
+#: The macro `PGikz.pl` is used to create the plot.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGtikz.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We create a randomly transformed version of `sqrt(x)` as the function with a
+#: reasonably straightforward answer.
+#:
+#: The `nicestring` function is useful for printing polynomials in a nice way.
+#:
+#: The graph is created with `PGtikz.pl`, a very robust plotting package. The
+#: shading in done with the `\filldraw` command with the `fill opacity=0.5`. Also
+#: note that one of the sides of the filled area is the square root function.
+$a    = random(-4, 2);
+$b    = random(1,  4);
+$g    = Compute("$b + sqrt(x - $a)");
+$gtex = "$b + \sqrt{" . nicestring([ 1, -$a ]) . '}';
+$ans  = Compute("3*$b + 14/3");
+
+$graph = createTikZImage();
+$graph->tikzLibraries('arrows.meta');
+$graph->BEGIN_TIKZ
+\tikzset{>={Stealth[scale=1.5]}}
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-6,-2) rectangle (6,8);
+\begin{scope}
+    \clip[rounded corners=14pt] (-6,-2) rectangle (6,8);
+    \draw[ultra thin] (-6,-2) grid (6,8);
+\end{scope}
+\draw[->,thick] (-6,0) -- (6,0) node[above left,outer sep=3pt] {\(x\)};
+\foreach \x in {-5,...,-1,1,2,...,5}
+    \draw(\x,5pt) -- (\x,-5pt) node[below] {\(\x\)};
+\draw[->,thick] (0,-2) -- (0,8) node[below right,outer sep=3pt] {\(y\)};
+\foreach \y in {-1,1,2,...,7}
+    \draw (5pt,\y) -- (-5pt,\y) node[left]{\(\y\)};
+\filldraw[draw=blue,fill=blue!50!white,fill opacity=0.5]
+    ({$a+1},0) -- ({$a+1},{$b+1})
+    -- plot[domain={$a+1}:{$a+4},samples=100] (\x,{$b+sqrt(\x-$a)})
+    -- ({$a+4},0) -- cycle;
+\draw[blue,ultra thick,->]
+    plot[domain={$a}:6,samples=100] (\x,{$b+sqrt(\x-$a)});
+END_TIKZ
+
+#:% section = statement
+BEGIN_PGML
+Use the graph to find the area of the shaded region under [`f(x) = [$gtex]`].
+
+>>[@ image($graph, width => 400, tex_size => 800) @]*<<
+
+>>Graph of [`y = f(x)`].<<
+
+Area: [_]{$ans}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/IntegralCalc/IndefiniteIntegrals.pg b/tutorial/sample-problems/IntegralCalc/IndefiniteIntegrals.pg
new file mode 100644
index 0000000000..6042d1c4c8
--- /dev/null
+++ b/tutorial/sample-problems/IntegralCalc/IndefiniteIntegrals.pg
@@ -0,0 +1,64 @@
+## DESCRIPTION
+## Indefinite integrals
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('integral calculus', 'indefinite integrals')
+
+#:% name = Indefinite Integrals
+#:% type = Sample
+#:% subject = integral calculus
+#:% categories = [antiderivatives]
+
+#:% section = preamble
+#: The macro `parserFormulaUpToConstant.pl` will allow the entry of formula with a
+#: general constant like the antiderivative.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',                'PGML.pl',
+    'parserFormulaUpToConstant.pl', 'PGcourse.pl'
+);
+
+#:% section = setup
+#: Examples of specific and general antiderivatives:
+#:
+#: - Specific antiderivatives: `e^x, e^x + pi`
+#: - General antiderivatives: `e^x + C`, `e^x + C - 3`, `e^x + K`
+#: The specific antiderivative is an ordinary formula, and we check this answer, we
+#: will specify that it be a formula evaluated up to a constant (see the first answer
+#: blank in the section below). For the general antiderivative, we use the
+#: `FormulaUpToConstant()` constructor provided by `parserFormulaUpToConstant.pl`.
+
+# Specific antiderivative:  Marks correct e^x, e^x + pi, etc
+$specific = Formula('e^x');
+
+#  General antiderivative: Marks correct e^x + C, e^x + C - 3, e^x + K, etc.
+$general = FormulaUpToConstant('e^x');
+
+#:% section = statement
+#: In the first answer blank, we look for the answer with an additive constant
+#: using the option `upToConstant => 1` in the `cmp` method.
+#:
+#: The second is a standard answer blank, but `$general` is created with.
+#: `FormulaUpToConstant`
+BEGIN_PGML
+a. Enter a specific antiderivative for [`e^x`]:
+[_]{ $specific->cmp(upToConstant => 1) }{10}
+
+b. Enter the most general antiderivative for [`e^x`]:
+[_]{$general}{10}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/IntegralCalc/LimitsOfIntegration.pg b/tutorial/sample-problems/IntegralCalc/LimitsOfIntegration.pg
new file mode 100644
index 0000000000..5aaf2d8abb
--- /dev/null
+++ b/tutorial/sample-problems/IntegralCalc/LimitsOfIntegration.pg
@@ -0,0 +1,91 @@
+## DESCRIPTION
+## Answer blanks in the limits of integration
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('Integrals', 'answer blanks in limits of integration')
+
+#:% name = Answer Blanks in Limits of Integration
+#:% type = Sample
+#:% subject = integral calculus
+#:% categories = [antiderivatives]
+
+#:% section = preamble
+#: We  use `niceTables.pl` for table formatting commands we will use to put
+#: the answer blanks in the limits of integration.  We use `answerHints.pl` to
+#: help guide students toward the correct answer.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl', 'PGML.pl', 'niceTables.pl', 'answerHints.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: We define both `x` and `t` as variables as well as the differential `dx`
+#: (which would be incorrect) and the correct `dt`.
+#:
+#: The `LayoutTable` of PODLINK('niceTables.pl') is used to display the
+#: definite integral.  Note that the `align => 'rl'` is used to get the
+#: formatting to look correct.
+Context()->variables->are(
+    x  => 'Real',
+    dx => 'Real',
+    t  => 'Real',
+    dt => 'Real'
+);
+
+$integral = LayoutTable(
+    [
+        [ ' ', ans_rule(4) ],
+        [
+            '\(f(x)= \)' . ans_rule(10) . '\(+\)',
+            '\(\displaystyle \int \;\;\)' . ans_rule(10)
+        ],
+        [ ' ', ans_rule(4) ],
+    ],
+    align      => 'rl',
+    allcellcss => { padding => '3pt' }
+);
+
+#:% section = statement
+#: The integral is placed in the problem with the `[$integral]*` which displays
+#: the table.
+BEGIN_PGML
+Find a formula for the function [`f(x)`] such that [`f '(x) = [$fpx]`] and
+[`f(2) = 5`].  Use [`t`] as the variable of integration inside the integral.
+
+[$integral]*
+END_PGML
+
+#:% section = answer
+#: The answer blanks are written out as `ans_rule`, so we must use this style of
+#: answer checking.  We use `AnswerHints` to guide the students to the correct answer.
+#: Note that we also include the incorrect answer with the `x` as the variable
+#: and give the student feedback on this.
+$fpx = Formula("sin(x)");
+$fpt = Formula("sin(t)");
+
+ANS(Compute('x')->cmp());
+ANS(Compute('5')->cmp());
+ANS(
+    Compute("$fpt * dt")->cmp()->withPostFilter(AnswerHints(
+        Formula("$fpx")    => "Are you using the correct variable?",
+        Formula("$fpx*dx") => "Are you using the correct variable?",
+        Formula("$fpt")    => "Don't forget the differential dt",
+    ))
+);
+ANS(Compute('2')->cmp());
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/IntegralCalc/RiemannSums.pg b/tutorial/sample-problems/IntegralCalc/RiemannSums.pg
new file mode 100644
index 0000000000..72f9039345
--- /dev/null
+++ b/tutorial/sample-problems/IntegralCalc/RiemannSums.pg
@@ -0,0 +1,189 @@
+## DESCRIPTION
+## Integral calculus: Interpreting Riemann sums in terms of area
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('Integrals', 'Area and Distance','Riemann sum','area')
+
+#:% name = Riemann Sums
+#:% type = Sample
+#:% subject = integral calculus
+#:% categories = [Riemann sums]
+
+#:% section = preamble
+#: The `weightedGrader.pl` macro is used because we want to give different parts
+#: of the answer different weights, the `parserPopUp.pl` macro is used to create
+#: drop down menus, and the `PGtikz.pl` macro is used to produce the graphs.
+#:
+#: To use the weighted grader call `install_weighted_grader();`.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',     'PGML.pl',
+    'weightedGrader.pl', 'parserPopUp.pl',
+    'PGtikz.pl',         'PGcourse.pl'
+);
+
+install_weighted_grader();
+
+#:% section = setup
+#: First generate a random constant for the function and the interval endpoints.
+#: Note that you should be careful to choose ranges for the parameters such that
+#: all possibilities work well in the graphs.
+#:
+#: Then compute the left and right Riemann sums, first by storing the x and y
+#: values in arrays and summing over the arrays.
+#:
+#: Next, generate the graphs of the function with the rectangles whose areas are
+#: summed in the Riemann sums.
+#:
+#: Finally, construct drop down menu answers that ask the student to relate the
+#: Riemann sum estimates to the area of the region specified in the problem.
+$c = random(9, 13);       # a constant for scaling the function
+$f = Compute("x^2/$c");
+$a = random(2, 5);        # left endpoint of interval
+$b = $a + 2;              # right endpoint of interval
+
+# Generate arrays of x and y values for the Riemann sum.
+# There are n + 1 entries in each array so that we can use
+# only one pair of arrays for both the left and the right
+# endpoint Riemann sums.
+$n  = 4;                # number of rectangles
+$dx = ($b - $a) / $n;
+for $k (0 .. $n) {
+    $x[$k] = $a + $k * $dx;
+    $y[$k] = $f->eval(x => $x[$k]);
+}
+$sumLeft  = 0;
+$sumRight = 0;
+for $k (0 .. $n - 1) {
+    $sumLeft  += $y[$k] * $dx;
+    $sumRight += $y[ $k + 1 ] * $dx;
+}
+
+# Graph of the Left Riemann sum rectangles
+$graph1 = createTikZImage();
+$graph1->tikzLibraries('arrows.meta');
+$graph1->BEGIN_TIKZ
+\tikzset{>={Stealth[scale=2]}}
+\Large % Make the fonts a little bigger.
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-1,-1) rectangle (9,9);
+\draw[->] (-1,0) -- (9,0) node[above left,outer sep=3pt] {\(x\)};
+\foreach \x in {1,...,8} \draw(\x,5pt) -- (\x,-5pt) node [below] {\(\x\)};
+\draw[->] (0,-1) -- (0,9) node[below right,outer sep=3pt] {\(y\)};
+\foreach \y in {1,...,8} \draw (5pt,\y) -- (-5pt,\y) node[left] {\(\y\)};
+\draw[<->] plot[domain=-1:9] (\x,{\x*\x/$c});
+\filldraw[draw=blue,fill=blue!50!white, fill opacity = 0.5]
+    ($x[0],0) rectangle ($x[1],$y[0]);
+\filldraw[draw=blue,fill=blue!50!white, fill opacity = 0.5]
+    ($x[1],0) rectangle ($x[2],$y[1]);
+\filldraw[draw=blue,fill=blue!50!white, fill opacity = 0.5]
+    ($x[2],0) rectangle ($x[3],$y[2]);
+\filldraw[draw=blue,fill=blue!50!white, fill opacity = 0.5]
+    ($x[3],0) rectangle ($x[4],$y[3]);
+END_TIKZ
+
+# Graph of the right Riemann sum rectangles
+$graph2 = createTikZImage();
+$graph2->tikzLibraries('arrows.meta');
+$graph2->BEGIN_TIKZ
+\tikzset{>={Stealth[scale=2]}}
+\Large % Make the fonts a little bigger.
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-1,-1) rectangle (9,9);
+\draw[->] (-1,0) -- (9,0) node[above left,outer sep=3pt] {\(x\)};
+\foreach \x in {1,...,8} \draw(\x,5pt) -- (\x,-5pt) node [below] {\(\x\)};
+\draw[->] (0,-1) -- (0,9) node[below right,outer sep=3pt] {\(y\)};
+\foreach \y in {1,...,8} \draw (5pt,\y) -- (-5pt,\y) node[left] {\(\y\)};
+\draw[<->] plot[domain=-1:9] (\x,{\x*\x/$c});
+\filldraw[draw=blue,fill=blue!50!white, fill opacity = 0.5]
+    ($x[0],0) rectangle ($x[1],$y[1]);
+\filldraw[draw=blue,fill=blue!50!white, fill opacity = 0.5]
+    ($x[1],0) rectangle ($x[2],$y[2]);
+\filldraw[draw=blue,fill=blue!50!white, fill opacity = 0.5]
+    ($x[2],0) rectangle ($x[3],$y[3]);
+\filldraw[draw=blue,fill=blue!50!white, fill opacity = 0.5]
+    ($x[3],0) rectangle ($x[4],$y[4]);
+END_TIKZ
+
+$leftEstimateDropDown = DropDown(
+    [
+        'an overestimate of',
+        'equal to',
+        'an underestimate of',
+        'there is ambiguity'
+    ],
+    2
+);
+
+$rightEstimateDropDown = DropDown(
+    [
+        'an overestimate of',
+        'equal to',
+        'an underestimate of',
+        'there is ambiguity'
+    ],
+    0
+);
+
+#:% section = statement
+#: The weights for the weighted grader are assigned by passing the `weight` flag
+#: to the `cmp` method.
+BEGIN_PGML
+Suppose [``f(x) = \frac{x^2}{[$c]}``].
+
+a. The rectangles in the graph below illustrate a left endpoint Riemann sum for
+[`f(x)`] on the interval [`[$a] \leq x \leq [$b]`].  The value of this left
+endpoint Riemann sum is [_]{Real($sumLeft)->cmp(weight => 45)}{5} and it is
+[_]{ $leftEstimateDropDown->cmp(weight => 5) } the area of the region enclosed
+by [`y = f(x)`], the [`x`]-axis, and the vertical lines [`x = [$a]`] and
+[`x = [$b]`].
+
+>>[@ image($graph1, height => 250, width => 250, tex_size => 450) @]*<<
+
+>>Left endpoint Riemann sum<<
+
+b. The rectangles in the graph below illustrate a right endpoint Riemann sum for
+[`f(x)`] on the interval [`[$a] \leq x \leq [$b]`].  The value of this right
+endpoint Riemann sum is [_]{ Real($sumRight)->cmp(weight => 45) }{5} and it is
+[_]{ $rightEstimateDropDown->cmp(weight => 5) } the area of the region enclosed
+by [`y = f(x)`], the [`x`]-axis, and the vertical lines [`x = [$a]`] and
+[`x = [$b]`].
+
+>>[@ image($graph2, height => 250, width => 250, tex_size => 450) @]*<<
+
+>>Right endpoint Riemann sum<<
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+a. The left endpoint Riemann sum is
+[```
+    f([$x[0]]) \cdot 0.5 + f([$x[1]]) \cdot 0.5 + \cdots + f([$x[ $n - 1]]) \cdot 0.5
+    = ([$y[0]] + [$y[1]] + \cdots + [$y[ $n-1 ]]) \cdot 0.5 = [$sumLeft].
+```]
+
+b. The right endpoint Riemann sum is
+[```
+    f([$x[1]]) \cdot 0.5 + f([$x[2]]) \cdot 0.5 + \cdots + f([$x[ $n ]]) \cdot 0.5
+    = ([$y[1]] + [$y[2]] + \cdots + [$y[ $n ]]) \cdot 0.5  = [$sumRight].
+```]
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
+
diff --git a/tutorial/sample-problems/IntegralCalc/VolumeOfRevolution.pg b/tutorial/sample-problems/IntegralCalc/VolumeOfRevolution.pg
new file mode 100644
index 0000000000..ff166c790d
--- /dev/null
+++ b/tutorial/sample-problems/IntegralCalc/VolumeOfRevolution.pg
@@ -0,0 +1,143 @@
+## DESCRIPTION
+## Volume of solids of revolution
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('Integrals', 'volume of solids of revolution')
+
+#:% name = Volume of Solids of Revolution
+#:% subject = integral calculus
+#:% type = Sample
+#:% categories = [volume, solid of revolution, disk method]
+
+#:% section = preamble
+#: We load `weightedGrader.pl` and install it. We load `answerHints.pl` to give
+#: student feedback on particular incorrect answers. We load `niceTables.pl` so
+#: that we can construct tables in HTML mode that will make the answer blanks
+#: for the limits of integration appear at the top and bottom of the integral
+#: symbol.
+#:
+#: If the weighted grader is to be used, the command
+#: `install_weighted_grader();` must be called.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',     'PGML.pl',
+    'niceTables.pl',     'answerHints.pl',
+    'weightedGrader.pl', 'PGcourse.pl'
+);
+
+install_weighted_grader();
+
+#:% section = setup
+#: To keep the code that needs to be modified compartmentalized, we define the
+#: functions involved, the limits of integration, the integrand, the volume, and
+#: an array of weights (which sum to 100) for each of these answers.
+#:
+#: The code for correctly displaying the answer blanks creates `$integral` which
+#: will be displayed correctly both in TeX and HTML modes. Notice that it uses
+#: `NAMED_ANS_RULE(name, width)` for all of the answer blanks instead of
+#: `ans_rule(width)`.
+#:
+#: We define `$integral` to display the integral and answer
+#: blanks correctly using a `LayoutTable` from PODLINK('niceTables.pl').
+Context()->variables->are(x => 'Real', dx => 'Real', y => 'Real', dy => 'Real');
+
+$upper = Real('1');
+$lower = Real('0');
+$int   = Compute('(pi x^2 - pi x^4) dx');
+$vol   = Compute('2pi/15');
+
+$integral = LayoutTable(
+    [
+        [ ' ', NAMED_ANS_RULE('upperlimit', 4) ],
+        [
+            '\(V= \)',
+            '\(\displaystyle \int \;\;\)'
+                . NAMED_ANS_RULE('integrand', 10)
+                . '\(\;=\;  \)'
+                . NAMED_ANS_RULE('volume', 4)
+        ],
+        [ ' ', NAMED_ANS_RULE('lowerlimit', 4) ],
+    ],
+    align      => 'rl',
+    valign     => 'middle',
+    allcellcss => { padding => '3pt' }
+);
+
+@weights = (5, 5, 40, 50);
+#:% section = statement
+#: Standard PGML and latex is used to describe the problem.  The integral
+#: that was formatted using a table above is inserted with `[$integral]*`
+#:
+#: A note is added that specifies for the students how the
+#: answer will be graded (the `weightedGrader.pl` macro does not do this
+#: automatically, as some other graders do.)
+BEGIN_PGML
+Set up and evaluate an integral for the volume of the solid of revolution
+obtained by rotating the region bounded by [`y = x`] and [`y = x^2`] about
+the [`x`]-axis.
+
+[$integral]*
+
+[@ MODES(
+    TeX  => '',
+    HTML => << "END_HTML"
+${BITALIC}${BBOLD}Note:${EBOLD} You can earn
+$weights[0]${PERCENT} for the upper limit of integration,
+$weights[1]${PERCENT} for the lower limit of integration,
+$weights[2]${PERCENT} for the integrand, and
+$weights[3]${PERCENT} for the finding the volume.
+${EITALIC}
+END_HTML
+) @]*
+END_PGML
+
+#:% section = answer
+#: To install the answer evaluator call
+#: `NAMED_WEIGHTED_ANS(name => $answer->cmp()->withPostFilter(), weight)`
+#: instead of using `ANS($answer->cmp()->withPostFilter())`. Providing
+#: customized answer hints for students is a good idea, because the whole point
+#: of this homework exercise it to learn how to set up this integral using
+#: proper notation. If we just wanted to ask for the volume, we could have done
+#: it using only one answer blank.
+#:
+#: If you would like to give full credit for the overall volume, you can
+#: replace the last `NAMED_WEIGHTED_ANS` with
+#:```{.perl}
+#:CREDIT_ANS($vol->cmp, [ 'upperlimit', 'lowerlimit', 'integrand' ], $weights[3]);
+#:```
+#:
+#: Of course, if you want to give equal credit, then each of the
+#: `NAMED_WEIGHTED_ANS` commands can be replaced with `ANS`, however
+#: make sure that they listed in order.
+NAMED_WEIGHTED_ANS(upperlimit => $upper->cmp, $weights[0]);
+NAMED_WEIGHTED_ANS(lowerlimit => $lower->cmp, $weights[1]);
+NAMED_WEIGHTED_ANS(
+    integrand => $int->cmp->withPostFilter(AnswerHints(
+        Formula('pi x^2 - pi x^4 dx') =>
+            "Don't forget to multiply every term in the integrand by dx",
+        Formula('pi (x^2 - x^4)')  => "Don't forget the differential dx",
+        Formula('pi(x^4 - x^2)dx') => 'Is the parabola above the line?',
+        Formula('pi(x^4 - x^2)')   => 'Is the parabola above the line?',
+        Formula('pi(x - x^2)')     => 'Make sure you use the disk method.',
+        Formula('pi(x - x^2)dx')   => 'Make sure you use the disk method.',
+    )),
+    $weights[2]
+);
+NAMED_WEIGHTED_ANS('volume' => $vol->cmp, $weights[3]);
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+COMMENT('Weights each answer blank separately.');
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/LinearAlgebra/MatrixAnswer1.pg b/tutorial/sample-problems/LinearAlgebra/MatrixAnswer1.pg
new file mode 100644
index 0000000000..f79ce10cdc
--- /dev/null
+++ b/tutorial/sample-problems/LinearAlgebra/MatrixAnswer1.pg
@@ -0,0 +1,63 @@
+## DESCRIPTION
+## Answer is a matrix
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('matrix')
+
+#:% name = Matrix Answer
+#:% type = Sample
+#:% subject = linear algebra
+#:% categories = [matrix]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Use `Context('Matrix');`. MathObject matrices are constructed using the `Matrix()`
+#: constructor. The matrix `A` has two rows and three columns, and is constructed by
+#: `[[row 1 entries], [row 2 entries]]`, and this construction generalizes in the
+#: obvious way. If a matrix has only one row, such as `B`, then it is entered as
+#: `[row 1 entries]` and not as `[ [row 1 entries] ]`. If `$B = Matrix([a,b,c]);`, then
+#: the matrix `$B->transpose` is equivalent to `Matrix([[a],[b],[c]]);` which has an outer
+#: pair of brackets enclosing all of the rows, where each row encloses its single element
+#: with brackets.
+Context('Matrix');
+
+$A = Matrix([
+    [ random(-5, 5), random(-5, 5), random(-5, 5) ],
+    [ random(-5, 5), random(-5, 5), random(-5, 5) ],
+]);
+
+$B = Matrix([
+    [ random(-5, 5), random(-5, 5), random(-5, 5) ],
+    [ random(-5, 5), random(-5, 5), random(-5, 5) ],
+]);
+
+$answer = $A * ($B->transpose);
+
+#:% section = statement
+BEGIN_PGML
+Suppose
+
+>> [``A = [$A]``] and [``B = [$B].``] <<
+
+Evaluate the following matrix product.
+
+[`A B^T =`] [_____]*{$answer}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/LinearAlgebra/MatrixAnswer2.pg b/tutorial/sample-problems/LinearAlgebra/MatrixAnswer2.pg
new file mode 100644
index 0000000000..21511bee51
--- /dev/null
+++ b/tutorial/sample-problems/LinearAlgebra/MatrixAnswer2.pg
@@ -0,0 +1,90 @@
+## DESCRIPTION
+## Answer is a matrix
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('matrix')
+
+#:% name = Matrix Answer Alternative
+#:% type = Sample
+#:% subject = linear algebra
+#:% categories = [matrix, answer]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Use `Context('Matrix');`. We construct a 2 by 3 matrix and extract its first column and first row.
+Context('Matrix');
+
+$example1 = Matrix([ [ 1, 2, 3 ], [ 4, 5, 6 ] ]);
+$example2 = $example1->column(1);
+$example3 = $example1->row(1);
+
+#:% section = statement
+BEGIN_PGML
+The purpose of this question is to show you the syntax needed to enter matrices
+in WeBWorK when there is only one answer box for entering a matrix (which is not
+obvious) or when there are multiple answer boxes for entering a matrix (which is
+obvious).  The examples below should be self-explanatory, so you can jump to
+them if you want; however, a detailed explanation follows if you want to read
+more.
+
+Matrices use square brackets to enclose items in lists.  A matrix with one row,
+such as a row vector, is a comma separated list enclosed by square brackets.  A
+matrix with more than one row or a column vector is a comma separated list of
+lists, where each list uses square brackets to enclose its items.  Your answers
+must use square brackets to enclose each row in a matrix or in a column vector.
+Also, a pair of square brackets is needed to enclose a matrix with more than one
+row (e.g., a [`2 \times 3`] matrix and a [`2 \times 1`] column vector have
+multiple rows so they need extra square brackets, but a [`1 \times 3`] row
+vector has only one row so it does not need extra square brackets).  Your
+answers may have spaces and line breaks in them, such as
+
+>> [| [ [1, 2, 3], |] <<
+>> [| [4, 5, 6] ]  |] <<
+
++ Enter the matrix [``[$example1]``] as [@ $example1->string @]*
+[@ ans_box(3,30) @]*
+
++ Enter the column vector [``[$example2]``] as [@ $example2->string @]*
+[@ ans_box(3,30) @]*
+
++ Enter the row vector [``[$example3]``] as [@ $example3->string @]*
+[@ ans_box(3,30) @]*
+END_PGML
+
+#:% section = answer
+#: Because an `ans_box` is used, we need to use the older style answer checkers.
+
+ANS($example1->cmp);
+ANS($example2->cmp);
+ANS($example3->cmp);
+
+#:% section = setup2
+#: Reset the context because the matrix answer checker gets confused
+#: when the `ans_box` and `ans_array` methods are co-mingled.
+Context('Matrix');
+
+$example4 = Matrix([ [ 1, 2, 3 ], [ 4, 5, 6 ] ]);
+
+#:% section = statement2
+#: This is the other method to entering matrices.
+BEGIN_PGML
+[$BR]*
++ Entering a matrix using multiple answer blanks is straightforward --
+just put each matrix entry into its own answer blank.
+Enter the matrix [`` [$example4] ``] with one matrix entry per answer box.
+[______]*{$example4}
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/LinearAlgebra/MatrixCustomAnswerChecker.pg b/tutorial/sample-problems/LinearAlgebra/MatrixCustomAnswerChecker.pg
new file mode 100644
index 0000000000..9e43abaffb
--- /dev/null
+++ b/tutorial/sample-problems/LinearAlgebra/MatrixCustomAnswerChecker.pg
@@ -0,0 +1,69 @@
+## DESCRIPTION
+## Answer is a pair of matrices that require a custom answer checker
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('matrix','custom answer checker','multianswer')
+
+#:% name = Custom Matrix Answer Checker
+#:% type = Sample
+#:% subject = linear algebra
+#:% categories = [answer, matrix]
+
+#:% section = preamble
+#: Since the answer will depend on the two matrices input, we need to use `parserMultiAnswer.pl`.
+
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserMultiAnswer.pl', 'PGcourse.pl');
+
+$showPartialCorrectAnswers = 0;
+
+#:% section = setup
+#: Construct two matrices `$A` and `$B` that do not commute and therefore serve as a correct answer.
+#: Use a $multians object with a custom answer checker subroutine. The answer checker uses
+#: `my ( $correct, $student, $answerHash ) = @_;` to grab the inputs (the correct answer,
+#: the student answer, and the answer hash table info). Then, put the student's
+#: two answers into an array using `my @s = @{$student};`. Make sure the student's
+#: first matrix `$s[0]` is converted to a `MathObject` matrix using `$s0 = Matrix($s[0]);`
+#: and similarly for the student's second matrix. The return value, which is boolean, is
+#: the truth value of the statement `$s0 * $s1 != $s1 * $s0`.
+Context('Matrix');
+
+$A = Matrix([ [ 1, 1 ], [ 0, 1 ] ]);
+$B = Matrix([ [ 1, 0 ], [ 1, 1 ] ]);
+
+$multians = MultiAnswer($A, $B)->with(
+    singleResult => 1,
+    checker      => sub {
+        my ($correct, $student, $answerHash) = @_;
+        my @s = @{$student};
+        $s0 = Matrix($s[0]);
+        $s1 = Matrix($s[1]);
+        return $s0 * $s1 != $s1 * $s0;
+    }
+);
+
+#:% section = statement
+#:  Make sure that both answer arrays are called as methods on the `$multians` object
+BEGIN_PGML
+Give an example of two [`2 \times 2`] matrices [`A`] and [`B`] such that
+[`AB \ne BA`] .
+
+	[`A =`] [_____]*{$multians}
+
+	[`B =`] [_____]*{$multians}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/LinearAlgebra/MatrixOperations.pg b/tutorial/sample-problems/LinearAlgebra/MatrixOperations.pg
new file mode 100644
index 0000000000..5b47b8dca9
--- /dev/null
+++ b/tutorial/sample-problems/LinearAlgebra/MatrixOperations.pg
@@ -0,0 +1,100 @@
+## DESCRIPTION
+## Find the product of two matrices if the product is defined.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('matrix','matrix operations')
+
+#:% name = Matrix Operation
+#:% type = Sample
+#:% subject = linear algebra
+#:% categories = [matrix]
+
+#:% section = preamble
+#: This uses `parserRadioMultiAnswer.pl`, so it needs to be loaded.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',             'PGML.pl',
+    'parserRadioMultiAnswer.pl', 'PGcourse.pl'
+);
+
+#:% section = setup
+#: First, the two matrices are defined.
+#:
+#: A `RadioMultiAnswer` produces a set of radio buttons for each of the given statements.
+#: The format is
+#:```{#radio-multi-answer-usage .perl}
+#: RadioMultiAnswer([
+#:     [statement1],
+#:     [statement2],
+#:     ...
+#:     [last statement]
+#: ], correct index, options)
+#:```
+#: Answer blanks can be added with the `%s` in the string and if a matrix is desired,
+#: `%s*` should be used.  See the POD for more details.
+Context('Matrix');
+
+$A = Matrix([
+    [ non_zero_random(-5, 5), non_zero_random(-5, 5) ],
+    [ non_zero_random(-5, 5), non_zero_random(-5, 5) ]
+]);
+
+$B = Matrix([
+    [
+        non_zero_random(-5, 5),
+        non_zero_random(-5, 5),
+        non_zero_random(-5, 5)
+    ],
+    [
+        non_zero_random(-5, 5),
+        non_zero_random(-5, 5),
+        non_zero_random(-5, 5)
+    ],
+]);
+
+$rma1 = RadioMultiAnswer(
+    [
+        ['The product \(AB\) does not exist.'],
+        [ 'The product \(AB\) is %s*', $A * $B ]
+    ],
+    1
+);
+
+$rma2 = RadioMultiAnswer(
+    [
+        ['The product \(BA\) does not exist.'],
+        [ 'The product \(BA\) is %s*', $A * $B ]
+    ],
+    0
+);
+
+#:% section = statement
+BEGIN_PGML
+Let
+>> [``A = [$A] \quad\text{and}\quad B = [$B].``] <<
+
+1) Select the correct choice below, and fill in any answer boxes within that
+choice.
+
+    [____]{$rma1}
+
+2) Select the correct choice below, and fill in any answer boxes within that
+choice.
+
+    [____]{$rma2}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/LinearAlgebra/RowOperations.pg b/tutorial/sample-problems/LinearAlgebra/RowOperations.pg
new file mode 100644
index 0000000000..61173bc987
--- /dev/null
+++ b/tutorial/sample-problems/LinearAlgebra/RowOperations.pg
@@ -0,0 +1,61 @@
+## DESCRIPTION
+## Row operations on a Matrix
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('matrix','row operation')
+
+#:% name = Row Operations
+#:% type = Sample
+#:% subject = linear algebra
+#:% categories = [matrix, row operation]
+
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Construct a matrix with three distinct rows. Create a string `$op` of Tex code that
+#: describes the row operation. Use `$A->row(i)` to extract the ith row of the matrix A
+#: as a MathObject. Use `$A->row(1) + $k*$A->row(2)` to perform the row operation and
+#: place it into the first row of the answer matrix.
+#:
+#: The do-until loop ensures that no two rows are identical.  This is not necessary
+#: for this problem, but can be helpful in other situations.
+Context('Matrix');
+
+do {
+    $A = Matrix([
+        [ non_zero_random(-5, 5), non_zero_random(-5, 5) ],
+        [ non_zero_random(-5, 5), non_zero_random(-5, 5) ],
+        [ non_zero_random(-5, 5), non_zero_random(-5, 5) ],
+    ]);
+} until (($A->row(1) != $A->row(2))
+        && ($A->row(1) != $A->row(3))
+        && ($A->row(2) != $A->row(3)));
+
+$k  = random(2, 9);
+$op = "R_{1} + $k R_{2} \rightarrow R_{1}";
+
+$ans = Matrix([ $A->row(1) + $k * ($A->row(2)), $A->row(2), $A->row(3), ]);
+
+#:% section = statement
+#: Remember when using a matrix answer blank in PGML, to append a *
+BEGIN_PGML
+Give the result of applying the row operation [`[$op]`] to the given matrix.
+
+[``[$A] \mathop{\longrightarrow}^{[$op]}``] [_____]*{$ans}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/ChemicalReaction.pg b/tutorial/sample-problems/Misc/ChemicalReaction.pg
new file mode 100644
index 0000000000..04530f796e
--- /dev/null
+++ b/tutorial/sample-problems/Misc/ChemicalReaction.pg
@@ -0,0 +1,74 @@
+## DESCRIPTION
+## Chemical reaction template
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('chemical reaction', 'template')
+
+# References:
+# http://webwork.maa.org/pod/pg_TRUNK/macros/contextReaction.pl.html
+# http://webwork.maa.org/moodle/mod/forum/discuss.php?d=449
+
+#:% name = Chemical Reaction
+#:% type = Sample
+#:% subject = chemistry
+#:% categories = [chemistry]
+
+#:% section = preamble
+#: Load `contextReaction.pl` to put chemical reactions/equations in a `Compute`
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextReaction.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We create a couple of arrays `@reactants` and `@products` and fill them with
+#: some examples of balanced chemical equations.  The second and third examples
+#: show that groupings, such as for `(OH)_2` are necessary.  The third example
+#: shows how you could randomize a chemical reaction question.  In particular, note
+#: that `${b}_2` is needed instead of `$b_2` so that Perl interprets the variable
+#: as `$b` with a subscript of 2 instead of a variable named `$b_2` with no subscript.
+Context('Reaction');
+
+@reactants = ();
+@products  = ();
+
+$reactants[0] = Formula('2C_2H_6 + 7O_2');
+$products[0]  = Formula('4CO_2 + 6H_2O');
+
+$reactants[1] = Formula('6CO_2 + 6O_2');
+$products[1]  = Formula('C_6 H_12 O_6 + 6 O_2');
+
+$reactants[2] = Formula('3 Ca Cl_2 + 2 Na_3 PO_4');
+$products[2]  = Formula('Ca_3 (PO_4)_2 + 6 Na Cl');
+
+# variations on 2NaOH + MgCl_2 --> 2NaCl + Mg(OH)_2
+$a = list_random('Li', 'Na', 'K');
+$b = list_random('F',  'Cl', 'Br');
+
+# Use ${b}_2 instead of $b_2 below so that Perl knows the variable name is
+# $b = ${b} and not $b_2 = ${b_2}.
+$reactants[3] = Formula("2 $a OH + Mg ${b}_2");
+$products[3]  = Formula("2 $a $b + Mg (OH)_2");
+
+$i = random(0, $#reactants, 1);
+
+#:% section = statement
+#: This is a way to print out the four reactions in a for loop.
+for $i (0 .. 3) {
+BEGIN_PGML
+[`[$reactants[$i]] \longrightarrow `] [_]{$products[$i]}{10}
+
+END_PGML
+}
+
+BEGIN_PGML
+Enter a subscript using an underscore, such as [|H_2 O|]* for [`\mathrm{H_2 O}`].
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/DraggableProof.pg b/tutorial/sample-problems/Misc/DraggableProof.pg
new file mode 100644
index 0000000000..2cc57816ed
--- /dev/null
+++ b/tutorial/sample-problems/Misc/DraggableProof.pg
@@ -0,0 +1,64 @@
+## DESCRIPTION
+## A Simple draggable proof.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Fort Lewis tutorial 2011)
+## Date(03/10/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('draggable proof', 'template')
+
+#:% name = Draggable Proof
+#:% type = Sample
+#:% subject = proof
+#:% categories = [proof, draggable]
+
+#:% section = preamble
+#: This problem uses the `draggableProof.pl` macro to display "buckets" that the
+#: student can drag statements to and from.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'draggableProof.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The `DraggableProof` function takes an arrayref of correct statements,
+#: followed (optionally) by extra statements. See
+#: PODLINK('the Draggable Proof POD', 'draggableProof.pl') for more options.
+$proof = DraggableProof(
+    # These are the correct statements of the proof in the correct order.
+    [
+        'Assume \(\sqrt{2} = \frac{a}{b}\) where \(a,b\) are integers, with \(\text{gcd}(a,b) = 1\)',
+        '\(2 = \frac{a^2}{b^2}\)',
+        '\(a^2 = 2b^2\)',
+        'if \(a^2\) is even, then \(a\) must be even',
+        'Let \(a = 2k\) for \(k\) some integer',
+        'We can then write \(2 = \frac{4k^2}{b^2}\) or \(b^2 = 2k^2\)',
+        'Therefore \(b^2\) is even, so \(b\) is also even',
+        'If \(a\) and \(b\) are both even, then the initial assumption that \(\text{gcd}(a,b) = 1\) is contradicted.',
+        '\(\sqrt{2}\) is therefore not rational.'
+    ],
+    # These are extra statements that are not needed.
+    [
+        'Then \(a\) is odd',
+        '\(b^2\) cannot be rational.',
+        'therefore \(a = 2b\)'
+    ]
+);
+
+#:% section = statement
+#: The line `[_]{$proof}` prints the statement and options in the proof and sets up the answer rule.
+BEGIN_PGML
+Prove that [`\sqrt{2}`] is irrational.
+
+[_]{$proof}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/DynamicGraphPolygon.pg b/tutorial/sample-problems/Misc/DynamicGraphPolygon.pg
new file mode 100644
index 0000000000..b589354cf1
--- /dev/null
+++ b/tutorial/sample-problems/Misc/DynamicGraphPolygon.pg
@@ -0,0 +1,119 @@
+## DESCRIPTION
+## Dynamically generated graph of a function
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'dynamic graph', 'polygon')
+
+#:% name = Shaded Polygon Graph
+#:% type = technique
+#:% see_also = [DynamicGraph.pg]
+
+#:% section = preamble
+#: The dynamic graphs are generated with `PGtikz.pl`, so this is needed.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGtikz.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: See PROBLINK('DynamicGraph.pg') for basics of using tikz.
+#:
+#: Since we make three plots with the same setup, all of the commands that
+#: are common to the graphs are defined in the same perl string.
+#:
+#: Each of the plots uses the `\filldraw` command.  Options for this are
+#:
+#:* `fill`: the color of the fill region
+#:* `draw`: the color of the boundary.
+#:* `very thick`: the thickness of the boundary
+#:* `opacity`: the opacity (between 0 and 1) of the fill region.
+#:
+#: In the polygon and region under the curve, the `draw` method uses the
+#: verticies (or the `plot` command which uses the curve itself) and
+#: ends with `cycle` indicated that the region is closed.
+#:
+#: The colors are defined in the LaTeX LINK('xcolor package','https://mirrors.mit.edu/CTAN/macros/latex/contrib/xcolor/xcolor.pdf')
+#:
+# The setup for each plot is the same, so we'll use a perl block for this.
+$plot_setup = qq/
+\tikzset{>={Stealth[scale=1.5]}}
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-5,5) rectangle (5,-5);
+\draw[lightgray, dashed] (-5,-5) grid (5,5);
+\draw (-5,0) -- (5,0) node [below left] {\(x\)};
+\foreach \x in {-4,...,-1,1,2,...,4} \draw(\x,-4.5) node {\(\x\)};
+\draw (0,-5) -- (0,5) node [below right] {\(y\)};
+\foreach \y in {-4,...,-1,1,2,...,4} \draw(-4.5,\y) node {\(\y\)};
+/;
+
+# The vertices of the triangle chosen randomly will be ($x0,$y0), ($x1,$y0)
+# and ($x0,$y1).
+$x0 = random(-3, -1);
+$x1 = random(1,  3);
+$y0 = random(-3, -1);
+$y1 = random(1,  3);
+
+$graph1 = createTikZImage();
+$graph1->tikzLibraries('arrows.meta');
+$graph1->BEGIN_TIKZ
+$plot_setup;
+\filldraw[very thick, fill=LightGreen, draw=DarkGreen, opacity=0.5] ($x0,$y0)
+    -- ($x1,$y0) -- ($x0,$y1) -- cycle;
+END_TIKZ
+
+# A plot of 1+sqrt(x) and shade underneath the graph.
+
+$graph2 = createTikZImage();
+$graph2->tikzLibraries('arrows.meta');
+$graph2->BEGIN_TIKZ
+$plot_setup;
+
+\filldraw[fill=LightBlue, opacity=0.5, draw=blue] (1,1)
+    -- plot[domain=1:4, smooth] (\x,{1+sqrt(\x)})
+    -- (4,0) -- (1,0) -- cycle;
+\draw[very thick, DarkBlue] plot [domain=0:5, smooth] (\x,{1+sqrt(\x)});
+END_TIKZ
+
+# A circle with center ($x0,$y0)
+$x = random(-2, 2);
+$y = random(-2, 2);
+
+$graph3 = createTikZImage();
+$graph3->tikzLibraries('arrows.meta');
+$graph3->BEGIN_TIKZ
+$plot_setup;
+
+\filldraw[very thick, fill=LightSalmon, opacity=0.5, draw=DarkOrange]
+    circle[radius=3] ($x,$y);
+END_TIKZ
+
+#:% section = statement
+#: Note that the tikz graph in `$graph1`, `$graph2` and `$graph3` to be shown
+#: is placed in the `image` function
+#: and since this is a function, it must go in a `[@ ... @]*` block.
+BEGIN_PGML
+
+[@ image($graph1, width => 400) @]*
+
+[@ image($graph2, width => 400) @]*
+
+[@ image($graph3, width => 400) @]*
+
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/EssayAnswer.pg b/tutorial/sample-problems/Misc/EssayAnswer.pg
new file mode 100644
index 0000000000..fc75f21a1a
--- /dev/null
+++ b/tutorial/sample-problems/Misc/EssayAnswer.pg
@@ -0,0 +1,83 @@
+## DESCRIPTION
+## Essay answer template
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('essay answer', 'template')
+
+# References:
+# http://webworkgoehle.blogspot.com/2012/09/essay-answers-in-webwork.html
+
+#:% name = Essay Answer
+#:% type = [Sample, technique]
+#:% categories = [essay]
+
+#:% section = preamble
+#: Use the `PGessaymacros.pl` for the essay answer
+#: and `parserPopUp.pl` for the multiple choice drop
+#: down menu.  Setting `$showPartialCorrectAnswers = 0;`
+#: means that students will not receive feedback on whether
+#: their answers are correct.
+#: The all-or-nothing problem grader (the standard problem grader)
+#: is used in order to withhold assigning any credit when the student
+#: submits an answer.  This allows the professor to manually determine
+#: what percentage the student should get.
+#: If the standard problem grader was not used here, then the default
+#: problem grader (the average problem grader) would award
+#: 50 percent credit to students who answer the multiple choice
+#: question correct.
+DOCUMENT();
+loadMacros(
+    'PGstandard.pl',  'PGML.pl',
+    'parserPopUp.pl', 'PGessaymacros.pl',
+    'PGcourse.pl'
+);
+
+$showPartialCorrectAnswers = 0;
+
+#:% section = setup
+$popup = PopUp(
+    [ 'Choose', 'True', 'False' ],    # choices
+    'False'                           # corect answer
+);
+
+$a = random(2, 5);
+
+$f1 = Compute("ln(x (x-$a))");
+$f2 = Compute("ln(x) + ln(x-$a)");
+
+#:% section = statement
+#: Clearly communicate to the student the expectations
+#: of the problem and how it will be graded.  The `essay_box(w, h)`
+#: is resizable and takes inputs for initial width and height.
+#:
+#: Note that `essay_cmp()` is not associated with any object
+#: (i.e., it is **not** `$essay->cmp()`).
+#:
+#: The essay answer must be graded manually by the instructor.  Hand grading is
+#: done either (1) by viewing the homework set and clicking the **Grade problem**
+#: link in the rightmost column of the problem list, or (2) by checking the
+#: **Problem Grader** checkbox in the problem and clicking
+#: **Preview My Answers** or **Check Answers**, or (3) by clicking on
+#: **Statistics** in Instructor Tools menu, selecting the homework set, and
+#: clicking the **Manual Grader** link under the problem number, or (4) by
+#: clicking the **Grade Problem** link after the problem number on the
+#: **Set Detail** page.
+BEGIN_PGML
+Answer the following true / false question and then explain your answer.  Your
+answers will be read and graded manually at a later time.
+
+[_]{$popup} For all real numbers [`x`], [`[$f1] = [$f2]`].
+
+Please explain your reasoning in the answer box below.
+[@ ANS( essay_cmp() ); essay_box(8, 60) @]*
+END_PGML
+
+ENDDOCUMENT();
+
diff --git a/tutorial/sample-problems/Misc/FormulaAnswer.pg b/tutorial/sample-problems/Misc/FormulaAnswer.pg
new file mode 100644
index 0000000000..7602018506
--- /dev/null
+++ b/tutorial/sample-problems/Misc/FormulaAnswer.pg
@@ -0,0 +1,46 @@
+## DESCRIPTION
+## Formula answer template
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('formula answer', 'template')
+
+#:% name = Formula Answer
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [answer]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl');
+
+#:% section = setup
+#: Use `do { $b = random(2, 9) } until ( $b != $a );` to generate distinct
+#: random numbers.
+
+$a = non_zero_random(-9, 9);
+do { $b = random(2, 9) } until ($b != $a);
+
+$answer1 = Compute("$a");
+$answer2 = Compute("($a x^($b) + $b)/x")->reduce();
+
+#:% section = statement
+BEGIN_PGML
+Enter [`[$answer1]`]: [____]{$answer1}
+
+Enter [``[$answer2]``]: [____]{$answer2}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/FormulaDomain.pg b/tutorial/sample-problems/Misc/FormulaDomain.pg
new file mode 100644
index 0000000000..e9130f53d1
--- /dev/null
+++ b/tutorial/sample-problems/Misc/FormulaDomain.pg
@@ -0,0 +1,67 @@
+## DESCRIPTION
+## Formula answer with domain issues template
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('formula answer', 'template')
+
+#:% name = Setting the Domain for Answer Checking
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [domain, answer]
+#:% see_also = [FormulaTestPoints.pg]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Restrict the domain of function evaluation using `$ans1->{limits} = [ $a + 1, $a + 4 ];`,
+#: which will choose test points at random in the interval `[$a + 1, $a + 4]`.
+#: This will ensure that the test points are in the domain of the function.
+#:
+#: The domain for `$ans2` is all real numbers except for `0` and `$a`, and
+#: we would like to stay away from these vertical asymptotes because answer evaluators
+#: don't work well when the function values are very large or very small.  Thus, we
+#: explicitly list those test points in the domain that will be used when the function is evaluated.
+#:
+#: It is possible to set the domain once for all of the functions within a particular
+#: context.  For more details, see PROBLINK('FormulaTestPoints.pg').
+#:
+#: It is possible to get diagnostic information about the answer checker if one
+#: replaces the `{$ans}` with `{$ans1->cmp(diagnostics => 1)}`.
+#: When diagnostics are turned on and a student answer is submitted, you will get a graph
+#: of the correct answer and the student answer on the same graph, as well as a table that
+#: specifies which test points were used by the answer checker, and how much of a difference
+#: there was between the student answer and the correct answer at these checkpoints.
+#: To test the reliability of your answer checker, it is good to click the reload
+#: button on your browser several times after a student answer has been submitted,
+#: since reloading changes the test points used.
+$a = random(2, 5);
+
+$ans1 = Compute("sqrt(x - $a)");
+$ans1->{limits} = [ $a + 1, $a + 4 ];
+
+$ans2 = Compute("ln(abs(x / (x - $a)))");
+$ans2->{test_points} = [ [-5], [-4], [1], [ $a - 1 ], [7], [8] ];
+
+#:% section = statement
+BEGIN_PGML
+a. Enter the answer [``[$ans1] =``] [_]{$ans1}
+
+b. Enter the answer [``[$ans2] =``] [_]{$ans2}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/FormulaTestPoints.pg b/tutorial/sample-problems/Misc/FormulaTestPoints.pg
new file mode 100644
index 0000000000..5b854d1cac
--- /dev/null
+++ b/tutorial/sample-problems/Misc/FormulaTestPoints.pg
@@ -0,0 +1,65 @@
+## DESCRIPTION
+## Shows how to test a formula at a given set of points.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(04/15/2023)
+## Institution(Fitchburg States)
+## Author(Peter Staab)
+## KEYWORDS('function', 'test points')
+
+#:% name = Formula Test Points
+#:% type = [sample, technique]
+#:% categories = [misc]
+#:% see_also = [FormulaDomain.pg]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The first line sets the limits of evaluation for any problem in the context
+#: to `[-1,1]`.
+#:
+#: Alternatively, the limits on the context can be set with
+#:```{.perl}
+#:Context()->flags->set(limits=>[2,5]);
+#:```
+#:
+#: For the points for `$g`, note that the domain of `$g` is all values outside
+#: of the interval `(-2,2)`. One way to handle this would be to set the `limits`
+#: for the function to be outside this interval.  Alteratively, as shown,
+#: the points are set with the `test_points` field to be a set of points
+#: that don't include `(-2,2)`.
+Context()->variables->set(x => { limits => [ -1, 1 ] });
+
+# Alternately
+Context()->flags->set(limits => [ 2, 5 ]);
+
+$f = Compute('sqrt(x+1)');
+
+## Or, setting the limits only for the given
+##    formula, we don't need to reset the Context,
+##    and just include
+# $func = Compute('sqrt(x-1)');
+# $func->{limits} = [2,5];
+
+$g = Compute("sqrt(x^2 - 4)");
+$g->{test_points} = [ [-3], [-2], [2], [3], [4] ];
+
+#:% section = statement
+BEGIN_PGML
+Enter [`[$f]`] [___]{$f}
+
+Enter [`[$g]`] [___]{$g}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/IframeEmbedding.pg b/tutorial/sample-problems/Misc/IframeEmbedding.pg
new file mode 100644
index 0000000000..e3245df1b2
--- /dev/null
+++ b/tutorial/sample-problems/Misc/IframeEmbedding.pg
@@ -0,0 +1,79 @@
+## DESCRIPTION
+## Iframe embedding template
+## ENDDESCRIPTION
+
+## KEYWORDS('iframe','embedding', 'template')
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+
+#:% name = Embedding an IFrame
+#:% type = Sample
+#:% categories = [misc, video]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We create a mode dependent variable `$slideshow` that displays a
+#: Google slideshow inside an html `iframe` when in html mode, and
+#: the message "An embedded Google slide show." in TeX mode.  If you omit the
+#: TeX mode stuff, then there will be errors when the pdf hardcopy is generated.
+#: Similarly for the `$video`.  (Searching the web for "YouTube embed
+#: video" should bring up instructions for how to get the code to embed a YouTube
+#: video into a webpage.)
+
+$slideshow = MODES(
+    HTML => tag(
+        'iframe',
+        src =>
+            'https://docs.google.com/presentation/d/1pk0FxsamBuZsVh1WGGmHGEb5AlfC68KUlz7zRRIYAUg/embed#slide=id.i0',
+        width  => '555',
+        height => '451'
+    ),
+    TeX => 'An embedded Google slide show.'
+);
+
+$video = MODES(
+    HTML => tag(
+        'iframe',
+        src             => 'https://www.youtube.com/embed/M4vqr3_ROIk',
+        width           => '420',
+        height          => '315',
+        allowfullscreen => undef
+    ),
+    TeX => "An embedded YouTube video."
+);
+
+#:% section = statement
+#: Include the `$slideshow` and `$video` wherever you like.
+BEGIN_PGML
+# Embedded Google slides
+
+>> [$slideshow]* <<
+
+>>Google slides embedded using an iframe.<<
+
+# Embedded YouTube video
+
+>> [$video]* <<
+
+>>YouTube video of Arthur Benjamin, mathemagician, embedded using an iframe.<<
+>>If the video does not work,
+[@ htmlLink("https://www.youtube.com/embed/M4vqr3_ROIk",
+    "click here to go to YouTube directly.") @]*<<
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
+
diff --git a/tutorial/sample-problems/Misc/ManyMultipleChoice.pg b/tutorial/sample-problems/Misc/ManyMultipleChoice.pg
new file mode 100644
index 0000000000..101639fa99
--- /dev/null
+++ b/tutorial/sample-problems/Misc/ManyMultipleChoice.pg
@@ -0,0 +1,98 @@
+## DESCRIPTION
+## Many multiple choice template
+## ENDDESCRIPTION
+
+## KEYWORDS('multiple choice', 'template')
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+
+#:% name = Many Multiple Choice
+#:% type = Sample
+#:% categories = [multiple choice, misc]
+
+#:% section = preamble
+#: The `PGchoicemacros.pl` macro is used to construct the list of multiple
+#: choice items, and the custom problem grader fluid from `PGgraders.pl` is
+#: used for incremental grading.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl', 'PGML.pl', 'parserPopUp.pl', 'PGgraders.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: Withhold feedback when answers are submitted by setting
+#: `$showPartialCorrectAnswers = 0;`.
+#:
+#: This problem uses an incremental grader called the `custom_problem_grader_fluid`.
+#: With this problem grader, the number of correct answers `[2, 4, 6]`
+#: and their corresponding scores `[0.3, 0.6, 1]` must be specified.  The last
+#: entry in the `grader_numright` array must be the total number of questions
+#: asked, and the last entry in the `grader_scores` array must be 1
+#: (otherwise nobody can earn full credit!).  The grader message can also
+#: be customized by setting the value of `grader_message` to the desired custom
+#: message.
+#:
+#: If a grader is desired that awards full credit when all questions are correct
+#: and no credit otherwise, use the commented out standard problem grader code
+#: instead.
+#:
+#: Several questions and answers are defined, and a selection of them chosen via
+#: `random_subset` to present to the student working the problem.
+
+$showPartialCorrectAnswers = 0;
+
+# Incremental grader
+install_problem_grader(~~&custom_problem_grader_fluid);
+$ENV{grader_numright} = [ 2,   4,   6 ];
+$ENV{grader_scores}   = [ 0.3, 0.6, 1 ];
+$ENV{grader_message} =
+    'You can earn '
+    . '30% partial credit for 2 - 3 correct answers, and '
+    . '60% partial credit for 4 - 5 correct answers.';
+
+# All or nothing grader
+# install_problem_grader(~~&std_problem_grader);
+
+# Questions and answers
+@s_and_a = (
+    [ 'All continuous functions are differentiable.',            'False' ],
+    [ 'All differentiable functions are continuous.',            'True' ],
+    [ 'All polynomials are differentiable.',                     'True' ],
+    [ 'All functions with positive derivatives are increasing.', 'True' ],
+    [ 'All rational functions are continuous.',                  'False' ],
+    [ 'All exponential functions are differentiable.',           'True' ],
+    [ 'All exponential functions are rational functions.',       'False' ],
+);
+
+# Select six of the statements and answers to use.
+@statements = random_subset(6, @s_and_a);
+
+#:% section = statement
+#: Display the statements and a True / False drop down for the answers that were
+#: selected.
+BEGIN_PGML
+Are the following statements true or false?
+
+[@ join("\n\n", map {
+    '[_]{DropDownTF($statements[' . $_ . '][1])} [$statements[' . $_ . '][0]]'
+} 0 .. $#statements) @]**
+END_PGML
+
+#:% section = solution
+#: Show the statements and answers.
+BEGIN_PGML_SOLUTION
+The answers are
+
+[@ join("\n\n", map {
+   	'[$statements[' . $_ . '][1]]: [$statements[' . $_ . '][0]]'
+} 0 .. $#statements) @]**
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/Matching.pg b/tutorial/sample-problems/Misc/Matching.pg
new file mode 100644
index 0000000000..6832fbf015
--- /dev/null
+++ b/tutorial/sample-problems/Misc/Matching.pg
@@ -0,0 +1,126 @@
+## DESCRIPTION
+## Matching question template
+## ENDDESCRIPTION
+
+## KEYWORDS('matching', 'template')
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+
+#:% name = Matching Problem
+#:% type = Sample
+#:% categories = [multiple choice, misc]
+
+#:% section = preamble
+#: The `PGchoicemacros.pl` macro is used to construct the list of multiple
+#: choice items, and the custom problem grader fluid from `PGgraders.pl` is
+#: used for incremental grading.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',     'PGML.pl',
+    'PGchoicemacros.pl', 'PGgraders.pl',
+    'unionTables.pl',    'PGcourse.pl'
+);
+
+#:% section = setup
+#: Withhold feedback when answers are submitted by setting
+#: `$showPartialCorrectAnswers = 0;`.
+#:
+#: This problem uses an incremental grader called the `custom_problem_grader_fluid`.
+#: With this problem grader, the number of correct answers `[2, 4, 6]`
+#: and their corresponding scores `[0.3, 0.6, 1]` must be specified.  The last
+#: entry in the `grader_numright` array must be the total number of questions
+#: asked, and the last entry in the `grader_scores` array must be 1
+#: (otherwise nobody can earn full credit!).  The grader message can also
+#: be customized by setting the value of `grader_message` to the desired custom
+#: message.
+#:
+#: If a grader is desired that awards full credit when all questions are correct
+#: and no credit otherwise, use the commented out standard problem grader code
+#: instead.
+#:
+#: Create a list of 6 questions and answers, 2 extra answers, and a
+#: 'None of the above' answer that will be made last with `makeLast`.
+#: So the popup list must have 9 entries A through I.
+#:
+#: As an alternative, see PROBLINK('MatchingAlt.pg') for another way to write
+#: a matching problem.
+$showPartialCorrectAnswers = 0;
+
+# Incremental grader
+install_problem_grader(~~&custom_problem_grader_fluid);
+$ENV{grader_numright} = [ 2,   4,   6 ];
+$ENV{grader_scores}   = [ 0.3, 0.6, 1 ];
+$ENV{grader_message} =
+    'You can earn '
+    . '30% partial credit for 2 - 3 correct answers, and '
+    . '60% partial credit for 4 - 5 correct answers.';
+
+# All or nothing grader
+# install_problem_grader(~~&std_problem_grader);
+
+# Create a matching list and use popups
+$ml = new_match_list();
+$ml->rf_print_q(~~&pop_up_list_print_q);
+$ml->ra_pop_up_list([
+    'No answer' => '?',
+    'A'         => 'A',
+    'B'         => 'B',
+    'C'         => 'C',
+    'D'         => 'D',
+    'E'         => 'E',
+    'F'         => 'F',
+    'G'         => 'G',
+    'H'         => 'H',
+    'I'         => 'I',
+]);
+
+# Add correct questions and answers
+$ml->qa(
+    'Question a?',
+    'Answer a',
+    'Question b?',
+    'Answer b',
+    'Question c?',
+    'Answer c',
+    'Question d?',
+    'Answer d',
+    'Question e?',
+    'Answer e',
+    'Question f?',
+    'Answer f',
+);
+$ml->choose(6);
+
+# Add extra incorrect answers
+$ml->extra('Extra answer 1', 'Extra answer 2',);
+$ml->choose_extra(2);
+
+$ml->makeLast('None of the above');
+
+#:% section = statement
+#:The `ColumnMatchTable()` method is provided by the macro file `unionTables.pl`.
+BEGIN_PGML
+Match each question with its answer.
+
+[@ ColumnMatchTable($ml) @]***
+END_PGML
+
+#:% section = answer
+ANS(str_cmp($ml->ra_correct_ans));
+
+#:% section = solution
+#: Extract the correct answers from the MatchList object and reformat.
+@correct      = @{ $ml->ra_correct_ans() };
+$answerstring = join(', ', @correct);
+
+BEGIN_PGML_SOLUTION
+The correct answers are [$answerstring].
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/MatchingAlt.pg b/tutorial/sample-problems/Misc/MatchingAlt.pg
new file mode 100644
index 0000000000..c17ac7db0e
--- /dev/null
+++ b/tutorial/sample-problems/Misc/MatchingAlt.pg
@@ -0,0 +1,155 @@
+## DESCRIPTION
+## Matching question template
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Date(05/23/2023)
+## Institution(Missouri Western State University)
+## Author(Glenn Rice)
+## KEYWORDS('matching', 'template')
+
+#:% name = Matching Problem (Alternate)
+#:% type = Sample
+#:% categories = [multiple choice, misc]
+
+#:% section = preamble
+#: The `parserPopUp.pl` macro is used to create drop down menus for answers, and
+#: the custom problem grader fluid from `PGgraders.pl` is used for incremental
+#: grading.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl', 'PGML.pl', 'parserPopUp.pl', 'PGgraders.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: Withhold feedback when answers are submitted by setting
+#: `$showPartialCorrectAnswers = 0;`.
+#:
+#: This problem uses an incremental grader called the `custom_problem_grader_fluid`.
+#: With this problem grader, the number of correct answers `[2, 4, 6]`
+#: and their corresponding scores `[0.3, 0.6, 1]` must be specified. The last
+#: entry in the `grader_numright` array must be the total number of questions
+#: asked, and the last entry in the `grader_scores` array must be 1
+#: (otherwise nobody can earn full credit!). The grader message can also
+#: be customized by setting the value of `grader_message` to the desired custom
+#: message.
+#:
+#: If a grader is desired that awards full credit when all questions are correct
+#: and no credit otherwise, use the commented out `std_problem_grader` code
+#: instead.
+#:
+#: The default `avg_problem_grader` could also be used by not using a custom
+#: problem grader at all to give credit for the parts that are correct.
+#: The percent score will be 100 * (number correct) / (number of questions) with
+#: the default grader.
+#:
+#: Create a list of 6 questions and answers, 2 extra answers, and a
+#: 'None of the above' answer that will be force to be last.
+$showPartialCorrectAnswers = 0;
+
+# Incremental grader
+install_problem_grader(~~&custom_problem_grader_fluid);
+$ENV{grader_numright} = [ 2,   4,   6 ];
+$ENV{grader_scores}   = [ 0.3, 0.6, 1 ];
+$ENV{grader_message} =
+    'You can earn '
+    . '30% partial credit for 2 - 3 correct answers, and '
+    . '60% partial credit for 4 - 5 correct answers.';
+
+# All or nothing grader
+# install_problem_grader(~~&std_problem_grader);
+
+# Create a list of questions and answers.
+@q_and_a = (
+    [ 'Question a?', 'Answer a' ],
+    [ 'Question b?', 'Answer b' ],
+    [ 'Question c?', 'Answer c' ],
+    [ 'Question d?', 'Answer d' ],
+    [ 'Question e?', 'Answer e' ],
+    [ 'Question f?', 'Answer f' ],
+);
+
+# Add extra incorrect answers
+@extra_a = ('Extra answer 1', 'Extra answer 2');
+
+# Randomize the questions.
+@q_and_a = map { splice(@q_and_a, random(0, $#q_and_a)) } 0 .. $#q_and_a;
+
+# Choose a random order to display the answers (including the incorrect answers).
+push(@answers, (map { $_->[1] } @q_and_a), @extra_a);
+@indices = (0 .. $#answers);
+@shuffle = map { splice(@indices, random(0, $#indices), 1) } 0 .. $#indices;
+
+# Create an inverse map back to the original indices.
+@inversion[@shuffle] = (0 .. $#shuffle);
+
+# Add an answer that is always last.  It is also incorrect in this case.
+push(@answers, 'None of the above');
+push(@shuffle, scalar(@shuffle));
+
+@answer_dropdowns =
+    map { DropDown([ @ALPHABET[ 0 .. $#answers ] ], $inversion[$_]) }
+    0 .. $#q_and_a;
+
+#:% section = statement
+#: Inject style into the page header to nicely show the questions on the left
+#: and the answers on the right. On narrow screens the answers will be below
+#: the questions.
+#:
+#: In the problem text a `div` with the css class defined in the style snippet
+#: wraps the questions and answers. Inside that the questions are in the first
+#: inner `div`, and the answers in the second inner `div`.
+#:
+#: When a hardcopy of the problem is generated two side by side parboxes are
+#: used instead.
+#:
+#: Both the questions and answers are added as PGML parsed strings.
+HEADER_TEXT(MODES(TeX => '', HTML => <<END_STYLE));
+<style>
+.two-column {
+    display: flex;
+	flex-wrap: wrap;
+	gap: 2rem;
+	align-items: center;
+	justify-content: space-evenly;
+}
+</style>
+END_STYLE
+
+BEGIN_PGML
+Match each question with its answer.
+
+[@ MODES(TeX => '\\parbox{0.4\\linewidth}{',
+	HTML => '<div class="two-column"><div>') @]*
+[@ join(
+    "\n\n",
+    map {
+        '[_]{$answer_dropdowns[' . $_ . ']} '
+            . '*' . ($_ + 1) . '.* '
+            . '[$q_and_a[' . $_ . '][0]]'
+    } 0 .. $#q_and_a
+) @]**
+[@ MODES(TeX => '}\\hfill\\parbox{0.4\\linewidth}{',
+	HTML => '</div><div>') @]*
+[@ join(
+    "\n\n",
+    map {
+        '*' . $ALPHABET[($_)] . '.* [$answers[$shuffle[' . $_ . ']]]'
+    } 0 .. $#answers
+) @]**
+[@ MODES(TeX => '}', HTML => '</div></div>') @]*
+END_PGML
+
+#:% section = solution
+#: Show the letter indices for the correct answers as a comma separated list.
+#: Use the `inversion` mapping to find the correct original indices.
+BEGIN_PGML_SOLUTION
+The correct answers are
+[@ join(', ', map { $ALPHABET[($inversion[($_)])] } 0 .. $#q_and_a) @]*.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/MatchingGraphs.pg b/tutorial/sample-problems/Misc/MatchingGraphs.pg
new file mode 100644
index 0000000000..e4475e5ef3
--- /dev/null
+++ b/tutorial/sample-problems/Misc/MatchingGraphs.pg
@@ -0,0 +1,173 @@
+## DESCRIPTION
+## Matching problem with graphs
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(07/15/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('matching', 'dynamic graph')
+
+#:% name = Matching Problem with Graphs
+#:% type = Sample
+#:% subject = [algebra, precalculus]
+#:% categories = [graph]
+
+#:% section = preamble
+#: The dynamic graph is generated with `PGtikz.pl`, so this is needed.
+#: The matching is done with popups, so `parserPopUp.pl` is need and lastly
+#: a `LayoutTable` is used from `niceTables.pl`.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl', 'PGML.pl', 'PGtikz.pl', 'parserPopUp.pl',
+    'niceTables.pl', 'PGcourse.pl'
+);
+
+#:% section = setup
+#: The array `@all_plots` contains the display form (f) of the function,
+#: the functional form (form) of the function needed in tikz format,
+#: the domain of the function and the alterative text.
+#:
+#: The graphs of all plots and then created by calling commands from `PGtikz.pl`.
+#: See PROBLINK('DynamicGraph.pg') for a simpler example using tikz. Note
+#: that alternate text is provided to the `image` command and for accessibility
+#: should always be considered and this should be provided.
+#:
+#: The dropdowns are created in the `@dropdown` array which pulls all
+#: options.
+#:
+#: The `LayoutTable` is used to make an accessible table that is nicely
+#: laid out.
+#:
+#: Although this matching problem creates graphs dynamically, these can use
+#: static images by changing the call to `image` to just pass in the
+#: image names.
+@all_plots = (
+    {
+        f      => 'x^2',
+        form   => '\x*\x',
+        domain => '-3:3',
+        alt    =>
+            'A graph of a curve with a minimum at the origin and opening '
+            . 'upward.'
+    },
+    {
+        f      => 'e^x',
+        form   => 'exp(\x)',
+        domain => '-6:3',
+        alt    => 'A graph of a curve starting near the negative x axis and '
+            . 'rising steeply toward the first quadrant.'
+    },
+    {
+        f      => 'x^3',
+        form   => '\x*\x*\x',
+        domain => '-2:2',
+        alt    => 'A graph of a curve from the third quadrant (where is it '
+            . 'concave down) to the first quadrant (where it is concave up).'
+    },
+    {
+        f      => 'ln(x)',
+        form   => 'ln(\x)',
+        domain => '0.1:6',
+        alt    => 'A graph of a curve that approaches the negative y-axis '
+            . 'and rises to the first quadrant and everywhere it is concave'
+            . 'down.'
+    },
+    {
+        f      => '3x+2',
+        form   => '3*\x+2',
+        domain => '-6:6',
+        alt    =>
+            'The graph of a line from the 3rd quadrant to the first quadrant'
+    },
+    {
+        f      => 'sin(x)',
+        form   => 'sin(\x r)',
+        domain => '-6:6',
+        alt    => 'A graph of a curve that osciallates and passes through the '
+            . 'origin'
+    },
+);
+
+for $i (0 .. $#all_plots) {
+    my $graph = createTikZImage();
+    $graph->tikzLibraries('arrows.meta');
+    $graph->BEGIN_TIKZ
+    \tikzset{>={Stealth[scale=1.5]}}
+    \filldraw[
+        draw=LightBlue,
+        fill=white,
+        rounded corners=10pt,
+        thick,use as bounding box
+    ] (-7,-7) rectangle (7,7);
+    \draw[->,thick] (-6,0) -- (6,0) node[above left,outer sep=3pt] {\(x\)};
+    \foreach \x in {-5,...,-1,1,2,...,5}
+        \draw(\x,5pt) -- (\x,-5pt) node [below] {\(\x\)};
+    \draw[->,thick] (0,-6) -- (0,6) node[below right,outer sep=3pt] {\(y\)};
+    \foreach \y in {-5,...,-1,1,2,...,5}
+        \draw (5pt,\y) -- (-5pt,\y) node[left] {\(\y\)};
+    \draw[blue,ultra thick] plot[domain=$all_plots[$i]->{domain},smooth] (\x,{$all_plots[$i]->{form}});
+END_TIKZ
+    $all_plots[$i]->{graph} = $graph;
+}
+
+@plots = random_subset(4, @all_plots);
+
+# sorted list of possible answers
+$list = [ lex_sort(map {"$_->{f}"} @all_plots) ];
+
+@dropdowns = map { DropDown($list, "$_->{f}") } @plots;
+
+$tab = LayoutTable(
+    [
+        [
+            map {
+                image(
+                    $plots[$_]->{graph},
+                    width           => 300,
+                    tex_size        => 400,
+                    extra_html_tags => "alt = '$plots[$_]->{alt}'"
+                )
+            } (0 .. 1)
+        ],
+        [ map { $dropdowns[$_]->menu } (0 .. 1) ],
+        [
+            map {
+                image(
+                    $plots[$_]->{graph},
+                    width           => 300,
+                    tex_size        => 400,
+                    extra_html_tags => "alt = '$plots[$_]->{alt}'"
+                )
+            } (2 .. 3)
+        ],
+        [ map { $dropdowns[$_]->menu } (2 .. 3) ]
+
+    ],
+    align => 'cc'
+);
+
+$showPartialCorrectAnswers = 0;
+
+#:% section = statement
+BEGIN_PGML
+Match the graph with the formula for the graph (Click on image for a larger view.)
+
+[$tab]*
+END_PGML
+
+#:% section = answer
+#: Because the dropdowns are created in the older fashion, we use the `ANS` form
+#: to check the answer
+ANS($dropdowns[$_]->cmp) for (0 .. 3);
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/MultipleChoiceCheckbox.pg b/tutorial/sample-problems/Misc/MultipleChoiceCheckbox.pg
new file mode 100644
index 0000000000..3fb2b1402d
--- /dev/null
+++ b/tutorial/sample-problems/Misc/MultipleChoiceCheckbox.pg
@@ -0,0 +1,100 @@
+## DESCRIPTION
+## Multiple choice template
+## ENDDESCRIPTION
+
+## KEYWORDS('multiple choice', 'template')
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+
+#:% name = Multiple Choice with Checkbox
+#:% type = [Sample, technique]
+#:% categories = [multiple choice, misc]
+#:% see_also = [MultipleChoiceRadio.pg, MultipleChoicePopup.pg, ManyMultipleChoice.pg]
+
+#:% section = preamble
+#: Include `parserCheckboxList.pl` in the `loadMacros`.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserCheckboxList.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: To setup, `CheckboxList` creates a new object. The format is
+#:```{#constructor .perl}
+#: $checks = CheckboxList([choices, ...], [correct_choices, ...], options);
+#:```
+#: where the `correct_choices` can either match those in `choices` or be the indices
+#: (starting at 0).
+#:
+#: If we nest `choices` in another arrayref, then the order of the choices will be randomized.
+#:
+#: Using the option `separator` and setting to `$SPACE x 10` results in
+#: a horizontal checklist.  Note that `$SPACE` should be used and not `&nbsp;` so that
+#: this works in both html and hardcopy.
+#:
+#: See PODLINK('the POD', 'parserCheckboxList.pl') for more options.
+$checks1 = CheckboxList(
+    [
+        "\(e^{x^2} e^{1/x}\)",
+        "\(e^{x^2} e^{x^{-1}}\)",
+        "\(\displaystyle\frac{e^{x^2}}{e^x}\)",
+        'None of the above'
+    ],
+    [ 0, 1 ]
+);
+
+$checks2 = CheckboxList(
+    [
+        [
+            "\(e^{x^2} e^{1/x}\)",
+            "\(e^{x^2} e^{x^{-1}}\)",
+            "\(\displaystyle\frac{e^{x^2}}{e^x}\)"
+        ],
+        'None of the above'
+    ],
+    [ 0, 1 ]
+);
+
+# This makes the checkbox list horizontal.
+$checks3 = CheckboxList(
+    [
+        "\(e^{x^2} e^{1/x}\)",
+        "\(e^{x^2} e^{x^{-1}}\)",
+        "\(\displaystyle\frac{e^{x^2}}{e^x}\)",
+        'None of the above'
+    ],
+    [ 0, 1 ],
+    separator => $SPACE x 10
+);
+
+#:% section = statement
+BEGIN_PGML
+Select all expressions that are equivalent to  [`e^{x^2 + 1/x}`].
+There may be more than one correct answer.
+
+[_]{$checks1}
+
+**Alternative with randomly ordered choices**
+
+[_]{$checks2}
+
+**Alternative shown with horizontal spacing**
+
+[_]{$checks3}
+END_PGML
+
+#:% section = solution
+#: The `correct_ans` method can be called to get the correct answer.
+BEGIN_PGML_SOLUTION
+The correct answer to the first is [$checks1->correct_ans].
+
+The correct answer to the second is [$checks2->correct_ans].
+
+The correct answer to the third is [$checks3->correct_ans].
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/MultipleChoicePopup.pg b/tutorial/sample-problems/Misc/MultipleChoicePopup.pg
new file mode 100644
index 0000000000..52823460d6
--- /dev/null
+++ b/tutorial/sample-problems/Misc/MultipleChoicePopup.pg
@@ -0,0 +1,67 @@
+## DESCRIPTION
+## Multiple choice template
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('multiple choice', 'template')
+
+#:% name = Multiple Choice with Popup
+#:% type = [Sample, technique]
+#:% categories = [multiple choice, misc]
+#:% see_also = [MultipleChoiceRadio.pg, MultipleChoiceCheckbox.pg, ManyMultipleChoice.pg]
+
+#:% section = preamble
+#: The macro `parserPopUp.pl` must be loaded.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserPopUp.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: To create a radio object, use `$popup = PopUp([choices,...],correct);`
+#: For details, see parserPopUp.pl The context is not really necessary, but multiple
+#: choice questions are often follow-up questions, so we leave it in.
+#:
+#: The `parsePopUp.pl` macro has two methods `PopUp` and `DropDown`. The former requires
+#: that a default `?` is coded in the first element.  The latter will put that in
+#: unless the `placeholder` option is there.
+#:
+#: Note: setting the `$showPartialCorrectAnswers` to 0 is often desirable for
+#: multiple choice problems so students don't know which part is incorrect and
+#: could therefore just guess the answer.
+$showPartialCorrectAnswers = 0;
+
+$popup = PopUp([ '?', 'Red', 'Blue', 'Green' ], 'Blue');
+
+$dropdown1 = DropDown([ 'Red', 'Blue', 'Green' ], 'Green');
+
+$dropdown2 =
+    DropDown([ 'Red', 'Blue', 'Green' ], 'Red', placeholder => 'Select One');
+
+#:% section = statement
+BEGIN_PGML
+Select my favorite color [_]{$popup}
+
+**Same thing, but using DropDown**
+
+Select my favorite color [_]{$dropdown1}
+
+**Same thing, but using DropDown with placeholder option**
+
+Select my favorite color [_]{$dropdown2}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+* The first correct answer is [$popup->correct_ans].
+* The second correct answer is [$dropdown1->correct_ans].
+* The third correct answer is [$dropdown2->correct_ans].
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/MultipleChoiceRadio.pg b/tutorial/sample-problems/Misc/MultipleChoiceRadio.pg
new file mode 100644
index 0000000000..c0d53089d8
--- /dev/null
+++ b/tutorial/sample-problems/Misc/MultipleChoiceRadio.pg
@@ -0,0 +1,60 @@
+## DESCRIPTION
+## Multiple choice template
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('multiple choice', 'template')
+
+#:% name = Multiple Choice with Radio Buttons
+#:% type = [Sample, technique]
+#:% categories = [multiple choice, misc]
+#:% see_also = [MultipleChoicePopup.pg, MultipleChoiceCheckbox.pg, ManyMultipleChoice.pg]
+
+#:% section = preamble color:blue
+#:The macro `parserRadioButtons.pl` must be loaded.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserRadioButtons.pl', 'PGcourse.pl');
+
+#:% section = setup
+#:To create a radio object, use `$radio = RadioButtons([choices,...],correct,options);`
+#:For all options, see MultipleChoiceProblems and parserRadioButtons.pl. The context
+#:is not really necessary, but multiple choice questions are often follow-up questions,
+#:so we leave it in.
+$radio1 = RadioButtons(
+    [ [ 'Red', 'Blue', 'Green' ], 'None of these' ],
+    'Blue',    # correct answer
+);
+
+$radio2 = RadioButtons(
+    [ [ 'Red', 'Blue', 'Green' ], 'None of these' ],
+    2,         # correct answer as an index (starting at 0)
+    separator => $SPACE x 4
+);
+
+#:% section = statement
+BEGIN_PGML
+My favorite color is
+
+[_]{$radio1}
+
+The same question with horizontal options:
+
+My favorite color is [_]{$radio2}
+END_PGML
+
+#:% section = solution
+#: The `correct_ans` method can be called to get the correct answer.
+BEGIN_PGML_SOLUTION
+The correct answer to the first is [$radio1->correct_ans].
+
+The correct answer to the first is [$radio2->correct_ans].
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/RandomPerson.pg b/tutorial/sample-problems/Misc/RandomPerson.pg
new file mode 100644
index 0000000000..1fa4edf1f8
--- /dev/null
+++ b/tutorial/sample-problems/Misc/RandomPerson.pg
@@ -0,0 +1,59 @@
+## DESCRIPTION
+## Shows the use of the randomNamesPronouns.pl macro
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(04/15/2023)
+## Institution(Fitchburg States)
+## Author(Peter Staab)
+## KEYWORDS('names', 'pronouns', 'random')
+
+#:% name = Random Person
+#:% type = Sample
+#:% categories = [misc]
+
+#:% section = preamble
+#: We need to load `randomPerson.pl` macro
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'randomPerson.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The macro `randomPerson.pl` provides functionality to
+#:
+#: * select a random name from a user-defined or default list with pronouns.
+#: * provide correct pronouns as well as verb conjugation.
+#:
+#: The `randomPerson(n => 3)` subroutine selects 3 unique random persons.
+#:
+#: See the `randomNamesPronouns.pl` POD for more information and example.
+($p1, $p2, $p3) = randomPerson(n => 3);
+
+$n = random(20, 30, 2);
+$c = random(4,  8,  2);
+
+#:% section = statement
+#: The objects `$p1, $p2` and `$p3` are `Person` objects and we can call the methods
+#: for name, and the pronouns `subject, possessive, possession` and `object` as well
+#: as the capitalized versions of each of these.  In addition, there is a `verb`
+#: method to conjugate most verbs as well as some irregular ones, like `do`
+#: which returns the correct conjugation of "to do".
+BEGIN_PGML
+[$p1] has a ribbon of length [$n] cm.  [$p1->Subject] [$p1->verb('cut')]
+[$c] cm off the ribbon and [$p1->verb('give')] the piece to [$p1->possessive]
+friend [$p2].
+
+[$p1] then [$p1->verb('divide')] the rest in half and [$p1->verb('give')]
+half to [$p1->possessive] friend [$p3].
+
+How much ribbon [$p1->do] [$p1] have left? [___]{Real(($n-$c)/2)}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Misc/Scaffolding.pg b/tutorial/sample-problems/Misc/Scaffolding.pg
new file mode 100644
index 0000000000..4926bea72e
--- /dev/null
+++ b/tutorial/sample-problems/Misc/Scaffolding.pg
@@ -0,0 +1,62 @@
+## DESCRIPTION
+## scaffolding template
+## ENDDESCRIPTION
+
+## KEYWORDS('scaffold','scaffolding', 'sequentially revealed')
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+
+#:% name = Scaffolded Problem
+#:% type = [Sample, technique]
+#:% categories = [misc]
+
+#:% section = preamble
+#: Make sure that the `scaffold.pl` macro is loaded.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'scaffold.pl', 'PGcourse.pl');
+
+#:% section = setup
+
+#:% section = statement
+#: Each `Section::Begin()` and `Section::End()` block can have its own context, etc.
+#: See the scaffold.pl macro file for Scaffold options.
+Scaffold::Begin();
+
+Section::Begin('Part 1: The first part');
+BEGIN_PGML
+This is the text for part 1.
+
+[`1 + 1 = `] [_]{2}{10}
+END_PGML
+Section::End();
+
+Section::Begin('Part 2: The second part');
+BEGIN_PGML
+This is text for the second part.
+
+[`2 * 2 = `] [_]{4}{10}
+END_PGML
+Section::End();
+
+Section::Begin('Part 3: The third part');
+BEGIN_PGML
+This is text for the third part.
+
+[`1 + 2 + 4 = `] [_]{7}{10}
+END_PGML
+Section::End();
+
+Scaffold::End();
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Parametric/ParametricEquationAnswers.pg b/tutorial/sample-problems/Parametric/ParametricEquationAnswers.pg
new file mode 100644
index 0000000000..3733c6d297
--- /dev/null
+++ b/tutorial/sample-problems/Parametric/ParametricEquationAnswers.pg
@@ -0,0 +1,111 @@
+## DESCRIPTION
+## Check student answers that are parametric equations
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('parametric equation', 'answer checker')
+
+#:% name = Parametric Equation Answer Checker
+#:% type = [Sample, technique]
+#:% subject = [differential calculus]
+#:% categories = [parametric, answer]
+
+#:% section = preamble
+#: Since there are multiple ways to parameterize, we use the `parserMultiAnswer.pl`
+#: macro.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserMultiAnswer.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We use a `MultiAnswer()` answer checker that will verify that the students
+#: answers satisfy the equation for the circle and have the required starting
+#: and ending points. This answer checker will allow students to enter any
+#: correct parametrization. For example, both
+#: x = \cos(t), y = sin(t), 0 ≤ t ≤ pi/3 and x = cos(2t), y = sin(2t),
+#: 0 ≤ t ≤ pi/6 will be marked correct.
+#:
+#: When evaluating student's answers, it is important not to use quotes. For
+#: example, if the code were `$xstu->eval(t=>"$t1stu")` with quotes, then if a
+#: student enters pi the answer checker will interpret it as the string "pi"
+#: which will need to be converted to a MathObject Real and numerical error
+#: will be introduced in the conversion. The correct code to use is
+#: `$xstu->eval(t=>$t1stu)` without quotes so that the answer is interpreted
+#: without a conversion that may introduce error.
+#:
+#: The first if statement is fully correct, that is the parametric functions
+#: are on the unit circle and the initial and final points are correct.
+#: The other three ifelse in the answer checker has either the second point,
+#: first point or both points wrong.
+Context("Numeric")->variables->are(t => "Real");
+Context()->variables->set(t => { limits => [ -5, 5 ] });
+
+$x  = Formula("cos(t)");
+$y  = Formula("sin(t)");
+$t0 = Compute("0");
+$t1 = Compute("pi/3");
+
+($x0, $y0) = (1, 0);
+($x1, $y1) = (1 / 2, sqrt(3) / 2);
+
+$multians = MultiAnswer($x, $y, $t0, $t1)->with(
+    singleResult => 0,
+    checker      => sub {
+        my ($correct, $student, $self) = @_;
+        my ($xstu, $ystu, $t0stu, $t1stu) = @{$student};
+        if ((($xstu**2 + $ystu**2) == 1)
+            && (($xstu->eval(t => $t0stu)) == $x0)
+            && (($ystu->eval(t => $t0stu)) == $y0)
+            && (($xstu->eval(t => $t1stu)) == $x1)
+            && (($ystu->eval(t => $t1stu)) == $y1))
+        {
+            return [ 1, 1, 1, 1 ];
+
+        } elsif ((($xstu**2 + $ystu**2) == 1)
+            && (($xstu->eval(t => $t0stu)) == $x0)
+            && (($ystu->eval(t => $t0stu)) == $y0))
+        {
+            return [ 1, 1, 1, 0 ];
+
+        } elsif ((($xstu**2 + $ystu**2) == 1)
+            && (($xstu->eval(t => $t1stu)) == $x1)
+            && (($ystu->eval(t => $t1stu)) == $y1))
+        {
+            return [ 1, 1, 0, 1 ];
+
+        } elsif ((($xstu**2 + $ystu**2) == 1)) {
+            return [ 1, 1, 0, 0 ];
+
+        } else {
+            return [ 0, 0, 0, 0 ];
+        }
+    }
+);
+#:% section = statement
+#: Since the correct answer depends on all answer blanks, the MathObject
+#: `$multians` is input into all answer blanks.
+BEGIN_PGML
+Find a parametrization of the unit circle from the point
+[` \big(1,0\big) `] to [` \big(\frac{1}{2},\frac{\sqrt{3}}{2}\big) `].
+Use [` t `] as the parameter for your answers.
+
+[` x(t) = `] [__]{$multians}
+
+[` y(t) = `] [__]{$multians}
+
+for [__]{$multians} to [__]{$multians}.
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Parametric/ParametricPlot.pg b/tutorial/sample-problems/Parametric/ParametricPlot.pg
new file mode 100644
index 0000000000..828d33f05f
--- /dev/null
+++ b/tutorial/sample-problems/Parametric/ParametricPlot.pg
@@ -0,0 +1,87 @@
+## DESCRIPTION
+## Graphing a parametric curve.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('parametric', 'graph')
+
+#:% name = Parametric Curve Graph
+#:% types = [Sample, technique]
+#:% subject = parametric
+
+#:% section = preamble
+#: We use `PGtikz.pl` to generate the graph.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGtikz.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The package `PGtikz.pl` is used to produce the curve.  Basics of such a plot
+#: are described in PROBLINK('TikZImages.pg').
+#:
+#: Most of the code for the plot produces the axes with the nice border.  The
+#: parametric plotting routine is the last function call starting with
+#: `\draw[DarkBlue, very thick] plot [....]`. Note that
+#:
+#: * `samples` is the number of points to create the plot.
+#: * `domain` is the plotting domain.
+#: * `variable` is the variable for the plot.  `\x` is default.  We switch to
+#: * `\t` as is standard for parametric plots.
+#: * The plot is in the `({}, {})` where the first slot is the `x` function and
+#:the second is the `y` function.  It is important that the functions are
+#:wrapped in `{}` and the variable has the backslash.
+Context()->variables->add(t => 'Real');
+
+$graph = createTikZImage();
+$graph->tikzLibraries('arrows.meta');
+$graph->BEGIN_TIKZ
+\tikzset{>={Stealth[scale=1.5]}}
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-3.5,-3.5) rectangle (3.5,3.5);
+\draw[->] (-3.5,0) -- (3.5,0) node[above left,outer sep=3pt] {\(x\)};
+\foreach \x in {-3,-2,-1,1,2,3} \draw (\x,0.15) -- (\x,-0.15) node [below] {\x};
+\draw[->] (0,-3.5) -- (0,3.5) node[below right,outer sep=3pt] {\(y\)};
+\foreach \y in {-3,-2,-1,1,2,3} \draw (0.15,\y) -- (-0.15,\y) node [left] {\y};
+\draw[DarkBlue,very thick]
+    plot [samples=250,domain=0:{2*pi},variable=\t]
+    ({2*sin(2*\t r)},{2*sin(3*\t r)});
+END_TIKZ
+
+$x  = Compute('2sin(2t)');
+$x0 = $x->eval(t => 'pi/3');
+$y  = Compute('2sin(3t)');
+$y0 = $y->eval(t => 'pi/3');
+
+$m    = $y->D('t')->eval(t => 'pi/3') / $x->D('t')->eval(t => 'pi/3');
+$line = Compute("$m*(x-$x0)+$y0");
+
+#:% section=statement
+BEGIN_PGML
+Find the tangent line to the parametric curve:
+>> [``x(t) = [$x], \qquad y(t) = [$y]``] <<
+
+when [`t=\pi/3`].  The graph of the curve is
+
+>>[@ image($graph, width => 300) @]*<<
+
+Tangent line in slope-intercept form
+
+[`y=`][_____]{$line}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Parametric/PolarGraph.pg b/tutorial/sample-problems/Parametric/PolarGraph.pg
new file mode 100644
index 0000000000..f0d2ba4a90
--- /dev/null
+++ b/tutorial/sample-problems/Parametric/PolarGraph.pg
@@ -0,0 +1,65 @@
+## DESCRIPTION
+## Graphing a polar curve given by r=f(theta)
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('parametric', 'graph polar curve')
+
+#:% name = Polar Graph
+#:% type = [sample, technique]
+#:% subject = parametric
+
+#:% section = preamble
+#: We use `PGtikz.pl` to generate the graph.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGtikz.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The package `PGtikz.pl` is used to produce the curve.  The plotting routine used in
+#: this way plots parametrically and we plot the polar curve parametrically.
+Context()->variables->are(t => 'Real');
+
+$graph = createTikZImage();
+$graph->tikzLibraries('arrows.meta');
+$graph->BEGIN_TIKZ
+\tikzset{>={Stealth[scale=1.5]}}
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-3.5,-3.5) rectangle (3.5,3.5);
+\draw[->] (-3.5,0) -- (3.5,0) node[above left,outer sep=3pt] {\(x\)};
+\draw[->] (0,-3.5) -- (0,3.5) node[below right,outer sep=3pt] {\(y\)};
+\draw[DarkGreen,very thick]
+    plot [samples=250,domain=0:{2*pi},variable=\t]
+    ({3*cos(5*\t r)*cos(\t r)},{3*cos(5*\t r)*sin(\t r)});
+\fill[opacity=0.5,fill=DarkGreen]
+    (0,0) -- plot[samples=250,domain={-pi/10}:{pi/10},variable=\t]
+    ({3*cos(5*\t r)*cos(\t r)},{3*cos(5*\t r)*sin(\t r)}) -- cycle;
+END_TIKZ
+
+BEGIN_PGML
+Find the area enclosed by one petal of the rose curve
+[`r = f(\theta) = \cos(5\theta)`].
+
+>>[@ image($graph, width => 300) @]*<<
+
+>>Graph of [`r = \cos(5\theta)`]<<
+
+Area = [_____]{'pi/20'}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Parametric/SpaceCurveGraph.pg b/tutorial/sample-problems/Parametric/SpaceCurveGraph.pg
new file mode 100644
index 0000000000..a58be7ee6e
--- /dev/null
+++ b/tutorial/sample-problems/Parametric/SpaceCurveGraph.pg
@@ -0,0 +1,45 @@
+## DESCRIPTION
+## Parametric equations: graphing a parametric curve in space
+## ENDDESCRIPTION
+
+## KEYWORDS('parametric', 'curve in space')
+
+## DBsubject('WeBWorK')
+## DBchapter(WeBWorK tutorial)
+## DBsection(Fort Lewis tutorial 2011)
+## Date('01/30/2011')
+## Author('Paul Pearson')
+## Institution('Fort Lewis College')
+
+#:% name = Space Curve Graph
+#:% type = Sample
+#:% subject = [parametric, graph]
+
+#:% section = preamble
+#: The macro `plotly3D.pl` is used to produce the graph.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'plotly3D.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: A `plotly3D` graph is created with the `Graph3D` function. There are many options as
+#: decribed in PODLINK('the POD','plotly3D.pl'), but to get started include the `height` and `width`.
+#:
+#: A parametric curve (space curve) is added to the graph with the `addCurve` method,
+#: which takes an array ref of length 3.  These are strings as javascript function in the
+#: variable `t`.  The second array ref is `[tmin, tmax, samples]`.
+$graph = Graph3D(
+    height => 300,
+    width  => 300,
+    title  => 'Spiral in 3D',
+);
+
+$graph->addCurve([ 't*cos(t)', 't*sin(t)', 't' ], [ 0, 6 * pi, 150 ]);
+
+#:% section = statement
+#: This just prints the graph.  No question is asked.
+BEGIN_PGML
+[@ $graph->Print @]*
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Parametric/Spacecurve.pg b/tutorial/sample-problems/Parametric/Spacecurve.pg
new file mode 100644
index 0000000000..0762b90b75
--- /dev/null
+++ b/tutorial/sample-problems/Parametric/Spacecurve.pg
@@ -0,0 +1,75 @@
+## DESCRIPTION
+## Parametric equations: parametric curve in space
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('parametric', 'curve in space')
+
+#:% name = Space Curve
+#:% type = Sample
+#:% subject = [parametric, vector calculus]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserMultiAnswer.pl', 'PGcourse.pl');
+
+$showPartialCorrectAnswers = 0;
+
+#:% section = setup
+#: Because the answers can vary and are interdependent, we use the `MultiAnswer` to check
+#: the results.
+#:
+#: We use `singleResult => 1` since it doesn't make sense to say that `x(t)` is correct but
+#: `z(t)` is incorrect since they depend on one another. First, we check that the student
+#: hasn't fed us a bogus constant solution such as `x=y=z=0` by requiring the x-coordinate
+#: to be a formula (not a constant) via
+#:```{.perl}
+#:return 0 unless $xstu->isFormula;
+#:```
+#: Then, we check
+#: that the student's answers satisfy the parametric equation.
+Context()->variables->are(t => 'Real');
+Context()->variables->set(t => { limits => [ 0, 10 ] });
+
+$a = random(-5, -2);
+$x = Formula("$a * t^2");
+$y = Formula('0');
+$z = Formula('t');
+
+$multians = MultiAnswer($x, $y, $z)->with(
+    singleResult => 1,
+    checker      => sub {
+        my ($correct, $student, $self) = @_;
+        my ($xstu,    $ystu,    $zstu) = @{$student};
+        return 0 unless $xstu->isFormula;
+        return (($xstu == $a * $zstu**2) && ($ystu == 0)) ? 1 : 0;
+    }
+);
+
+#:% section = statement
+#: Notice that we use `$multians` in each answer blank because they results in the
+#: three answers are dependent on each other.
+BEGIN_PGML
+Find a parametrization of the curve [`x = [$a] z^2`] in the [`xz`]-plane.  Use
+[`t`] as the parameter for all of your answers.
+
+[`x(t) =`] [_]{$multians}{15}
+
+[`y(t) =`] [_]{$multians}{15}
+
+[`z(t) =`] [_]{$multians}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Parametric/SurfaceGraph.pg b/tutorial/sample-problems/Parametric/SurfaceGraph.pg
new file mode 100644
index 0000000000..3aa5038840
--- /dev/null
+++ b/tutorial/sample-problems/Parametric/SurfaceGraph.pg
@@ -0,0 +1,51 @@
+## DESCRIPTION
+## Parametric equations: graphing a parametric curve in space
+## ENDDESCRIPTION
+
+## KEYWORDS('parametric', 'curve in space')
+
+## DBsubject('WeBWorK')
+## DBchapter(WeBWorK tutorial)
+## DBsection(Fort Lewis tutorial 2011)
+## Date('01/30/2011')
+## Author('Paul Pearson')
+## Institution('Fort Lewis College')
+
+#:% name = Surface Graph
+#:% type = Sample
+#:% subject = parametric
+
+#:% section = preamble
+#: The macro `plotly3D.pl` is used to produce the graph.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'plotly3D.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: A `plotly3D` graph is created with the `Graph3D` function. There are many option
+#: (see PODLINK('the POD','plotly3D.pl')), but to get started include the `height` and `width`.
+#:
+#: A parametric surface is added to the graph with the `addSurface` method,
+#: which takes 3 array refs, each of length 3.
+#: 1. These are strings as javascript function in the variables `u` and `v`.
+#: 2. The parametric range in `u` or `[umin, umax, samples]`.
+#: 3. The parametric range in `v` or `[vmin, vmax, samples]`.
+$graph = Graph3D(
+    height => 300,
+    width  => 300,
+    title  => 'Sphere',
+);
+
+$graph->addSurface(
+    [ '3*sin(v)*cos(u)', '3*sin(v)*sin(u)', '3*cos(v)' ],
+    [ 0,                 2 * pi,            30 ],
+    [ 0,                 pi,                30 ]
+);
+
+#:% section = statement
+#: This just prints the graph.  No question is asked.
+BEGIN_PGML
+[@ $graph->Print @]*
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Parametric/VectorParametricDerivative.pg b/tutorial/sample-problems/Parametric/VectorParametricDerivative.pg
new file mode 100644
index 0000000000..8e0b2455cc
--- /dev/null
+++ b/tutorial/sample-problems/Parametric/VectorParametricDerivative.pg
@@ -0,0 +1,64 @@
+## DESCRIPTION
+## Parametric equations: parametric curve in space
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('parametric', 'curve in space')
+
+#:% name = Parametric Vector Function with Derivative
+#:% type = Sample
+#:% subject = parametric
+
+#:% section = preamble
+#: Although not necessary for the code below, we load `parserVectorUtils.pl` because you may
+#: want to use some of its methods when you use this template file.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserVectorUtils.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We choose not to display the answer using ijk notation. Also, use `ijkAnyDimension => 1` to
+#: require a dimension match between i,j,k
+#: vectors and either the student or the correct answer when doing vector operations.
+#:
+#: The custom answer checker is used to check if the derivative matching the questioned asked.
+#: Use dot products of the student answer with the vectors `Vector(1,0)` and `Vector(0,1)` to
+#: get the components `$xstu` and `$ystu` of the student answer. Then, we can differentiate
+#: the components just like any `MathObject` formula.
+Context('Vector2D');
+Context()->variables->are(t => 'Real');
+Context()->variables->set(t => { limits => [ 0, 5 ] });
+Context()->flags->set(ijk => 0, ijkAnyDimension => 1);
+
+$ans = Vector("<2t,(2t)^2>")->cmp(
+    checker => sub {
+        my ($correct, $student, $ansHash) = @_;
+        my $xstu = $student . Vector(1, 0);
+        my $ystu = $student . Vector(0, 1);
+        return (($xstu->D('t') == Formula('2'))
+                && ($ystu->D('t') == Formula('8t'))) ? 1 : 0;
+    }
+);
+
+#:% section = statement
+BEGIN_PGML
+Find a vector parametric function [`\vec{r}(t)`]
+for a bug that moves along the parabola [`y = x^2`]
+with velocity [`\vec{v}(t) = \langle 2, 8t \rangle`]
+for all [`t`].
+
+[`\vec{r}(t) =`] [_]{$ans}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Parametric/VectorParametricFunction.pg b/tutorial/sample-problems/Parametric/VectorParametricFunction.pg
new file mode 100644
index 0000000000..f6a90c65b4
--- /dev/null
+++ b/tutorial/sample-problems/Parametric/VectorParametricFunction.pg
@@ -0,0 +1,92 @@
+## DESCRIPTION
+## Parametric equations: parametric curve in space
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('parametric', 'curve in space')
+
+#:% name = Vector Parametric Function
+#:% type = Sample
+#:% subject = parametric
+
+#:% section = preamble
+#: Since it is a vector parametric curve, we will want vector utilities from `parserVectorUtils.pl`.
+#: Since we will need to check multiple answer blanks that depend upon each other, we use `parserMultiAnswer.pl`.
+DOCUMENT();
+loadMacros(
+    'PGstandard.pl',        'PGML.pl',
+    'parserVectorUtils.pl', 'parserMultiAnswer.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: The student's vector-valued function is stored in `$f`. To get the x- and y-components
+#: of the students answer we dot it with the standard basis vectors using `$f . i` and `$f . j`.
+#: Note: If you want to differentiate the component functions in the student's answer, you'll
+#: need to use a different method as `($f . i)->D('t')` will generate errors since the dot
+#: product does not get evaluated. Another problem given in this section describes how to
+#: extract formulas from the components of the student's answer, which can then be differentiated.
+#: Notice that we have given the students helpful feedback messages about which endpoints are incorrect.
+Context('Vector2D');
+#Context('Vector'); # for 3D vectors
+Context()->variables->are(t => 'Real');
+Context()->variables->set(t => { limits => [ 0, 5 ] });
+Context()->flags->set(ijk => 0);
+
+$a = random(2, 5);
+$Q = Point($a, $a**2);
+
+$multians = MultiAnswer(Vector("<t,t**2>"), 0, $a)->with(
+    singleResult => 1,
+
+    checker => sub {
+
+        my ($correct, $student, $self) = @_;           # get the parameters
+        my ($f,       $x1,      $x2)   = @{$student};  # extract student answers
+        if ((($f . i)**2 == ($f . j))
+            && ($f->eval(t => $x1) == Vector("<0,0>"))
+            && ($f->eval(t => $x2) == Vector("<$a,$a**2>")))
+        {
+            return 1;
+        } elsif ((($f . i)**2 == ($f . j))
+            && ($f->eval(t => $x1) == Vector("<0,0>")))
+        {
+            $self->setMessage(3, 'Your right endpoint is not correct.');
+            return 0;
+        } elsif ((($f . i)**2 == ($f . j))
+            && ($f->eval(t => $x2) == Vector("<$a,$a**2>")))
+        {
+            $self->setMessage(2, 'Your left endpoint is not correct.');
+            return 0;
+        } elsif ((($f . i)**2 == ($f . j))) {
+            $self->setMessage(2, 'Your left endpoint is not correct.');
+            $self->setMessage(3, 'Your right endpoint is not correct.');
+            return 0;
+        } else {
+            return 0;
+        }
+    }
+);
+
+#:% section = statement
+BEGIN_PGML
+Find a vector parametric equation for the parabola
+[`y = x^2`] from the origin to the point
+[`[$Q]`] using [`t`] as a parameter.
+
+[`\vec{r}(t) =`] [_]{$multians}{10} for [___]{$multians}
+[`\leq t \leq`] [___]{$multians}.
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Parametric/VectorParametricLines.pg b/tutorial/sample-problems/Parametric/VectorParametricLines.pg
new file mode 100644
index 0000000000..b02f2dfb15
--- /dev/null
+++ b/tutorial/sample-problems/Parametric/VectorParametricLines.pg
@@ -0,0 +1,66 @@
+## DESCRIPTION
+## Parametric equations: vector parametric lines
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('parametric', 'vector parametric lines')
+
+#:% name = Parametric Lines
+#:% type = Sample
+#:% subject = parametric
+
+#:% section = preamble
+#: We load `parserVectorUtils.pl` which provides the `Line()` subroutine for a particular
+#: parametrization of a line, as well as `parserParametricLine.pl` which provides a subroutine
+#: `ParametricLine()` that allows students to enter any parametrization.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',        'PGML.pl',
+    'parserVectorUtils.pl', 'parserParametricLine.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: For the answer which is a particular parametrization through two points at times `t=0` and `t=1`,
+#: we use `Line()`. To allow students to enter any equation for a parametric line through two points,
+#: we use `ParametricLine()` The syntax is fairly self-explanatory.
+Context('Vector')->variables->are(t => 'Real');
+
+$P = non_zero_point3D(-9, 9, 1);
+$V = non_zero_vector3D(-9, 9, 1);
+
+$Q1 = Point($P + $V);
+$Q2 = Point($P + 2 * $V);
+
+$general    = ParametricLine($P, $V);
+$particular = Line($P, $V, '2t');
+
+#:% section = statement
+BEGIN_PGML
+a. Find any vector parametric equation for the
+line that goes through the points [`[$P]`] and
+[`[$Q1]`].
+
+    [`\vec{L}(t) =`] [_]{$general}{20}
+
+b. Find a vector parametric equation for the
+line that goes through the point [`[$P]`]
+when [`t = 0`] and the point [`[$Q2]`] when
+[`t = 1`].
+
+    [`\vec{L}(t) =`] [_]{$particular}{20}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/README.md b/tutorial/sample-problems/README.md
new file mode 100644
index 0000000000..558b45025b
--- /dev/null
+++ b/tutorial/sample-problems/README.md
@@ -0,0 +1,100 @@
+# Directory of Sample Problems
+
+This directory contains sample problems that were mostly original written by
+Paul Pearson. These have been copied from the OPL in `FortLewis/Authoring/Templates`.
+These problems have been updated to use PGML and current versions of macros.
+The wiki also had a number of problems listed as _Problem Techniques_ that did
+not exist in the OPL, so were generated to make runnable PG problems.
+
+## Metadata for a Sample Problem
+
+All metadata and documentation are embedded in a problem within comments that
+start with `#:%` or `#:`.  Metadata for a problem can appear anywhere but
+the standard location is just above the `DOCUMENT();` command.  The following
+metadata is currently supported.
+
+- **name**: the name of the problem as will appear in the documentation listings.
+- **type**: the type of the problem can be one or more of the following
+  - _sample_: a sample problem that would appear in some course.
+  - _technique_: a problem from the _Problem Techniques_ on the wiki which may
+  demonstrate something of interest, but may not be relevant as a sample problem.
+  - _snippet_: part of a problem that is useful if embedded in another problem.
+
+- **subject**: A subject area that a sample problem belongs to.  This may be more
+than one.
+- **see_also**: A listing of other problems (by the filename) that will appear
+in the documentation as a reference.
+- **category**: A listing of any categories that the problem would belong to.
+
+In many of these, if more than one is desired, place the list in brackets [ ].
+Also, both the singular and plural forms of the type, subject, category are
+supported.
+
+Here's an example:
+
+```perl
+#:% name = Surface Graph in Cylindrical Coordinates
+#:% type = [Sample, technique]
+#:% subject = [Vector Calculus]
+#:% see_also = [SpaceCurveGraph.pg, SurfaceGraph.pg]
+#:% categories = [graph]
+```
+
+## Structure of the code documenation
+
+The comments that are associated with each file in on the WeBWorK
+wiki have been embedded as formatted
+comments in the PGML files. The format for these have the form
+
+```perl
+#:% section = preamble
+#: This is the documentation comments for the preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We use `do { $b = random(2,9,1); } until ( $b != $a );` to generate distinct
+#: random numbers.
+$a = non_zero_random(-9, 9);
+do { $b = random(2,9,1); } until $b != $a;
+
+$answer1 = Compute("$a");
+$answer2 = Compute("($a x^($b) + $b) / x")->reduce();
+```
+
+where the beginning of a documentation block starts with `#:%` followed by a section name, then any options in the
+pattern `opt=value` or `opt:value`. The default names are `preamble`, `setup`, `statement`, `answer`, and `solution`.
+Note that at this point no actual options are honored.
+
+All documentation lines that start with `#:` and are formatted in markdown.
+
+All lines following the documentation lines are considered code until the next `#:%` line is encountered.
+
+## Generate the documentation
+
+The documentation is generated with the `parse-prob-doc.pl` script in the `bin`
+directory of pg. There are the following options (and many are required):
+
+- `problem_dir` or `d`:  The directory where the sample problems are.  This defaults to
+`PG_ROOT/tutorial/sample-problems` if not passed in.
+- `out_dir` or `o`: The directory where the resulting documentation files (HTML)
+will be located.
+- `pod_root` or `p`: The URL where the POD is located.  This is needed to
+correctly link POD documentation from the sample problems.
+- `pg_doc_home` or `h`: The URL of the directory for `out_dir`.  This is needed
+for correct linking.
+- `verbose` or `v`: verbose mode.
+
+After running, the following is created
+
+- the indexes `categories.html`, `techniques.html`, `macros.html` and `subjects.html` which
+produce four different ways of categorizing the problems.
+- For each sample problem, the problem will be parsed and
+  - an html file with the documented PG file
+  - a pg file with the documentation removed.  There is a link to this in the html file.
+
+The script `parse-prob-doc.pl` parses each pg file and uses the `problem-template.mt`
+template file to generate the
+html.  This template is processed using the `Mojo::Template` Perl module.  See the
+[Mojo::Template documentation](https://docs.mojolicious.org/Mojo/Template) for more information.
diff --git a/tutorial/sample-problems/Sequences/AnswerOrderedList.pg b/tutorial/sample-problems/Sequences/AnswerOrderedList.pg
new file mode 100644
index 0000000000..8ea33bf3f5
--- /dev/null
+++ b/tutorial/sample-problems/Sequences/AnswerOrderedList.pg
@@ -0,0 +1,54 @@
+## DESCRIPTION
+## Answer is an ordered list
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('integral calculus', 'answer is an ordered list')
+
+#:% name = Ordered List
+#:% type = Sample
+#:% subject = Sequences and Series
+#:% categories = [sequences, answer]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We create the array `@seq` with the first two entries.  The rest is filled
+#: with a `for` loop. Since the entries in the array `@seq` do not have commas between
+#: them, we create a Perl string `$answer` that joins the entries of the array `@seq` by
+#: a comma followed by a space ', '. Then, we make this string a MathObject by
+#: putting `Compute()` around it.
+#:
+#: Since the answer is a MathObject `List`, which is by default unordered, we must
+#: specify that the answer checker use `ordered=>1`.
+@seq = (1, 1);
+for $i (2 .. 6) {
+    $seq[$i] = $seq[ $i - 1 ] + $seq[ $i - 2 ];
+}
+
+$answer_cmp = Compute(join(', ', @seq))->cmp(ordered => 1);
+
+#:% section = statement
+BEGIN_PGML
+If [`s_1 = [$seq[0]]`], [`s_2 = [$seq[1]]`], and [`s_n = s_{n-1} + s_{n-2}`],
+find the first seven terms of this sequence, including [`s_1`] and [`s_2`].
+Enter your answer as a comma separated list of numbers.
+
+Sequence = [_]{$answer_cmp}{20}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Sequences/ExplicitSequence.pg b/tutorial/sample-problems/Sequences/ExplicitSequence.pg
new file mode 100644
index 0000000000..0c880da25f
--- /dev/null
+++ b/tutorial/sample-problems/Sequences/ExplicitSequence.pg
@@ -0,0 +1,62 @@
+## DESCRIPTION
+## Integral calculus: sequences
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('integral calculus', 'sequences')
+
+#:% name = Explicit Sequence
+#:% type = Sample
+#:% subject = Sequences and Series
+#:% categories = [sequences]
+#:% see_also = [FormulaTestPoints.pg, FormulaDomain.pg]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We set the test points to be positive integers to avoid errors when evaluating
+#: the answer. Even if you expect students to enter answers such as `cos(pi * n) / n!`,
+#: you should still restrict the domain to positive integers, because some students
+#: may simplify this to `(-1)^n / n!` and receive errors because the answer checker
+#: is substituting things such as n=0.5 into their formula.
+#:
+#: For more explanation on the `test_points` see PROBLINK('FormulaTestPoints.pg')
+Context()->variables->are(n => 'Real');
+
+$answer = Compute('(-1)^n / n!');
+$answer->{test_points} = [ [1], [2], [3], [4], [5], [6] ];
+
+@seq = (
+    "a_0 = 1",
+    "a_1 = -1",
+    "a_2 = \frac{1}{2}",
+    "a_3 = -\frac{1}{6}",
+    "a_4 = \frac{1}{24}",
+    "a_5 = -\frac{1}{120}",
+    "\ldots"
+);
+
+$sequence = join(', ', @seq);
+
+#:% section = statement
+BEGIN_PGML
+Find a formula for [`n^{th}`] term of the sequence [`[$sequence]`].
+
+[`a_n =`] [_]{$answer}{20}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Sequences/RecursiveSequence.pg b/tutorial/sample-problems/Sequences/RecursiveSequence.pg
new file mode 100644
index 0000000000..33c5612c04
--- /dev/null
+++ b/tutorial/sample-problems/Sequences/RecursiveSequence.pg
@@ -0,0 +1,59 @@
+## DESCRIPTION
+## Integral calculus: sequences and recursively defined functions
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('integral calculus', 'recursively defined functions')
+
+#:% name = Recursive Sequence
+#:% type = Sample
+#:% subject = Sequences and Series
+#:% categories = [sequences]
+
+#:% section = preamble
+#: We will be defining a new named function and adding it to the context, and the
+#: easiest way to do this is using parserFunction.pl. There is a more basic way to
+#: add functions to the context, which is explained in example 2 at AddingFunctions
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserFunction.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We define a new named function `f` as something the student is unlikely to guess.
+#: The named function `f` is, in some sense, just a placeholder since the student will
+#: enter expressions involving `f(n-1)`, WeBWorK will interpret it internally as
+#: `sin(pi^(n-1))+e*n^2`, and the only thing the student sees is `f(n-1)`.
+#: If the recursion
+#: has an closed-form solution (e.g., the Fibonacci numbers are given by
+#: `f(n) = (a^n - (1-a)^n)/sqrt(5)` where `a = (1+sqrt(5))/2)` and you want to allows
+#: students to enter the closed-form solution, it would be good to define `f` using
+#: that explicit solution in case the student tries to answer the question by writing
+#: out the explicit solution `(a^n - (1-a)^n)/sqrt(5)` instead of using the shorthand `f(n)`.
+Context()->variables->are(n => 'Real');
+parserFunction(f => 'sin(pi^n) + e * n^2');
+
+$fn = Formula('3 f(n - 1) + 2');
+
+#:% section = statement
+#: We should tell students to use function notation rather than subscript notation
+#: so that they aren't confused about syntax.
+BEGIN_PGML
+The current value [`f(n)`] is three times the previous value, plus two.  Find a
+recursive definition for [`f(n)`].  Enter [`f_{n-1}`] as [`f(n-1)`].
+
+[`f(n) =`] [_]{$fn}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Sequences/SeriesTest.pg b/tutorial/sample-problems/Sequences/SeriesTest.pg
new file mode 100644
index 0000000000..b2bfde3de2
--- /dev/null
+++ b/tutorial/sample-problems/Sequences/SeriesTest.pg
@@ -0,0 +1,137 @@
+## DESCRIPTION
+## Series: limit comparison test
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('integral calculus', 'limit comparison test')
+
+#:% name = Series Test
+#:% type = Sample
+#:% subject = Sequences and Series
+#:% categories = [sequences, series]
+
+#:% section = preamble
+#: We load `niceTables.pl` to create a table in which answer blanks are stacked on top
+#: of each other to form a fraction. We use `PGgraders.pl` to give partial credit
+#: incrementally. We use `parserMultiAnswer.pl` for the fraction answer so that we can
+#: accept two correct answers, depending on how much a student has simplified their answer.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl', 'PGML.pl',
+    'niceTables.pl', 'parserPopUp.pl',
+    'PGgraders.pl',  'parserMultiAnswer.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: We use the `MultiAnswer` object `$multians` to allow students to enter one of two
+#: correct answers. We could have also accomplished this using two custom answer checkers.
+#:
+#: We display the answerblanks nicely as a fraction in HTML and TeX modes by how we constructed `$showfraction`.
+Context()->variables->are(n => 'Real');
+
+$a = random(2, 9);
+$b = random(2, 9);
+$c = random(5, 20);
+$d = random(3, 9);
+$e = random(2, 9);
+
+$dm1 = $d - 1;
+$dm2 = $d - 2;
+
+# TeX
+$series   = "\sum_{n=$c}^{\infty} \frac{$a n + $b}{$c n^{$d} + $e}";
+$fraction = "\lim_{n\to\infty} \frac{a_n}{b_n} = \lim_{n\to\infty}";
+
+$num1 = Formula("$a n^$d + $b n^$dm1");
+$den1 = Formula("$c n^$d + $e");
+
+$num2 = Formula("$a + $b/n");
+$den2 = Formula("$c + $e/(n^$d)");
+
+$multians = MultiAnswer($num1, $den1)->with(
+    singleResult => 0,
+    checker      => sub {
+        my ($correct, $student, $ansHash) = @_;
+        my ($stu1, $stu2) = @{$student};
+
+        if (($num1 == $stu1 && $den1 == $stu2)
+            || ($num2 == $stu1 && $den2 == $stu2))
+        {
+            return [ 1, 1 ];
+        } elsif (($num1 == $stu1 && $den2 == $stu2)
+            || ($num2 == $stu1 && $den1 == $stu2))
+        {
+            $ansHash->setMessage(1, "Check your algebra");
+            $ansHash->setMessage(2, "Check your algebra");
+            return [ 0, 0 ];
+        } elsif ($num1 == $stu1 || $num2 == $stu1) {
+            return [ 1, 0 ];
+        } elsif ($den1 == $stu2 || $den2 == $stu2) {
+            return [ 0, 1 ];
+        } else {
+            return [ 0, 0 ];
+        }
+    }
+);
+
+$limit = Formula("$a/$c");
+$popup =
+    PopUp([ 'Choose', 'Converges', 'Diverges', 'Inconclusive' ], 'Converges');
+
+# Display the fraction and answer blanks nicely
+$frac = LayoutTable(
+    [ [ [ ans_rule(10), rowbottom => 1 ] ], [ ans_rule(10) ] ],
+    center     => 0,
+    allcellcss => { padding => '4pt' }
+);
+
+#:% section = statement
+#: Most of this is standard latex markup in a PGML block.  Note that to
+#: display the fraction above, we use `[$frac]*` followed by the
+#: PGML codeblock `[@ ANS($multians->cmp); '' @]` which does the
+#: answer checking using the multianswer described above.  There is a
+#: `''` at the tend of the codeblock to return an empty string instead of
+#: a HASHREF which we get from the ANS method.
+BEGIN_PGML
+Use the limit comparison test to determine whether
+[``\sum_{n=[$c]}^{\infty} a_n = \sum_{n=[$c]}^{\infty} \frac{[$a] n + [$b]}{[$c] n^{[$d]} + [$e]}``]
+converges or diverges.
+
+a. Choose a series [``\sum_{n=[$c]}^\infty b_n``] with terms of the form
+[``b_n = \frac{1}{n^p}``] and apply the limit comparison test.  Write your
+answer as a fully reduced fraction.  For [``n \geq [$c]``],
+[```\frac{\lim_{n \to \infty} a_n}{\lim_{n \to \infty} b_n}```][$frac]* [@ ANS($multians->cmp); '' @]
+
+b. Evaluate the limit in the previous part.  Enter [` \infty `] as _infinity_
+and [` -\infty `] as _-infinity_.  If the limit does not exist, enter _DNE_.
+
+[``\lim_{n\to\infty} \frac{a_{n}}{b_{n}} =``] [_]{$limit}{15}
+
+c. By the limit comparison test, does the series converge, diverge, or is the
+test inconclusive?  [_]{$popup}
+END_PGML
+
+#:% section = answer
+#: We use the problem grader fluid to give partial credit incrementally: 0% for 0-1
+#: correct answers, 40% for 2-3 correct answers, and full credit for 4 correct answers.
+install_problem_grader(~~&custom_problem_grader_fluid);
+
+$ENV{grader_numright} = [ 2,   4 ];
+$ENV{grader_scores}   = [ 0.4, 1 ];
+$ENV{grader_message} =
+    'You can earn 40% partial credit for 2 - 3 correct answers.';
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Statistics/linearRegression.pg b/tutorial/sample-problems/Statistics/linearRegression.pg
new file mode 100644
index 0000000000..d316f12e9b
--- /dev/null
+++ b/tutorial/sample-problems/Statistics/linearRegression.pg
@@ -0,0 +1,68 @@
+## DESCRIPTION
+##  Find the mean and standard deviation of a list of numbers.
+## ENDDESCRIPTION
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## KEYWORDS('statistic', 'linear regression', 'correlation coefficient')
+
+#:% name = Linear Regression
+#:% subject = [statistics]
+#:% type = sample
+
+#:% section = preamble
+#: Statistics functions mean and standard deviation are used so we load
+#: `PGstatisticsmacros.pl`.  We use the `DataTable` method from the
+#: `niceTables.pl` macro.
+DOCUMENT();
+
+loadMacros(
+    "PGstandard.pl",         "PGML.pl",
+    'PGstatisticsmacros.pl', 'niceTables.pl',
+    "PGcourse.pl"
+);
+
+#:% section = setup
+#: First, generate random numbers and then use the methods
+#: `sample_correlation` and `linear_regression`
+#: from the macro PODLINK('PGstatisticsmacros.pl').
+
+# produce an approximate slope and intercept
+$m = random(0.1, 0.75, 0.05);
+$b = random(0.5, 5,    0.25);
+
+# Create some random data
+for $i (0 .. 9) {
+    $x[$i] = random(2.5, 7.5, 0.5);
+    $y[$i] = $m * $x[$i] + $b;
+}
+
+@rows = ([ '\(x\)', '\(y\)' ]);
+push(@rows, [ $x[$_], $y[$_] ]) for (0 .. $#x);
+
+$corr = sample_correlation(~~@x, ~~@y);
+($m, $b) = sample_correlation(~~@x, ~~@y);
+
+#:% section = statement
+BEGIN_PGML
+Consider the following data:
+
+[@ DataTable(\@rows,
+  padding => [0.25, 0.25], horizontalrules => 1, align => '|c|c|' ) @]*
+
+Find the correlation coefficient and the linear regression line:
+
+a) correlation coefficient: [__]{$corr}
+
+b) linear regression line [`\hat{y}=`] [__]{Formula("$m x + $b")}
+
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Provide a solution here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Statistics/meanStdDev.pg b/tutorial/sample-problems/Statistics/meanStdDev.pg
new file mode 100644
index 0000000000..037e10fe15
--- /dev/null
+++ b/tutorial/sample-problems/Statistics/meanStdDev.pg
@@ -0,0 +1,64 @@
+## DESCRIPTION
+##  Find the mean and standard deviation of a list of numbers.
+## ENDDESCRIPTION
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## KEYWORDS('statistic', 'mean', 'standard deviation')
+
+#:% name = Mean and Standard Deviation
+#:% subject = [statistics]
+#:% type = sample
+
+#:% section = preamble
+#: Statistics functions mean and standard deviation are used so we load
+#: `PGstatisticsmacros.pl`.
+DOCUMENT();
+
+loadMacros("PGstandard.pl", "PGML.pl", 'PGstatisticsmacros.pl', "PGcourse.pl");
+
+#:% section = setup
+#: First, generate random numbers and then calculate the mean and standard
+#: deviation using the methods `stats_mean` and `stats_sd` from the macro
+#: PODLINK('PGstatisticsmacros.pl').
+for $i (0 .. 7) {
+    $x[$i] = random(1, 10);
+}
+
+$mean = stats_mean(@x);
+$sd   = stats_sd(@x);
+
+#:% section = statement
+BEGIN_PGML
+Find the mean and standard deviation of the following list of numbers:
+[@ join(', ', @x) @]
+
+a) Mean = [_____]{$mean}
+
+b) Standard Deviation = [___]{$sd}
+END_PGML
+
+#:% section = solution
+#: We use the method `stats_SX_SXX` of the `PGstatisticsmacros.pl` which
+#: returns the sum and sum of squares which aids in the solution.
+($sum_x, $sum_sq) = stats_SX_SXX(@x);
+$var = $sum_sq - ($sum_x**2) / 8;
+
+BEGIN_PGML_SOLUTION
+For the mean, use the formula
+
+[``\bar{x} = \frac{1}{n} \sum_{i=1}^n x_i = \frac{[$sum_x]}{8} = [$mean]``]
+
+For the standard deviation, first, find the variance
+
+[``s^2 = \frac{1}{n-1} \left(\sum_{i=1}^n x_i^2 - \frac{1}{n}(\sum_{i=1}^n x_i)^2\right) =
+\frac{1}{7} \left( [$sum_sq] - \frac{1}{8} ([$sum_x])^2\right) = \frac{[$var]}{7}``]
+
+and taking the square root
+
+[``s = [$sd]``]
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Trig/DisableFunctionsTrig.pg b/tutorial/sample-problems/Trig/DisableFunctionsTrig.pg
new file mode 100644
index 0000000000..567f0a7154
--- /dev/null
+++ b/tutorial/sample-problems/Trig/DisableFunctionsTrig.pg
@@ -0,0 +1,71 @@
+## DESCRIPTION
+## Disable functions and require exact fractions as answers.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('trigonometry', 'exact answer')
+
+#:% name = Disabling Functions
+#:% type = [Sample, technique]
+#:% subject = [trigonometry, precalculus]
+#:% categories = [trigonometry]
+
+#:% section = preamble
+#: The `contextFraction.pl` is loaded since we used the `Fraction-NoDecimals` context.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextFraction.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We choose a context that requires fractions as answers and does not allow decimals.
+#: After constructing the formulas involving trig functions, we disable all functions
+#: and re-enable the `sqrt()` function. This means that students are allowed to type in
+#: fractions and square roots, but not much else (e.g., they'll get an error message
+#: if they type in a trig function).
+#:
+#: Note that `$f1` and `$f2` are MathObject Formulas, which do not get reduced since `pi`
+#: is set to keep its name. If `$f1` and `$f2` used `Compute` instead, then the results
+#: would be -1 and 0.866... instead of cos(\pi) and sin(\pi/3) as desired.
+Context('Fraction-NoDecimals');
+
+# Prevent pi from becoming 3.1415... and cos(pi) from
+# becoming -1.
+Context()->constants->set(pi => { keepName => 1 });
+
+# The next context changes are not necessary to
+# prevent cos(pi) from becoming -1, but they cannot hurt.
+Context()->flags->set(
+    reduceConstants         => 0,
+    reduceConstantFunctions => 0
+);
+
+$f1 = Formula('cos(pi)');
+$f2 = Formula('sin(pi/3)');
+
+Context()->functions->disable('All');
+Context()->functions->enable('sqrt');
+
+$answer1 = Compute('-1');
+$answer2 = Compute('sqrt(3)/2');
+
+#:% section = statement
+BEGIN_PGML
+Enter your answers as simplified fractions.
+
++ [`[$f1] =`] [_]{$answer1}{15}
+
++ [`[$f2] =`] [_]{$answer2}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+The cosine of an angle is zero when the angle is an integer multiple of [`\pi`].
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Trig/DraggableIdentity.pg b/tutorial/sample-problems/Trig/DraggableIdentity.pg
new file mode 100644
index 0000000000..4b5807efc4
--- /dev/null
+++ b/tutorial/sample-problems/Trig/DraggableIdentity.pg
@@ -0,0 +1,64 @@
+## DESCRIPTION
+## A draggable proof to prove a trigonmetric identity.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Fort Lewis tutorial 2011)
+## Date(03/10/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('draggable proof', 'trigonometry')
+
+#:% name = Draggable Trigonometry Identity
+#:% type = Sample
+#:% subject = [proof, trigonometry]
+#:% categories = [trigonometry, draggable]
+
+#:% section = preamble
+#: This problem uses the `draggableProof.pl` macro to display "buckets" that the
+#: student can drag statements to and from.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'draggableProof.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The `DraggableProof` function takes an arrayref of correct statements,
+#: followed (optionally) by extra statements. See
+#: PODLINK('the Draggable Proof POD', 'draggableProof.pl') for more options.
+#:
+#: This shows how other identities could be structured. You probably want
+#: some incorrect statements to make the problem a little bit harder.
+$proof = DraggableProof(
+    # These are the correct statements of the proof in the correct order.
+    [
+        '\(\sin(\pi-\theta) = \sin(\pi)\cos(\theta)-\cos(\pi)\sin(\theta) \)',
+        '\(\sin(\pi-\theta) = 0 \cdot \cos(\theta) - (-1)\cdot \sin(\theta)\)',
+        '\(\sin(\pi-\theta) = 0+1\sin(\theta)\)',
+        '\(\sin(\pi-\theta) = \sin(\theta)\)',
+    ],
+    # These are extra statements that are not needed.
+    [
+        '\(\sin(\pi-\theta) = \cos(\pi)\cos(\theta)-\sin(\pi)\sin(\theta) \)',
+        '\(\sin(\pi-\theta) = 0\cdot\cos(\theta)-(-1)\sin(\theta) \)',
+        '\(\sin(\pi-\theta) = \sin(\pi)\cos(\theta)+\cos(\pi)\sin(\theta) \)',
+        '\(\sin(\pi-\theta) = 0\cdot\cos(\theta)+1 \cdot\sin(\theta) \)',
+        '\(\sin(\pi-\theta) = 1\cdot\cos(\theta)+0 \cdot\sin(\theta) \)',
+    ]
+);
+
+#:% section = statement
+#: The line `[_]{$proof}` prints the statement and options in the proof and sets up the answer rule.
+BEGIN_PGML
+Prove the trigonmetric identity [`\sin(\pi-\theta) = \sin(\theta)`].
+
+[_]{$proof}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Trig/PeriodicAnswers.pg b/tutorial/sample-problems/Trig/PeriodicAnswers.pg
new file mode 100644
index 0000000000..99963be619
--- /dev/null
+++ b/tutorial/sample-problems/Trig/PeriodicAnswers.pg
@@ -0,0 +1,42 @@
+## DESCRIPTION
+## Periodic answers
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('trigonometry', 'periodic answer')
+
+#:% name = Periodic Answers
+#:% type = Sample
+#:% subject = [trigonometry, precalculus]
+#:% categories = [trigonometry]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: This allows any answer of the form `pi/2+n pi` for integer `n` to be
+#: accepted.
+$answer = Real('pi/2')->with(period => pi);
+
+#:% section = statement
+BEGIN_PGML
+Enter a solution to [`\cos(\theta) = 0`].
+
+[`\theta =`] [_]{$answer}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+The cosine of an angle is zero when the angle is [`(n + 1 / 2)\pi`] for any
+integer [`n`].
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Trig/ProvingTrigIdentities.pg b/tutorial/sample-problems/Trig/ProvingTrigIdentities.pg
new file mode 100644
index 0000000000..8a4abb58bd
--- /dev/null
+++ b/tutorial/sample-problems/Trig/ProvingTrigIdentities.pg
@@ -0,0 +1,102 @@
+## DESCRIPTION
+## Proving trig identities
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## Static(1)
+## MO(1)
+## KEYWORDS('trigonometry', 'proving trig identities')
+
+#:% name = Proving Identities
+#:% type = Sample
+#:% subject = [trigonometry, precalculus]
+#:% categories = [trigonometry, proof]
+
+#:% section = preamble
+#: This is a scaffolded problem, so load `scaffold.pl`.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'scaffold.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We cleverly redefine the sine function so that when the student enters `sin(t)`,
+#: it is interpreted and evaluated internally as `exp(pi*t)` but displayed to
+#: the student as `sin(t)`. This prevents the entering of the orginally
+#: expression as the answer.  An alternative method to doing this is in
+#: PROBLINK('TrigIdentities.pg').
+Context()->variables->are(t => 'Real');
+
+# Redefine sin(x) to be e^(pi x).
+Context()->functions->remove('sin');
+
+package NewFunc;
+# The next line makes the function a function from reals to reals.
+our @ISA = qw(Parser::Function::numeric);
+
+sub sin {
+    shift;
+    my $x = shift;
+    return CORE::exp($x * 3.1415926535);
+}
+
+package main;
+# Make it work on formulas as well as numbers
+# sub cos { Parser::Function->call('cos', @_) } # if uncommented, this line will generate error messages
+# Add the new functions to the Context.
+Context()->functions->add(sin => { class => 'NewFunc', TeX => '\sin' },);
+
+#:% section = statement
+BEGIN_PGML
+This problem has three parts.  A part may be open if it is correct or if it is
+the first incorrect part.  Clicking on the heading for a part toggles whether it
+is displayed.
+
+In this multi-part problem, we will use algebra to verify the identity
+
+>>[`\displaystyle \frac{\sin(t)}{1 - \cos(t)} = \frac{1 + \cos(t)}{\sin(t)}.`]<<
+
+END_PGML
+
+Scaffold::Begin(is_open => 'correct_or_first_incorrect');
+
+Section::Begin('Part 1');
+BEGIN_PGML
+
+First, using algebra we may rewrite the equation above as
+[`\displaystyle \sin(t) = \left( \frac{1 + \cos(t)}{\sin(t)} \right) \cdot \Big(`]
+[_]{'1 - cos(t)'}{15} [` \Big) `].
+END_PGML
+Section::End();
+
+Section::Begin('Part 2');
+BEGIN_PGML
+Using algebra we may rewrite the equation as
+[`\sin(t) \cdot \big(`] [_]{'sin(t)'}{15}
+[`\big) = \big(1 + \cos(t)\big) \cdot \big(1 - \cos(t)\big)`].
+END_PGML
+Section::End();
+
+Section::Begin('Part 3');
+BEGIN_PGML
+Finally, using algebra we may rewrite the equation as
+[`\sin^2(t) =`] [_]{'1-(cos(t))^2'}{15}, which is true since
+[`\cos^2(t) + \sin^2(t) = 1`]. Thus, the original identity can be derived by
+reversing these steps.
+END_PGML
+Section::End();
+
+Scaffold::End();
+
+COMMENT(
+    'This is a multi-part problem
+in which the next part is revealed only after the previous
+part is correct.  Prevents students from entering trivial
+identities (entering what they were given).  Uses PGML.'
+);
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Trig/SpecialTrigValues.pg b/tutorial/sample-problems/Trig/SpecialTrigValues.pg
new file mode 100644
index 0000000000..f3240a1fff
--- /dev/null
+++ b/tutorial/sample-problems/Trig/SpecialTrigValues.pg
@@ -0,0 +1,67 @@
+## DESCRIPTION
+## Displays values of trig functions on the unit circle
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(PCC)
+## Author(Alex Jordan)
+## MO(1)
+## KEYWORDS('trigonometry', 'unit circle')
+
+#:% name = Using Special Trig Values on the Unit Circle
+#:% type = Sample
+#:% subject = trigonometry
+
+#:% section = preamble
+#: We load the `specialTrigValues.pl` macro to use exact values on the
+#: unit circle.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'specialTrigValues.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The `random_coprime` function selects two random numbers that are coprime
+#: from the list.  This will give fractions with denominators of 2,3,4 or 6.
+#:
+#: The `specialRadical` function returns a MathObject in the form `a sqrt(b)/c`
+#: were b, c come from a list of integers (defaults to `[1,2,3]`).
+#:
+#: It is noted that `specialRadical` has a complex form as well.
+#:
+#: The `specialAngle` function returns a MathObject in the form `a pi/c` where
+#: a in an integer and `c` comes from a list (defaults to `[1,2,3,4,6]`).
+($d, $n) = random_coprime([ 2, 3, 4, 6 ], [ 1 .. 12 ]);
+
+$r = random(2, 3);
+
+$c = specialRadical("$r cos($n pi/$d)");
+$s = specialRadical("$r sin($n pi/$d)");
+
+$x = list_random(sqrt(3) / 2, sqrt(2) / 2, 1 / 2);
+$a = specialAngle(arcsin($x));
+
+Context("Complex");
+$z = specialRadical("$r exp($n pi i/$d)");
+
+#:% section = statement
+BEGIN_PGML
+Evaluate the following:
+
+a) [`[$r] \cos([$n] \pi/[$d])=`] [_]{$c}
+
+b) [`[$r] \sin([$n] \pi/[$d])=`] [_]{$s}
+
+c) [`[$r] \exp([$n] \pi/[$d])=`] [_]{$z}
+
+d) [`\arcsin([$x])=`] [_]{$a}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Trig/TrigDegrees.pg b/tutorial/sample-problems/Trig/TrigDegrees.pg
new file mode 100644
index 0000000000..0c5c151356
--- /dev/null
+++ b/tutorial/sample-problems/Trig/TrigDegrees.pg
@@ -0,0 +1,53 @@
+## DESCRIPTION
+## Trigonometry: trig functions in degrees using context TrigDegrees
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(Demos)
+## DBsection(Problem)
+## Date(2021/07/22)
+## Institution(Champlain College Saint-Lambert)
+## Author(Michele Titcombe)
+## MO(1)
+## KEYWORDS('trigonometry', 'trig functions in degrees', 'degrees')
+
+#:% name = Degrees in Trigonometric Functions
+#:% type = [technique, sample]
+#:% subject = [trigonometry, precalculus]
+#:% categories = [trigonometry, degrees]
+
+#:% section = preamble
+#: We load the `contextTrigDegrees.pl` macro to help with trig functions with degrees.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextTrigDegrees.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: To override the WeBWorK default of evaluating trig functions in radians, use the `TrigDegrees` context,
+#: which redefines the standard trig functions to be in degrees, both in any formulas that appear
+#: later in the PG code and in any formulas that students enter in answer blanks.
+#:
+#: These redefined functions allow students to enter inverse functions using syntax such as
+#: `atan(x)`, or `arctan(x)`, or `tan^(-1)(x)`.
+Context('TrigDegrees');
+
+$ans1 = Compute("sin(30)");
+$ans2 = Compute("arcsin(0.5)");
+
+#:% section = statement
+#: Since this is in degrees, you should tell the students this.
+BEGIN_PGML
+1. [`\sin(30^{\circ})=`] [___]{$ans1}
+2. [`\arcsin(1/2)=`] [___]{$ans2}
+
+Interpret arguments of the sine and arcsine in terms of degrees.
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+COMMENT("Redefines trig functions to be in degrees (not radians).");
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/Trig/TrigIdentities.pg b/tutorial/sample-problems/Trig/TrigIdentities.pg
new file mode 100644
index 0000000000..d4293d8cd7
--- /dev/null
+++ b/tutorial/sample-problems/Trig/TrigIdentities.pg
@@ -0,0 +1,58 @@
+## DESCRIPTION
+## Trigonometric identities
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('trigonometry', 'trig identity')
+
+#:% name = Trigonometric Identities
+#:% type = Sample
+#:% subject = [trigonometry, precalculus]
+#:% categories = [trigonometry, custom]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: To prevent the student from just entering the given expression, we create
+#: a custom answer checker, which 1) performs a `->reduce` which will do some
+#: small simplification, 2) returns an error if the original expression
+#: was put in and 3) then checks if the answer is correct.
+#:
+#: An alternative method to doing this is in
+#: PROBLINK('ProvingTrigIdentities.pg').
+$ans = Compute('sin(x)')->cmp(
+    checker => sub {
+        my ($correct, $student, $ansHash) = @_;
+        my $stu_ans = $student->reduce;
+        Value->Error('There is a simpler answer')
+            if $stu_ans->string eq 'cos(x)*tan(x)';
+        return $student == $correct;
+    }
+);
+
+#:% section = statement
+BEGIN_PGML
+Simplify the expression as much as possible.
+
+[`\tan(x) \cos(x) =`] [_]{$ans}{15}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+COMMENT(
+    'Prevents students from entering trivial identities (entering what they '
+        . 'were given)');
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/VectorCalc/CylindricalGraph3D.pg b/tutorial/sample-problems/VectorCalc/CylindricalGraph3D.pg
new file mode 100644
index 0000000000..34663c4084
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/CylindricalGraph3D.pg
@@ -0,0 +1,73 @@
+## DESCRIPTION
+## This shows an interactive graph in 3D in cylindrical coordinates.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('algebra', 'dynamic graph')
+
+#:% name = Surface Graph in Cylindrical Coordinates
+#:% type = Sample
+#:% subject = [Vector Calculus]
+#:% see_also = [SpaceCurveGraph.pg, SurfaceGraph.pg]
+#:% categories = [graph]
+
+#:% section = preamble
+#: The dynamic graph is generated with `plotly3D.pl`,
+#: so this is needed.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'plotly3D.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: We generate the plot parametrically for the radial functions `z=cos(r^2/4)`
+#: and `z=r*sin^2(t)`.
+#:
+#: This occurs with `x=u*cos(v)` and `y=u*sin(v)`, where `u` and `v` are
+#: used as the radial and angular variables respectively.  These are the
+#: default variables used.
+#:
+#: The second plot changes the variables to `r` and `t` and shows a function
+#: with a non-rotational symmetric plot.
+#:
+#: The `addSurface` is very flexible, but if you are plotting a function in
+#: cylindrical coordinates, then the first two functions should remain the
+#: same.
+#:
+#: See PODLINK('plotly3D.pl') for more information on options.
+$a = random(2, 5);
+
+$gr1 = Graph3D();
+$gr1->addSurface(
+    [ 'u*cos(v)', 'u*sin(v)', "$a*cos(u^2/4)" ],
+    [ 0,          6,          30 ],
+    [ 0,          2 * pi,     30 ]
+);
+
+$gr2 = Graph3D();
+$gr2->addSurface(
+    [ 'r*cos(t)', 'r*sin(t)', 'r*sin(t)^2' ],
+    [ 0,          6,          30 ],
+    [ 0,          2 * pi,     30 ],
+    variables => [ 'r', 't' ]
+);
+
+#:% section=statement
+#: This shows how to add a plot to the problem.
+BEGIN_PGML
+This just shows the two plots side by side.
+
+[@ $gr1->Print @]* [@ $gr2->Print @]*
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/VectorCalc/DirectionField.pg b/tutorial/sample-problems/VectorCalc/DirectionField.pg
new file mode 100644
index 0000000000..da85cb3ce7
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/DirectionField.pg
@@ -0,0 +1,76 @@
+## DESCRIPTION
+## Vector Calculus: graph of a 2D direction field
+## ENDDESCRIPTION
+
+## KEYWORDS('vector calculus', 'direction field')
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+
+#:% name = Direction Field
+#:% subject = [Differential Equations, Vector Calculus]
+#:% type = [Sample, technique]
+#:% categories = [graph]
+#:% see_also = [VectorFieldGraph2D.pg]
+
+#:% section=preamble
+#: The macro `PGtikz.pl` is used to produced the direction field.
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGtikz.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: A direction field is a vector field where the length of the vectors are
+#: constant.  We use the same technique as PROBLINK('VectorFieldGraph2D.pg').
+#:
+#: The vector field <y,-x> is used and then when the vector is drawn is
+#: scaled by its length or `sqrt(x^2+y^2)`.  Since this is not defined at
+#: the origin, we don't draw the vector there and use the `ifthen` package
+#: to load the `\ifthenelse` latex command.
+#:
+#: If you want a slope field, where only the slope is draw with no arrow
+#: delete the `->` in the option of the `\draw` command inside the `\foreach`
+#: loops.
+$graph = createTikZImage();
+$graph->texPackages(['ifthen']);
+$graph->BEGIN_TIKZ
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-6,-6) rectangle (6,6);
+\draw[dotted] (-5,-5) grid (5,5);
+\draw[->] (-5,0) -- (5.25,0) node[above right] {\(x\)};
+\foreach \x in {-5,...,-1,1,2,...,5} \draw(\x,-5) node [below] {\x};
+\draw[->] (0,-5) -- (0,5.25) node[above right] {\(y\)};
+\foreach \y in {-5,...,-1,1,2,...,5} \draw(-5,\y) node [left] {\y};
+\foreach \x in {-4.5,-4,...,4.5} {
+	\foreach \y in {-4.5,-4,...,4.5} {
+		\ifthenelse{\equal{\x}{0} \AND \equal{\y}{0}}{}{
+			\draw[thick, blue,->] (\x,\y) --
+				({\x+0.4*\y/sqrt(\x*\x+\y*\y)},{\y-0.4*\x/sqrt(\x*\x+\y*\y)});
+			}
+		}
+	}
+END_TIKZ
+
+#:% section = statement
+#: This shows the vector field graph.
+BEGIN_PGML
+This is a direction field for
+[``\vec{v} =  \left< y, -x \right>``]
+
+>> [@ image($graph, width=> 400) @]* <<
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
+
diff --git a/tutorial/sample-problems/VectorCalc/RectangularGraph3D.pg b/tutorial/sample-problems/VectorCalc/RectangularGraph3D.pg
new file mode 100644
index 0000000000..62c30ba1c1
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/RectangularGraph3D.pg
@@ -0,0 +1,58 @@
+## DESCRIPTION
+## This shows an interactive graph in 3D in rectangular coordinates.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('vector calculus', 'dynamic graph' , 'cylindrical')
+
+#:% name = Surface Graph in Rectangular Coordinates
+#:% type = Sample
+#:% subject = [Vector Calculus, multivariate calculus]
+#:% see_also = [SpaceCurveGraph.pg, SurfaceGraph.pg, CylindricalGraph3D.pg]
+#:% categories = [graph]
+
+#:% section = preamble
+#: The dynamic graph is generated with `plotly3D.pl`,
+#: so this is needed.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'plotly3D.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: We generate the plot parametrically for the function `z=x^2+y^2` with the
+#: `addSurface` function.  Since `x` and `y` are generally used with
+#: rectangular coordinates, we set them with the
+#:```{#vars .perl}
+#:variables => ['x','y']
+#:```
+#:
+#: See PODLINK('plotly3D.pl') for more information on options.
+
+$gr = Graph3D();
+$gr->addSurface(
+    [ 'x', 'y', 'x^2+y^2' ],
+    [ -3,  3,   30 ],
+    [ -3,  3,   30 ],
+    variables => [ 'x', 'y' ]
+);
+
+#:% section=statement
+#: This shows how to add a plot to the problem.
+BEGIN_PGML
+The following is the plot of [`z=x^2+y^2`]
+
+[@ $gr->Print @]*
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/VectorCalc/VectorFieldGraph2D.pg b/tutorial/sample-problems/VectorCalc/VectorFieldGraph2D.pg
new file mode 100644
index 0000000000..bea1fa6801
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/VectorFieldGraph2D.pg
@@ -0,0 +1,72 @@
+## DESCRIPTION
+## Vector Calculus: graph of a 2D vector field
+## ENDDESCRIPTION
+
+## KEYWORDS('vector calculus', 'vector field graph 2D')
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+
+#:% name = Two-D Vector Field
+#:% subject = [Differential Equations, Vector Calculus]
+#:% type = Sample
+#:% categories = [graph]
+#:% see_also = [DirectionField.pg]
+
+#:% section=preamble
+#: The macro `PGtikz.pl` is used to produced the vector field.
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGtikz.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: The vector field is created directly.  The vector field is
+#: <x/(x^2+y^2), y/(x^2+y^2)> which is not defined at the origin.  Therefore,
+#: we don't draw the vector there and use the `ifthen` package to load the `\ifthenelse`
+#: latex command.
+#:
+#: The vector is created using the `\draw` command.
+$graph = createTikZImage();
+$graph->texPackages(['ifthen']);
+$graph->BEGIN_TIKZ
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-6,-6) rectangle (6,6);
+\draw[dotted] (-5,-5) grid (5,5);
+\draw[->] (-5,0) -- (5.25,0) node[above right] {\(x\)};
+\foreach \x in {-5,...,-1,1,2,...,5} \draw(\x,-5) node [below] {\x};
+\draw[->] (0,-5) -- (0,5.25) node[above right] {\(y\)};
+\foreach \y in {-5,...,-1,1,2,...,5} \draw(-5,\y) node [left] {\y};
+\foreach \x in {-4,...,4} {
+	\foreach \y in {-4,...,4} {
+		\ifthenelse{\equal{\x}{0} \AND \equal{\y}{0}}{}{
+			\draw[thick, blue,->] (\x,\y) -- ({\x+\x/(\x*\x+\y*\y)},{\y+\y/(\x*\x+\y*\y)});
+			}
+	}
+}
+END_TIKZ
+
+#:% section=statement
+#: This shows the vector field graph.
+BEGIN_PGML
+This is a velocity vector field for an explosion at the origin
+that decreases in speed the farther the distance is from the origin.
+
+[``\vec{v} =  \left< \frac{x}{x^2+y^2}, \frac{y}{x^2+y^2} \right>``]
+
+>> [@ image($graph, width=> 400) @]* <<
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
+
diff --git a/tutorial/sample-problems/VectorCalc/VectorFieldGraph3D/VectorFieldGraph3D1.pg b/tutorial/sample-problems/VectorCalc/VectorFieldGraph3D/VectorFieldGraph3D1.pg
new file mode 100644
index 0000000000..e3d1d3e6d0
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/VectorFieldGraph3D/VectorFieldGraph3D1.pg
@@ -0,0 +1,89 @@
+## DESCRIPTION
+## Vector Calculus: graph of a 3D vector field
+## ENDDESCRIPTION
+
+## KEYWORDS('vector calculus', 'vector field graph 3D')
+
+## DBsubject('WeBWorK')
+## DBchapter(WeBWorK tutorial)
+## DBsection(Fort Lewis tutorial 2011)
+## Date('01/30/2011')
+## Author('Paul Pearson')
+## Institution('Fort Lewis College')
+
+#:% name = Three-D Vector Field Graph
+#:% subject = Vector Calculus
+#:% type = Sample
+#:% categories = [graph]
+
+#:% section=preamble
+#: We need to include the macros file `LiveGraphicsVectorField3D.pl`.
+DOCUMENT();
+loadMacros(
+    'PGstandard.pl',                'PGML.pl',
+    'LiveGraphicsVectorField3D.pl', 'PGcourse.pl'
+);
+
+#:% section=setup
+#: The `VectorField3D()` routine returns a string of plot data consisting of a list of line
+#: segments (the vectors) along with other plot options. The arguments `RGBColor[a,b,c]` are
+#: numbers a, b, and c between 0 and 1 inclusive. You can uniformly scale all of the vectors
+#: in the vector field by the same amount using vectorscale. The outputtype feature controls
+#: how much of the string of plot data is generated, and setting it equal to 4 generates all
+#: of the plot information necessary to be displayed.
+#:
+#: Setting outputtype to something other than 4 will require you to read the source code of
+#: `LiveGraphicsVectorField3D.pl` and familiarize yourself with the details of the LiveGraphics3D
+#: javascript applet.
+Context()->variables->are(x => 'Real', y => 'Real', z => 'Real');
+
+$plot = VectorField3D(
+    Fx              => Formula('x'),
+    Fy              => Formula('y'),
+    Fz              => Formula('z'),
+    xvar            => 'x',
+    yvar            => 'y',
+    zvar            => 'z',
+    xmin            => -1,
+    xmax            => 1,
+    ymin            => -1,
+    ymax            => 1,
+    zmin            => -1,
+    zmax            => 1,
+    xsamples        => 4,
+    ysamples        => 4,
+    zsamples        => 4,
+    axesframed      => 1,
+    xaxislabel      => 'X',
+    yaxislabel      => 'Y',
+    zaxislabel      => 'Z',
+    vectorcolor     => "RGBColor[0.0,0.0,1.0]",
+    vectorscale     => 0.2,
+    vectorthickness => 0.01,
+    outputtype      => 4,
+);
+
+#:% section=statement
+#: This just shows the plot.
+BEGIN_PGML
+
+The following is the 3D vector field give by
+>> [`` \vec{v} = \left<x,y,z\right> ``] <<
+
+>> [@ Live3Ddata(
+	$plot,
+	image => alias("exploding-vector-field.png"),
+	size => [400,400],
+	tex_size => 600,
+	tex_center => 1,
+	scale => 1.25,
+); @]* <<
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
+
diff --git a/tutorial/sample-problems/VectorCalc/VectorFieldGraph3D/exploding-vector-field.png b/tutorial/sample-problems/VectorCalc/VectorFieldGraph3D/exploding-vector-field.png
new file mode 100755
index 0000000000..60bededf77
Binary files /dev/null and b/tutorial/sample-problems/VectorCalc/VectorFieldGraph3D/exploding-vector-field.png differ
diff --git a/tutorial/sample-problems/VectorCalc/VectorLineSegment1.pg b/tutorial/sample-problems/VectorCalc/VectorLineSegment1.pg
new file mode 100644
index 0000000000..ac8d3976d3
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/VectorLineSegment1.pg
@@ -0,0 +1,103 @@
+## DESCRIPTION
+## A Vector-value parametric line segment with a general paramterization
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('vector-valued', 'parametric', 'line segment')
+
+# created as a full problem by Peter Staab  2023.06.02
+
+#:% name = Vector-valued Parametric Line Segment--General
+#:% type = [technique, sample]
+#:% categories = vector
+#:% subject = Vector Calculus
+
+#:% section = preamble
+#: The macro
+#: `parseParametricLine.pl` provides the `ParametricLine` function which
+#: will be the answer.  The `parserMultiAnswer.pl` is needed since the
+#: answer blanks are interdependent.
+DOCUMENT();
+loadMacros(
+    'PGstandard.pl',           'PGML.pl',
+    'parserParametricLine.pl', 'parserMultiAnswer.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#:  We create a MutiAnswer answer checker that will evaluate the students
+#: vector parametric equation at the starting  and ending times provided
+#: by the student. For example, both of the student answers `(4,0) + t<-4,2>`
+#: for `t` between `0` and `1`, and `(4,0) + t<-2,1>` for t between `0` and `2`
+#: will be marked correct.
+Context("Vector");
+Context()->variables->are(t => "Real");
+
+$P = Point(4, 0);
+$Q = Point(0, 2);
+$V = Vector(-4, 2);
+
+$t    = Formula("t");
+$line = Vector("$P + $t * $V");
+
+$multians = MultiAnswer($line, Real("0"), Real("1"))->with(
+    singleResult => 0,
+    checker      => sub {
+        my ($correct, $student, $ansHash) = @_;
+        my ($linestu, $astu,    $bstu)    = @{$student};
+        my ($linecor, $acor,    $bcor)    = @{$correct};
+
+        if ((ParametricLine("$line") == $linestu)
+            && ($linestu->eval(t => $astu) == $line->eval(t => "0"))
+            && ($linestu->eval(t => $bstu) == $line->eval(t => "1")))
+        {
+            return [ 1, 1, 1 ];
+
+        } elsif ((ParametricLine("$line") == $linestu)
+            && ($linestu->eval(t => $astu) == $line->eval(t => "0")))
+        {
+            return [ 1, 1, 0 ];
+
+        } elsif ((ParametricLine("$line") == $linestu)
+            && ($linestu->eval(t => $bstu) == $line->eval(t => "1")))
+        {
+            return [ 1, 0, 1 ];
+
+        } elsif ((ParametricLine("$line") == $linestu)) {
+            return [ 1, 0, 0 ];
+
+        } else {
+            return [ 0, 0, 0 ];
+        }
+
+    }
+);
+
+#:% section = statement
+#: Since the three answer blanks depend on each other, we use `$multians`
+#: for each answer blank.
+BEGIN_PGML
+Find a vector parametric equation for the line
+segment from the point [`P = [$P]`]
+to [`Q = [$Q]`].
+
+[` \vec{r}(t) = `] [__]{$multians}
+
+for
+[__]{$multians}
+[` \leq t \leq `]
+[__]{$multians}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/VectorCalc/VectorLineSegment2.pg b/tutorial/sample-problems/VectorCalc/VectorLineSegment2.pg
new file mode 100644
index 0000000000..21e8f450b8
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/VectorLineSegment2.pg
@@ -0,0 +1,56 @@
+## DESCRIPTION
+## A Vector-value parametric line segment for a specific values of the parameter.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('vector-valued', 'parametric', 'line segment')
+
+# created as a full problem by Peter Staab  2023.06.02
+
+#:% name = Vector-valued Parametric Line Segment--Specific
+#:% type = [technique, sample]
+#:% categories = vector
+#:% subject = Vector Calculus
+
+#:% section = preamble
+#:  The macro `parseVectorUtils.pl` provides random points and vectors.
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserVectorUtils.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: In this case, there is only a single answer, so we can just enter the
+#: correct expression for the vector-valued function.
+Context("Vector");
+Context()->variables->are(t => "Real");
+
+$P     = non_zero_point3D();
+$disp  = non_zero_vector3D();
+$Q     = Point($P + $disp);
+$speed = random(3, 9, 1);
+
+$ans = Compute("$P + $speed *t * $disp/norm($disp)");
+
+#:% section = statement
+BEGIN_PGML
+A particle starts at the point [` P = [$P] `]
+when [` t = 0 `] and moves along a straight line
+toward [` Q = [$Q] `] at a speed of [` [$speed] `]
+cm/sec.  Assume that [`x, y,`] and [`z`] are measured
+in cm.  Do not enter units with your answers.
+
+Find the vector parametric equation for the position of the object.
+[` \vec{r}(t) = `] [____]{$ans}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/VectorCalc/VectorOperations.pg b/tutorial/sample-problems/VectorCalc/VectorOperations.pg
new file mode 100644
index 0000000000..ce8c1f403f
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/VectorOperations.pg
@@ -0,0 +1,77 @@
+## DESCRIPTION
+## Vector Calculus: Basic vector operations
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('vector calculus', 'vector operations')
+
+#:% name = Vector Operations
+#:% subject = Vector Calculus
+#:% type = Sample
+
+#:% section=preamble
+#: We load `parserVectorUtils.pl` to have access to functions on vectors like norm and unit.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserVectorUtils.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: We use `non_zero_vector3D(low,high,increment)` to randomly generate some vectors. Calling `$U->value`
+#: returns a (Perl) array of numbers. (Note that `->value` does not work on a vector whose
+#: components are non-constant formulas.) MathObjects defines the operators `.` and `x` to be the
+#: dot product and cross product when they occur between two vectors (that is, these operations
+#: are overloaded). The functions norm and unit calculate the length of a vector and a unit
+#: vector in the same direction. We undefine the dot and cross product as well as the functions
+#: norm and unit so that students cannot enter them in their answers.
+Context('Vector');
+
+$U = non_zero_vector3D(-9, 9, 1);
+$V = non_zero_vector3D(-9, 9, 1);
+
+# value works only for vectors of constants
+@Uarray = $U->value;
+$Ucomp2 = $Uarray[1];
+
+$UdotV   = $U . $V;
+$UcrossV = $U x $V;
+$Vlength = norm($V);
+$Vunit   = unit($V);
+
+# Prevent students from entering the dot and cross products,
+# and the vector functions norm and unit.
+
+Context()->operators->undefine('.', "><");
+Context()->functions->disable('Vector');
+
+BEGIN_PGML
+Suppose [` \vec{u} = [$U] `] and [` \vec{v} = [$V] `].
+
+a. The second component of [` \vec{u} `] is [___________]{$Ucomp2}
+
+b. [` \vec{u} \cdot \vec{v} = `] [___________]{$UdotV}
+
+c. [` \vec{u} \times \vec{v} = `] [________________]{$UcrossV}
+
+d. [` \left\| \vec{v} \right\| = `] [___________]{$Vlength}
+
+e. Enter a unit vector in the direction of [` \vec{v} `]. [______________]{$Vunit}
+
+f. Enter a vector parallel to [` \vec{v} `]. [________________]{$V->cmp( parallel=>1 )}
+
+g. Enter a vector in the same direction as [` \vec{v} `].
+[__________]{$V->cmp( parallel=>1, sameDirection=>1 )}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
+
diff --git a/tutorial/sample-problems/VectorCalc/VectorParametricLine.pg b/tutorial/sample-problems/VectorCalc/VectorParametricLine.pg
new file mode 100644
index 0000000000..0a326d124f
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/VectorParametricLine.pg
@@ -0,0 +1,58 @@
+## DESCRIPTION
+## A Vector-value parametric line
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('interval')
+
+# created as a full problem by Peter Staab  2023.06.02
+
+#:% name = Vector-valued Parametric Line
+#:% type = [technique, sample]
+#:% categories = vector
+#:% subject = Vector Calculus
+
+#:% section = preamble
+#: The macro `parseVectorUtils.pl` provides random points. The macro
+#: `parseParametricLine.pl` provides the `ParametricLine` function which
+#: will be the answer.
+DOCUMENT();
+loadMacros(
+    'PGstandard.pl',        'PGML.pl',
+    'parserVectorUtils.pl', 'parserParametricLine.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#:  We randomize two points in three-dimensional space, `P` and `Q`, a
+#: displacement vector between them, and a speed to travel between them.
+Context('Vector');
+Context()->variables->are(t => 'Real');
+
+$P    = non_zero_point3D();
+$disp = non_zero_vector3D();
+$Q    = Point($P + $disp);
+$line = ParametricLine("$P+t *$disp");
+
+#:% section = statement
+BEGIN_PGML
+Find a vector parametric equation for the
+line through points [` P = [$P] `] and [` Q = [$Q] `].
+
+[` \vec{r}(t) = `] [___]{$line}
+
+A vector should be entered like  <x(t),y(t),z(t)>.
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/VectorCalc/Vectors.pg b/tutorial/sample-problems/VectorCalc/Vectors.pg
new file mode 100644
index 0000000000..9640916fb2
--- /dev/null
+++ b/tutorial/sample-problems/VectorCalc/Vectors.pg
@@ -0,0 +1,123 @@
+## DESCRIPTION
+## This shows how to use vectors in a problem.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('interval')
+
+# created as a full problem by Peter Staab  2023.06.02
+
+#:% name = Vectors
+#:% type = [technique, sample]
+#:% categories = vector
+#:% subject = Vector Calculus
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: We indicate that we are working in a vector context by setting
+#: `Context('Vector')`. If we want to have vectors displayed, by default, as a
+#: sum of `i,j,k` components, we can set the `ijk` flag in the `Context`. This is
+#: commented out here; uncommenting it would result in the vector `$v1` here
+#: being shown as `$v1 = i + 3j` instead of `$v1 = <1,3>`, etc. Similarly,
+#: if we wanted to change the default display of the `i, j` and `k` vectors,
+#: say to have them display with overset arrows, we can redefine the TeX
+#: formatting of those constants, as shown in the second comment.
+#:
+#: Then, we can define vectors as we might expect: either with the `Vector` or
+#: `Compute` constructors, or by using the predefined vector constants
+#: `i, j` and `k`.  Any vector constructed with `i, j` and/or `k` will be
+#: three-dimensional vectors even if the vector `k` is not used.  That is
+#: `Vector('<1,2>')` is not equal to `i+2j`.
+#:
+#: Also if we define the vector using the constants i, j and k, as in the
+#: definition of `$v3 `here, then the default display of that vector will be in
+#: `i,j,k `format even if we don't set the corresponding Context flag.
+#:
+#: To explicitly require that the vectors be two-dimensional rather than
+#: three-dimensional, we would use `Context('Vector2D')` instead of
+#: `Context('Vector')`.
+#:
+#: The components of MathObjects vectors are available as an array from
+#: `$v->value;` thus, we could save the three components of the vector `$v3`
+#: in the array `@v3comp` using `@v3comp = $v3->value`.
+#: Then, we can access the first component using
+#: `$v3comp[0]`, the second component using `$v3comp[1]`, etc.
+#: Better still, to get the first component of the vector `$v3` we could
+#: use `$v3->extract(1)` instead of `($v3->value)[0]`. Note that the
+#: index of `extract` starts at 1, not 0.
+#:
+#: Lastly, there is other functionality associated with Vectors.  See the
+#: WeBWorK wiki page on
+#: [vectors](https://webwork.maa.org/wiki/Vector_(MathObject_Class))
+Context('Vector');
+## display vectors in ijk format
+# Context()->flags->set( ijk=>1 );
+## set the appearance of the ijk vectors
+##    this sets them to be overset with
+##    vector arrows, instead of boldface
+# Context()->constants->set(
+#   i => {TeX => "\mathit{\vec i}"},
+#   j => {TeX => "\mathit{\vec j}"},
+#   k => {TeX => "\mathit{\vec k}"},
+# );
+
+$v1 = Vector("<1,3>");
+$v2 = Compute("<-3,1>");
+$v3 = 3 * i + 2 * j - 4 * k;
+$v4 = Vector(1, 1, 0);
+
+# create an array of the components of $v3
+@v3comp = $v3->value;
+
+$a = 3 * i + j;
+# $b = $a + $v1; # this results in an error
+$c  = norm($v3);         # vector length
+$v5 = unit($v3);         # unit vector in same direction
+$d  = $v1 . $v2;         # dot product
+$v6 = $v3 x $v4;         # cross product
+$v3->isParallel($v4);    # returns 1 if parallel, 0 if skew
+
+BEGIN_PGML
+[`\vec{v}_1=[$v1]`]
+
+[`\vec{v}_2=[$v2]`]
+
+[`\vec{v}_3=[$v3]`]
+
+[`\vec{v}_4=[$v4]`]
+
+[`\vec{a} = [$a]`]
+
+[`\vec{v}_1+\vec{v}_2 = [$v1+$v2]`]
+
+[`||\vec{v}_3|| = [$c]`]
+
+[`[$v5]`] is a unit vector in the same direction as [`[$v3]`]
+
+[`\vec{v}_1 \cdot \vec{v}_2=[$d]`]
+
+[`\vec{v}_3 \times \vec{v}_4=[$v6]`]
+
+[`\vec{v}_3`] [@ $v3->isParallel($v4) ? 'is' : 'is not' @]
+parallel to [`\vec{v}_4`]
+
+The first element of [`\vec{v}_3`] is [@ $v3->extract(1) @]
+
+The third element of [`\vec{v}_4`] is [@ $v4->extract(3) @]
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/AdaptiveParameters.pg b/tutorial/sample-problems/problem-techniques/AdaptiveParameters.pg
new file mode 100644
index 0000000000..44dd744273
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/AdaptiveParameters.pg
@@ -0,0 +1,84 @@
+## DESCRIPTION
+## Utilizing adaptive parameters in checkers.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Date(05/25/2023)
+## Institution(Missouri Western State University)
+## Author(Glenn Rice)
+## KEYWORDS('differential equations', 'adaptive parameters')
+
+#:% name = Adaptive Parameters
+#:% type = technique
+#:% categories = [adaptive parameters]
+
+#:% categories = [differential equations, adaptive parameters]
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: This problem will utilize with adaptive parameters in the custom answer
+#: checker. Define `$aSoln` to be the result of calling `cmp` on a MathObject
+#: function with the `checker` option set.
+#:
+#: The general solution to the differential equation in this problem is
+#: $y = c e^x - 1$. The student will be asked to enter a specific solution like
+#: $y = e^2 e^x - 1$. Adaptive parameters will be used to check that the
+#: student's answer has the correct form.
+#:
+#: The custom answer checker creates a copy of the `Context` in which an
+#: adaptive parameter is allowed. It then re-computes the student and correct
+#: answers in that context. Then it checks that the answers match with the
+#: adaptive parameter.
+#:
+#: If it is desired to allow a solution to differ by an additive constant from
+#: the answer in the problem, this can be accomplished using existing
+#: MathObjects methods, as discussed on the
+#: [formulas up to constants](../problem-techniques/FormulasToConstants.html)
+#: page.
+#:
+#: If the answers may be a pure multiple of the correct answer without an
+#: additive constant, then `0` should not be considered correct. For example,
+#: if the general solution were `ce^x`. So the commented out line
+#: `return 0 if $student == Formula(0);` would needed in that case.
+#:
+#: Observe that this checker bypasses the adaptive parameter code for the
+#: 'produce_equivalence_message' filter. This filter compares the current
+#: student answer to the previous student answer and gives the message
+#: "This answer is equivalent to the one you just submitted." in the case that
+#: the two are deemed to be equal. That message could be confusing to students
+#: for two answers with different constants in this type of problem.
+$aSoln = Compute('e^x - 1')->cmp(
+    checker => sub {
+        my ($correct, $student, $ans) = @_;
+        # return 0 if $student == Formula(0); # See comments.
+        if ($self->{_filter_name} ne 'produce_equivalence_message') {
+            my $context = Context()->copy;
+            $context->flags->set(no_parameters => 0);
+            $context->variables->add(C0 => 'Parameter');
+            $student = Formula($context, $student);
+            $correct = Formula($context, 'C0 * e^x - 1');
+        }
+        return $correct == $student;
+    }
+);
+
+#:% section = statement
+BEGIN_PGML
+Find one solution to the differential equation.
+
+    [`\frac{dy}{dx} = y + 1`]
+
+[`y =`] [_]{$aSoln}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/AddingFunctions.pg b/tutorial/sample-problems/problem-techniques/AddingFunctions.pg
new file mode 100644
index 0000000000..68a9faae46
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/AddingFunctions.pg
@@ -0,0 +1,50 @@
+## DESCRIPTION
+## Shows how to add a general function as an input option.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('tolerance')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Adding Functions to a Context
+#:% type = technique
+#:% categories = [numbers, tolerance]
+
+#:% section = preamble
+#: We need to load the `parserFunction.pl` macro, and then use one of its
+#: routines to define a new function that students may type in their answers.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserFunction.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: First, we define a function `f(x,y)`.  The actual function doesn't matter but shouldn't
+#: be easily guessed, since a student could put in `sin(x*y)-exp(y)` and get the answer correct.
+#:
+#: This is a useful technique for any problem that the question is about a generic function
+#: rather than a specific one.
+Context()->variables->are(x => 'Real', y => 'Real');
+parserFunction('f(x,y)' => 'sin(x*y)-exp(y)');
+$ans = Compute('f(x-4,3)');
+
+#:% section = statement
+BEGIN_PGML
+Given a surface [`z = f(x,y)`], what is the equation for the [`z`] -coordinate
+of the surface along a line having [`y=3`], shifted four units to the right?
+
+[`z = `] [_____]{$ans}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/AnswerHints.pg b/tutorial/sample-problems/problem-techniques/AnswerHints.pg
new file mode 100644
index 0000000000..67a3a9a749
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/AnswerHints.pg
@@ -0,0 +1,90 @@
+## DESCRIPTION
+## Shows how to provide answer hints to students.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer', 'hints')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Answer Hints
+#:% type=technique
+#:% categories=[answer, knowls]
+#:% section=preamble
+#: Make sure the `answerHints.pl` macro is loaded.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'answerHints.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: To generate specific, customized answer hints for particular answers, we use
+#: the `AnswerHints` postfilter provided by `answerHints.pl`. The answer hints
+#: should be provided by a particular answer, followed by the hash table
+#: association operator `=>`, followed by a string that will show up in the
+#: messages portion of the answer preview and feedback box when students submit
+#: their answers. You may include as many answer and hint pairs as you like, and
+#: even use subroutines in them (see answerHints.pl for more on this).
+#:
+#: If the same error message should be given for several different answers, you
+#: should make a square bracketed list of those answers. For example, if the
+#: variables x, t, and u were all in the context, we could use
+#:
+#:```{#answer-hint-multiple .perl}
+#: $ans->cmp->withPostFilter(AnswerHints(
+#:     [ Compute('6 t'), Compute('6 x') ] =>
+#:         'Are you using the correct variable?'
+#: ))
+#:```
+#:
+#: If the MathObjects answer evaluator normally generates a message, the default
+#: is not to change a message that is already in place. To override a message
+#: generated by a MathObjects answer evaluator, you should set
+#: `replaceMessage => 1` as below.
+#:
+#:```{#answer-hint-single .perl}
+#: $ans->cmp->withPostFilter(AnswerHints(
+#:     Compute('6 u') => [ 'Good work!', replaceMessage => 1 ]
+#: ))
+#:```
+Context()->variables->are(t => 'Real', u => 'Real');
+
+$f   = Formula('2 t');
+$ans = Formula('6 u')->cmp->withPostFilter(AnswerHints(
+    Formula('6 t') => 'Are you using the correct variable?',
+    Formula('6 u') => 'Good work!'
+));
+
+#:% section = statement
+#: Knowls (little bits of knowledge) provide an always present link to a hint
+#: that expand to reveal the hint when clicked on, and collapse to hide the hint
+#: when clicked on again.
+BEGIN_PGML
+If [`f(t) = [$f]`], then [`f(3u)`] = [____]{$ans}
+
+[@ knowlLink(
+    'Click for a hint',
+	value => 'Substitute \(3u\) wherever you see \(t\) in the formula for \(f\).'
+) @]*
+END_PGML
+
+#:% section = hint
+#: This is a hint that is revealed to students only after a certain number of
+#: submissions. The number of submissions before the hint is shown is specified
+#: by the instructor in webwork settings.
+#:
+#: These hints are added to the problem in the block of text
+#: between the commands `BEGIN_PGML_HINT` and `END_PGML_HINT`, which must be on
+#: their own lines and at the start of a line. The hint will automatically
+#: generate the word HINT: before the block of text that is the hint, so you
+#: should not add it manually.
+BEGIN_PGML_HINT
+Substitute [`3u`] wherever you see [`t`] in the formula for [`f(t) = [$f]`].
+END_PGML_HINT
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/AnswerInExponent.pg b/tutorial/sample-problems/problem-techniques/AnswerInExponent.pg
new file mode 100644
index 0000000000..4666033458
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/AnswerInExponent.pg
@@ -0,0 +1,59 @@
+## DESCRIPTION
+## Provides an answer blank in an exponent.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer', 'exponent')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Answer in an Exponent
+#:% type = technique
+#:% categories = [answer, exponent]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The `Context()->variables->are` sets the variables for the context.
+Context()->variables->are(a => 'Real', b => 'Real');
+
+$n = random(3, 9);
+
+$ans_rule1 = ans_rule(4);
+$ans_rule2 = ans_rule(4);
+
+#:% section = statement
+#: To create an exponential, there is different code for both the TeX (hardcopy)
+#: and HTML version.  The `TeX` is as expected using the standard power `^`.
+#: The HTML version creates a exponent using the `vertical-align` attribute.
+BEGIN_PGML
+Rewrite the following using a single exponent.
+
+[@ MODES(
+	TeX => "\\( \\displaystyle a^{$n}b^{$n} = ( $ans_rule1)^{$ans_rule2} \\)",
+	HTML =>"<div><span>\\( \\displaystyle a^{$n}b^{$n} = (\\)$ans_rule1\\()\\)</span>" .
+		"<span style='vertical-align: 1.4em'> $ans_rule2 </span></div>"
+)@]*
+
+END_PGML
+
+#:% section = answer
+#: Because `ans_rule` is used above, this form of answer checking must be used.
+ANS(Compute('a b')->cmp);
+ANS(Real($n)->cmp);
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/AnswerIsSolutionToEquation.pg b/tutorial/sample-problems/problem-techniques/AnswerIsSolutionToEquation.pg
new file mode 100644
index 0000000000..7ebb21f9b3
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/AnswerIsSolutionToEquation.pg
@@ -0,0 +1,46 @@
+## DESCRIPTION
+## The answer is a solution to an equation.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer', 'exponent')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Answer is a Solution to an Equation
+#:% type = technique
+#:% categories = [answer, exponent]
+
+#:% section = preamble
+#: We need to include the macros file `parserSolutionFor.pl`
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserSolutionFor.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The function `SolutionFor('equation',point,options)` takes an equation, a point that
+#: satisfies that equation, and options such as `vars=>['y','x']` in case you want to change
+#: the order in which the variables appear in order pairs (the default is lexicographic ordering of the variables).
+Context('Vector')->variables->are(x => 'Real', y => 'Real');
+
+$f = SolutionFor("x^2 = cos(y)", "(1,0)");
+#$f = SolutionFor("x^2 - y = 0", [ 2, 4 ]);
+#$f = SolutionFor("x^2 - y = 0", Point(4, 2), vars => [ 'y', 'x' ]);
+
+#:% section = statement
+BEGIN_PGML
+A solution to [`[@ $f->{f} @]`] is [`(x,y) =`] [___]{$f}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/AnyAnswerMarkedCorrect.pg b/tutorial/sample-problems/problem-techniques/AnyAnswerMarkedCorrect.pg
new file mode 100644
index 0000000000..64cf0e833f
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/AnyAnswerMarkedCorrect.pg
@@ -0,0 +1,43 @@
+## DESCRIPTION
+## Shows how to implement any answer marked correct.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Any Answer is Marked Correct
+#:% type = technique
+#:% categories = [answer]
+
+#:% section = preamble
+#: We need to include the macros file unionTables.pl
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: We wrap the random command with a `Compute` to make `$a` a MathObject.
+#:
+#: The checker then returns 1 which will make any answer correct.
+$a = Compute(random(2, 9, 1));
+
+$ans = $a->cmp(checker => sub { return 1; });
+
+#:% section = statement
+BEGIN_PGML
+Enter anything, e. g. [`[$a] `] and it will be marked correct: [__]{$ans}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/CalculatingWithPoints.pg b/tutorial/sample-problems/problem-techniques/CalculatingWithPoints.pg
new file mode 100644
index 0000000000..8d64940136
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/CalculatingWithPoints.pg
@@ -0,0 +1,72 @@
+## DESCRIPTION
+## Perform calculations with Points.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('point')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Calculating with Points
+#:% type = technique
+#:% categories = [point]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: In the problem setup section of the file, we put the value of the subtraction
+#: of two Points in two variables, `$d1`, the x coordinate, and `$d2`, the y
+#: coordinate. This is achieved by calling `Point`'s value method, as shown.
+#:
+#: Alternative method: If you want to get only one of the coordinates of a
+#: Point, you can use the extract method, for example: `$x = $point->extract(1);`.
+#: This gets the first coordinate of `$point` and assigns it to the variable `$x`.
+#:
+#: We don't use `Context("Vector");` and `norm( $point[0] - $point[1] )` here
+#: to determine length because we don't want to accept an answer like `|<5,7>-<7,8>|`.
+#:
+#: Alternative method: You can use `$length=norm( $point[0] - $point[1] );`
+#: with `Context("Vector");` if you want to accept answers that are valid in
+#: the `Vector` context (such as the absolute value of a vector).
+#:
+#: We need to put parentheses around `$d1` and `$d2` in the Compute expression
+#: because if `$d1 = -6`, then `-6^2 = -36`, not `36`, as desired. However, if the
+#: code is `($d1)^2` then that evaluates as `(-6)^2 = 36`, as desired.
+Context("Point");
+@points = (
+    Point(random(1, 5,  1), random(-5, -1, 1)),
+    Point(random(5, 10, 1), random(6,  11, 1))
+);
+
+# If $point[0] = (x1,y1) and $point[1] = (x2,y2),
+# then the following makes $d1 = x1 - x2, $d2 = y1 - y2
+($d1, $d2) = ($points[0] - $points[1])->value;
+
+$length = Compute("sqrt( ($d1)^2+($d2)^2 )");
+$mid    = ($points[1] + $points[0]) / 2;
+
+#:% section=statement
+BEGIN_PGML
+Consider the two points [` [$points[0]] `]
+and [` [$points[1]] `].
+
+a. The distance between them is: [_______]{$length}
+
+b. The midpoint of the line segment that joins them is:
+[______]{$mid}
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/ComposingFunctions.pg b/tutorial/sample-problems/problem-techniques/ComposingFunctions.pg
new file mode 100644
index 0000000000..9cf0235ddd
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/ComposingFunctions.pg
@@ -0,0 +1,53 @@
+## DESCRIPTION
+## Shows how to check that the answer is the composition of two functions.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('composition')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Composing Functions
+#:% type = technique
+#:% categories = [composition]
+
+#:% section = preamble
+#: We need to include the macros file `answerComposition.pl`
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'answerComposition.pl', 'PGcourse.pl');
+
+#:% section = setup
+Context()->variables->are(x => 'Real', y => 'Real', u => 'Real');
+
+$a = random(2, 9);
+
+$f = Formula("sqrt(u)");
+$g = Formula("x^2+$a");
+
+#:% section = statement
+BEGIN_PGML
+Express the function [`y = \sqrt{x^2 + [$a]}`] as a composition [`y = f(g(x))`]
+of two simpler functions [`y = f(u)`] and [`u = g(x)`].
+
+	[`f(u) =`] [___]
+
+	[`g(x) =`] [___]
+END_PGML
+
+#:% section = answer
+#: This must be called with the method `COMPOSITION_ANS` with the arguments that
+#: will test for `f(g(x))`
+COMPOSITION_ANS($f, $g);
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/ConstantsInProblems.pg b/tutorial/sample-problems/problem-techniques/ConstantsInProblems.pg
new file mode 100644
index 0000000000..061eb91b8e
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/ConstantsInProblems.pg
@@ -0,0 +1,57 @@
+## DESCRIPTION
+## Provides constants in a PG problem.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('constants')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Constants in Problems
+#:% type = technique
+#:% categories = [constant]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: No changes are needed in the tagging and description or initialization sections of the problem
+#: file. In the problem set-up section, we add to the Context the constants we're going to use.
+#: Here we define a constant `k`, and assign it a value that will be used when expressions involving
+#: k are evaluated. Do not set `k=1`, because if you do, then `kx `and `x/k` are equivalent, for example.
+#: Obviously, do not set `k=0.`
+#:
+#: In this case we specified `constants->add()`, so that the constant k is added to existing
+#: constants in the problem. If we had used `constants->are()`, we would also remove all predefined
+#: constants from the Context (in a manner similar to the use of `variables->add()` and
+#: `variables->are()` when defining variables in a problem.
+#:
+#: One other tweak that we might want to put in here is to reset a Context flag so that students'
+#: answers are not reduced to numerical values when they are previewed or submitted. This is done
+#: by setting the formatStudentAnswer flag, as shown.
+Context()->constants->add(k => 0.01);
+
+# This means that student answers are not reduced to the numerical value
+# specified in the Context
+Context()->flags->set(formatStudentAnswer => 'parsed');
+
+$ans = Compute('k');
+
+#:% section = statement
+BEGIN_PGML
+[`f(x) = x - k`] (where [`k > 0`] is constant) is zero when [`x =`] [___]{$ans}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/CustomAnswerCheckers.pg b/tutorial/sample-problems/problem-techniques/CustomAnswerCheckers.pg
new file mode 100644
index 0000000000..1630b8e588
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/CustomAnswerCheckers.pg
@@ -0,0 +1,76 @@
+## DESCRIPTION
+## This provides a custom answer checker.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer', 'custom')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Custom Answer Checker
+#:% type = technique
+#:% categories = [answer, custom]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: To set up the custom answer checker we will override the answer checker routine for the `MathObject`
+#: that we're using to check the answer. Thus our answer object should be of the same type (e.g., `Real`,
+#: `Formula`, etc.) as what we want the student to be entering. For example, here we're going to ask for a
+#: value of x such that `cos(x) = cos($ans)`. Thus we set up the answer to be a real number.
+#:
+#: The `$ans` object overrides the `checker` part of the MathObject.  This is a subroutine
+#: which checks that the cosine of the student answer equals the cosine of the correct
+#: answer.  This also values like `pi/3`, `-pi/3` or `pi/3 + 2pi` to be considered correct.
+#:
+#: We can set an error message in the answer checker by using Value->Error("message"). This will
+#: set the message that is displayed to the student and exit the checker with an incorrect
+#: return value. For example:
+#:
+#:```{#value-error .perl}
+#: $ans = Compute('pi/3')->cmp(
+#:     checker => sub {
+#:         my ($correct, $student, $ansHash) = @_;
+#:         Value->Error("Try again") if cos($student) == sqrt(3) / 2;
+#:         return cos($correct) == cos($student);
+#:     }
+#: );
+#:```
+#:
+#: Another handle tip for troubleshooting. To see all of the keys and values in the
+#: `$ansHash` when the submit answers button is pressed, include this in your custom answer checker:
+#:
+#:```{.perl}
+#:for my $key ( keys %{$ansHash} ) {
+#:  warn "key: $key, value: $ansHash->{$key}";
+#:}
+#:```
+$ans = Compute('pi/3')->cmp(
+    checker => sub {
+        my ($correct, $student, $ansHash) = @_;
+        return cos($correct) == cos($student);
+    }
+);
+$val = Compute('cos(pi/3)');
+
+#:% section = statement
+BEGIN_PGML
+Enter a value of [`x`] for which [`\cos(x) = [$val]`]
+
+[`x=`] [___]{$ans}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/CustomAnswerListChecker.pg b/tutorial/sample-problems/problem-techniques/CustomAnswerListChecker.pg
new file mode 100644
index 0000000000..44b3b07f76
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/CustomAnswerListChecker.pg
@@ -0,0 +1,106 @@
+## DESCRIPTION
+## This shows how to check an arbitrary list of student answers.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(Fitchburg State University)
+## Author(Peter)
+## MO(1)
+## KEYWORDS('answer', 'custom', 'list')
+
+# Adapted from https://webwork.maa.org/wiki/Custom_Answer_Checkers_for_Lists
+
+#:% name = Custom Answer List Checker
+#:% type = technique
+#:% categories = [answer, custom, list]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: We expect the student answers to be points so we'll use the 'Point' context.
+#: Provide a list of 3 points that will be shown as the correct answer.
+#:
+#: The important part of this problem is that we customize the `cmp` function of
+#: the answer and since this is a list, we use a `list_checker` as shown.
+#:
+#: Most of the custom list checker is spent giving errors to specific situations
+#: in the student answers.  The part of the checker toward the bottom which
+#: checks if the two coordinates and if they add to `$c`, then increase the
+#: the `$score`.
+#:
+#: And lastly the checker ensures that the right number of points (3) is
+#: entered.
+Context('Point');
+
+$c   = random(4, 8);
+$ans = List("(0,$c),($c,0),($c-1,1)")->cmp(
+    list_checker => sub {
+        my ($correct, $student, $ansHash, $value) = @_;
+        my $n     = scalar(@$student);    # number of student answers
+        my $score = 0;                    # number of correct student answers
+        my @errors;                       # stores error messages
+
+        #  Loop though the student answers
+        for my $i (0 .. $n - 1) {
+            my $ith = Value::List->NameForNumber($i + 1);
+            my $p   = $student->[$i];                      # i-th student answer
+
+            #  Check that the student's answer is a point
+            if ($p->type ne "Point") {
+                push(@errors, "Your $ith entry is not a point");
+                next;
+            }
+
+            #  Check that the point hasn't been given before
+            for (my $j = 0, $used = 0; $j < $i; $j++) {
+                if ($student->[$j]->type eq "Point" && $student->[$j] == $p)
+                {
+                    push(@errors,
+                        "Your $ith point is the same as a previous one")
+                        unless $ansHash->{isPreview};
+                    $used = 1;
+                    last;
+                }
+            }
+
+            # If not already used, check that it satisfies the equation
+            # and increase the score if so.
+            if (!$used) {
+                my ($a, $b) = $p->value;
+                if ($a + $b == $c) {
+                    $score++;
+                } else {
+                    push(@errors, "Your $ith point is not correct")
+                        unless $ansHash->{isPreview};
+                }
+            }
+        }
+
+        #  Check that there are the right number of answers
+        if (!$ansHash->{isPreview}) {
+            push(@errors, "You need to provide more points") if $n < 3;
+            push(@errors, "You have given too many points")  if $n > 3;
+        }
+        return ($score, @errors);
+    }
+);
+
+#:% section = statement
+BEGIN_PGML
+Enter three distinct points [`(x,y)`] that satisfy the equation [`x+y=[$c]`]:
+
+[____]{$ans}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Any three points who's coordinates sum to [`[$c]`] are valid.  For example
+[`([$c],0),(0,[$c]),(1,[@ $c-1 @])`]
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/DataTables.pg b/tutorial/sample-problems/problem-techniques/DataTables.pg
new file mode 100644
index 0000000000..f3b78865d4
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/DataTables.pg
@@ -0,0 +1,91 @@
+## DESCRIPTION
+## This shows how to present and format a table for data.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('tutorial', 'table')
+
+#:% name = Data Table
+#:% type = [technique]
+#:% categories = table
+
+#:% section = preamble
+#: This shows how to use the `DataTable` function in `niceTables.pl`.
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'niceTables.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: We use the `DataTable` function from `niceTables.pl` to demonstrate some
+#: of it's features.  A `DataTable` is meant to display data in a
+#: tabular format.
+#:
+#: The basic form of a `DataTable` is
+#:```{#datatable .perl}
+#:$table = DataTable([
+#:   [row1],
+#:   [row2],
+#:   ...
+#:   [rowN]
+#: ],
+#: options);
+#:```
+# where the data goes in as an array ref of array refs.  The first row can
+#: (and is often) used for a header row. We will show some of the options
+#: here, but the full listing and explantion is in
+#: PODLINK('the niceTables.pl POD','niceTables.pl')
+#:
+#: The first use is meant to show some tabular data and the data is filled
+#: in randomly and stored in the `@rows` array.  Also, note that since
+#: a `DataTable` needs an array ref and typically in perl `\@rows` would be
+#: the arrayref, however, in a PG problem, to get a `\`, we use `~~`
+#:
+#: The second table uses `ans_rule` for answer blanks.  This example has
+#: rows hardcoded instead of in a loop.
+@rows = ([ '\(x\)', '\(y\)' ]);
+for $i (1 .. 5) {
+    push(@rows, [ $i, random(1, 10) ]);
+}
+
+$tab1 = DataTable(~~@rows);
+
+$a = non_zero_random(-4, 4);
+$f = Compute("x/(x-[$a])")->reduce;
+
+$tab2 = DataTable(
+    [
+        [ '\(x\)', '\(f(x)\)' ],
+        [ $a - 2,    ans_rule(10) ],
+        [ $a - 1,    ans_rule(10) ],
+        [ $a + 1,    ans_rule(10) ],
+        [ $a + 2,    ans_rule(10) ]
+    ],
+    align           => '|r|l|',
+    horizontalrules => 1
+);
+
+BEGIN_PGML
+Here's some data:
+
+[$tab1]*
+
+Fill out the following table for [``f(x)=[$f]``].
+
+[$tab2]*
+END_PGML
+
+for $i (-2, -1, 1, 2) {
+    ANS($f->eval(x => $a + $i)->cmp);
+}
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/DifferentiatingFormulas.pg b/tutorial/sample-problems/problem-techniques/DifferentiatingFormulas.pg
new file mode 100644
index 0000000000..dfa79873f9
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/DifferentiatingFormulas.pg
@@ -0,0 +1,58 @@
+## DESCRIPTION
+## This shows how to check "arbitrary" conditions on the student's answer.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('differentiate')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Differentiating Formulas
+#:% type = technique
+#:% categories = [derivative]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: The `Numeric` context automatically defines `x` to be a variable, so we add the variable `y`
+#: to the context. Then, we use the partial differentiation operator `D('var_name') `
+#: to take a partial derivative with respect to that variable. We can use the evaluate
+#: feature as expected.
+Context()->variables->add(y => "Real");
+
+$a = random(2, 4, 1);
+$f = Formula("x*y^2");
+
+$fx  = $f->D('x');
+$fxa = $fx->substitute(x => "$a");
+$fy  = $f->D('y');
+$fyx = $fy->D('x')->reduce;
+
+#:% section=statement
+BEGIN_PGML
+Suppose   [`   f(x) = [$f]   `].  Then
+
+a. [``  \frac{\partial f}{\partial x}   ``] = [____]{$fx}
+
+b. [`f_x ([$a],y)=   `] [____]{$fxa}
+
+c. [` f_y(x,y)=`] [____]{$fy}
+
+d. [`f_{yx} (x,y)= `] [___]{$fyx}
+
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/DigitsTolType.pg b/tutorial/sample-problems/problem-techniques/DigitsTolType.pg
new file mode 100644
index 0000000000..abd1654d36
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/DigitsTolType.pg
@@ -0,0 +1,88 @@
+## DESCRIPTION
+## This describes an alternative way for determining the tolerance type based on the number of digits.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer', 'tolerance')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Number of Digits and Tolerance in Answers
+#:% type = technique
+#:% categories = [answer, tolerance]
+#:% see_also = [NumericalTolerance.pg]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: * The `tolType => 'digits'` switches from the default `'relative' `tolerance
+#: type to the `'digits'` tolerance type.
+#: * The `tolerance => 3` sets the number of digits to check to 3. The default
+#: value is acutally the default for other tolerance types, `0.001`, but any
+#: tolerance that is between 0 and 1 is converted via `log10` and rounding to an
+#: integer (in this case, to 3).
+#: * The `tolTruncation` parameter is either 1 (true) or 0 (false). Its default
+#: is 1. Details are explained below.
+#: * The `tolExtraDigits` parameter sets the number of extra digits to examine
+#: beyond the first tolerance digits. Its default value is 1.
+#: This is explained below.
+#: * The goal is that the student must enter at least the first tolerance
+#: digits correctly. The last digits that they enter might be rounded
+#: (always accepted) or truncated (only accepted if `tolTruncation` is true).
+#: For example, if the correct answer is e=2.7182818... and tolerance is 3,
+#: the student can answer with 2.72. Or they can answer with 2.71 if
+#: `tolTruncation` is true. But for example 2.7 and 2.73 are not accepted.
+#:
+#: If the student enters additional digits, the first additional `tolExtraDigits`
+#: digits are examined in the same manner. For example, if the correct answer
+#: is `pi=3.1415926...` and default flag values are used, the student can answer
+#: with 3.14, 3.141, 3.142, 3.1415, and even 3.1418 since that 8 is beyond the
+#: extra digits checking. But for example 3.143 is not accepted, since the first
+#: extra digit is not right. (And if `tolTruncation` is false, 3.141 would not be
+#: accepted either.)
+#:
+#: Warning: this tolerance type also applies to formula comparisons.
+#: For example if the answer is `2^x` and a student enters `e^(0.69x)`, this
+#: will probably not be accepted. Random test values will be used for x to
+#: make that comparison. For example if one of the test values is `x=2`, the
+#: correct output is 4 and the student's output would be 3.9749... and this
+#: would be declared as not a match, since the first three digits to not agree.
+#:
+#: Warning: this article is about using this tolerance type for comparison of
+#: correct answers to student answers. But if this tolerance type is activated
+#: for a context, it also applies to comparisons you might make in problem
+#: setup code. It may be important to understand that it is not symmetric.
+#: For example, under default conditions, `Real(4) == Real(3.995)` is false,
+#: while `Real(3.995) == Real(4)` is true. The left operand is viewed as the
+#: "correct" value. With `Real(4) == Real(3.995)`, that "5" violates the
+#: `tolExtraDigits` checking. But with `Real(3.995) == Real(4)`, it is as if the
+#: student entered 4.00 and has the first 3 digits correct accounting for
+#: rounding. (Note that the default tolerance type relative is similarly
+#: asymmetric, but the effect is more subtle. You can see it with
+#: `Real(4) == Real(3.996001)` versus `Real(3.996001) == Real(4)`.)
+Context()->flags->set(tolType => 'digits', tolerance => 3, tolTruncation => 1);
+$ans = Real("pi");
+#:% section=statement
+BEGIN_PGML
+
+This section is with [|tolTruncation|] set to true (1).  The exact answer
+is [`\pi`].   Enter 3.14, 3.15, 3.141, 3.142 to see if it accepts the answer.
+
+[`\pi=`][_]{$ans}
+
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/DisableFunctions.pg b/tutorial/sample-problems/problem-techniques/DisableFunctions.pg
new file mode 100644
index 0000000000..8929f1487c
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/DisableFunctions.pg
@@ -0,0 +1,93 @@
+## DESCRIPTION
+## This shows how to disable functions allowed in student answers.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Disabling Functions in Student Answers
+#:% type = technique
+#:% categories = [answer]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: We can disable specific operations in the Context: in general, predefined
+#: operations are `* / + - ! >< U ^ ** . ,`, for multiplication, division,
+#: addition, subtraction, the factorial operation, the cross-product ><,
+#: set union, exponentiation (both `^` and `**` give exponentiation), the dot
+#: product, and list creation (,).
+#: ``
+#: After disabling the operation, they can be re-enabled with
+#: `operators->redefine()`, e.g., `Context()->operators->redefine("^")`. We can
+#: also remove operators with `operators->remove()`, but this is not recommended,
+#: as it makes it completely unknown in the Context so that students
+#: won't get helpful error messages if they try to use them.
+#:
+#: To disable specific functions in the Context, we similarly undefine them
+#: from the predefined functions. The predefined functions are `sin, cos, tan, sec,
+#: csc, cot, asin, acos, atan, asec, acsc, acot, sinh, cosh, tanh, sech, csch,
+#: coth, asinh, acosh, atanh, asech, csch, acoth, ln, log, log10, exp, sqrt,
+#: abs, int, sgn, atan2, norm, unit, arg, mod, Re, Im, conj`.
+#:
+#: In addition, classes of functions can be disabled with functions->disable():
+#:
+#: * `Context()->functions->disable("Trig");` (disables all trig functions in both SimpleTrig and InverseTrig functions)
+#: * `Context()->functions->disable("SimpleTrig");` (disables sin, cos, tan, sec, csc, cot)
+#: * `Context()->functions->disable("InverseTrig");` (disables asin, acos, atan, asec, acsc, acot, atan2)
+#: * `Context()->functions->disable("Hyperbolic");` (disables all hyperbolic functions in both SimpleHyperbolic and InverseHyperbolic functions)
+#: * `Context()->functions->disable("SimpleHyperbolic");` (disables sinh, cosh, tanh, sech, csch, coth)
+#: * `Context()->functions->disable("InverseHyperbolic");` (disables asinh, acosh, atanh, asech, acsch, acoth)
+#: * `Context()->functions->disable("Numeric");` (disables ln, log, log10, exp, sqrt, abs, int, sgn)
+#: * `Context()->functions->disable("Vector");` (disables norm, unit)
+#: * `Context()->functions->disable("Complex");` (disables arg, mod, Re, Im, conj)
+#: * `Context()->functions->disable("All");`
+#: Alternatively, we could use the following syntax.
+#:
+#:```{#disable-functions .perl}
+#: Parser::Context::Functions::Disable('All');
+#:```
+#:
+# To disable specific operations in student answers, use the undefine
+# method for the operations:
+Context()->operators->undefine("^", "**");
+
+# We can similarly disable specific functions with the following
+Context()->functions->undefine("sin", "cos", "tan", "sqrt");
+
+$ans = Compute("1/2");
+
+# To disallow absolute value, disable abs(),
+# sqrt and exponentiation (for sqrt(x^2) and (x^4)^(1/4)), and
+# the parentheses | |, and give consistent
+# error messages
+Context()->functions->disable("abs", "sqrt");
+Context()->operators->undefine("^", "**");
+Context()->parens->remove("|");
+Context()->{error}{convert} = sub {
+    my $message = shift;
+    $message =~ s/Unexpected character '~~|'/Absolute value is not allowed/;
+    return $message;
+};
+
+#:% section=statement
+BEGIN_PGML
+Find the numerical value: [` \sin^2(\pi/4) = `] [____]{$ans}
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/DraggableSubsets.pg b/tutorial/sample-problems/problem-techniques/DraggableSubsets.pg
new file mode 100644
index 0000000000..6f1de8f20c
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/DraggableSubsets.pg
@@ -0,0 +1,78 @@
+## DESCRIPTION
+## This shows how to setup a set of draggable items to sort.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('draggable')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Draggable Subsets
+#:% type = technique
+#:% categories = [draggable]
+
+#:% section = preamble
+#: The `draggableSubsets.pl` macro must be loaded.
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'draggableSubsets.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The DraggableSubsets call visually creates a set of regions called buckets that
+#: labelled boxes can be dragged between. The general form is
+#:```{#draggable-subsets-usage .perl}
+#: $draggable = DraggableSubsets(
+#:        $full_set,
+#:        $answer_sets,
+#:        %options
+#:    );
+#:```
+#:
+#: where `$full_set` is the set of all labelled boxes.  The `$answer_sets` is a nested
+#: array reference of distribution of the correct subsets.  There are many options. The
+#: example here shows the use of `DefaultSubsets` which shows how to label and initialize
+#: the buckets. The `AllowNewBuckets` option allows the student in add a new bucket (1)
+#: or not (0).  The `OrderedSubsets` option requires that the subsets in the student
+#: answer be the same as in the correct answer.
+#:
+#: See the [DraggableProofs](../Misc/DraggableProof.html) for an example of
+#: how to create drag and drop proof problems.
+$draggable = DraggableSubsets(
+    [
+        'mouse',        'ebola bacteria',
+        'flu virus',    'krill',
+        'house cat',    'emu',
+        'coyote',       'tapir',
+        'hippopotamus', 'elephant',
+        'blue whale',   'eagle'
+    ],
+    [ [], [ 0, 4, 6, 7, 8, 9, 10 ], [ 5, 11 ], [ 1, 2, 3 ] ],
+    # ['mouse','house cat','coyote','tapir','hippopatamus','elephant']
+    DefaultSubsets => [
+        { label => 'Animals', indices => [ 0 .. 11 ] },
+        { label => 'Mammals', indices => [] },
+        { label => 'Birds',   indices => [] },
+        { label => 'Other',   indices => [] }
+    ],
+    AllowNewBuckets => 0,
+    OrderedSubsets  => 1
+);
+
+#:% section = statement
+BEGIN_PGML
+Move all animals from the "Animals" bucket into its appropriate bucket.
+
+[_]{$draggable}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/EquationEvaluators.pg b/tutorial/sample-problems/problem-techniques/EquationEvaluators.pg
new file mode 100644
index 0000000000..4fa497bbe0
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/EquationEvaluators.pg
@@ -0,0 +1,109 @@
+## DESCRIPTION
+## This code shows how to check student answers that are equations.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer', 'custom')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Implicit Equations Evaluators
+#:% type = technique
+#:% categories = [implicit]
+
+#:% section = preamble
+#: In the initialization section, we need to include the macros file
+#: `parserImplicitEquation.pl`.
+DOCUMENT();
+loadMacros(
+    'PGstandard.pl',             'PGML.pl',
+    'parserImplicitEquation.pl', 'PGcourse.pl'
+);
+
+#:% section=setup
+#: We specify that the `Context` should be `ImplicitEquation`, and define the
+#: answer to be an equation. It's worth noting that there are a number of
+#: `Context` settings that may be specifying for equation answers.
+#: In particular, it's often important to pay attention to the limits
+#: used by the answer checker.
+#:
+#: By default, the `ImplicitEquation` context defines the variables x and y.
+#: To include other variables, it may be necessary to modify the context.
+#:
+#: Two other notes: if it's possible that a student's solution may evaluate
+#: to true for the test points that are used in the answer checker, it may
+#: be a good idea to specify what (x,y) solution values are used to check the
+#: answer. This can be done in the `ImplicitEquation` initialization call, e.g.,
+#:
+#:```{#specify-solutions .perl}
+#: $eqn = ImplicitEquation("y = (x-1)^2",
+#: solutions=>[[0,0],[1,1],[-1,1],[2,4],[-2,4]]);
+#:```
+#:
+#: And, for this type of answer checking it is more likely than for regular
+#: formulas that the student will represent the function in a form that exceeds
+#: the default problem checking tolerances, and so be marked as incorrect. To
+#: correct this, it may be necessary to specify a tolerance; an absolute
+#: tolerance can be set in the `ImplicitEquation` call, e.g.,
+#:
+#:```{#set-tolerance .perl}
+#: $eqn = ImplicitEquation("y = (x-1)^2",
+#: tolerance=>0.0001);
+#:```
+#:
+#: It is possible to remove the error message
+#: "Can't find any solutions to your equation" by remapping it to another
+#: error message. The message has to be non-empty, but it can be just a
+#: blank " ", as in
+#:
+#:```{#error-message .perl}
+#: Context()->{error}{msg}{"Can't find any solutions to your equation"} = " ";
+#:```
+#:
+#: This will eliminate the error message (though the "messages" column will
+#: be displayed in the answer table at the top of the problem, but no
+#: message will be there).
+#:
+#: Another way to remove the error message "Can't find any solutions to your
+#: equation" would be to use a post-filter to remove the message after the
+#: answer has been graded. The answerHints.pl file provides one way to do this,
+#: but it is probably just as easy to do it manually, as replacing the
+#: `$ans` line with the following:
+#:
+#:```{#post-filter .perl}
+#: $ans = ImplicitEquation("y = (x-1)^2")->cmp->withPostFilter(sub {
+#:    my $ans = shift;
+#:    $ans->{ans_message} = " " if $ans->{ans_message} eq
+#:    "Can't find any solutions to your equation";
+#:    return $ans;
+#: }));
+#:```
+Context("ImplicitEquation");
+Context()->variables->set(
+    x => { limits => [ -2, 2 ] },
+    y => { limits => [ 0,  4 ] }
+);
+
+$ans = ImplicitEquation("y = (x-1)^2");
+
+#:% section=statement
+BEGIN_PGML
+Give the equation of a shift of the
+parabola [`y = x^2`] which is upward
+opening and has its vertex at [`(1,0)`].
+
+equation: [___]{$ans}
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/EquationsDefiningFunctions.pg b/tutorial/sample-problems/problem-techniques/EquationsDefiningFunctions.pg
new file mode 100644
index 0000000000..e89ed34913
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/EquationsDefiningFunctions.pg
@@ -0,0 +1,53 @@
+## DESCRIPTION
+## This PG code shows how to check student answers that are equations that
+## define functions. If an equation defines a function, it is much more
+## reliable to use the this method of answer evaluation (via parserAssignment.pl)
+## than the implicit equation method (via parserImplicitEquation.pl).
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer', 'custom')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Equations Defining Functions (Not Implicit)
+#:% type = technique
+#:% categories = [equation]
+
+#:% section = preamble
+#: In the initialization section, we need to include the macros file
+#: `parserAssignment.pl`.
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserAssignment.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: We must allow assignment, and declare any function names we wish to use.
+#: For more details and examples in other `MathObjects` contexts, see
+#: PODLINK('parserAssignment.pl').
+Context("Numeric")->variables->are(x => "Real", y => "Real");
+parser::Assignment->Allow;
+parser::Assignment->Function("f");
+
+$eqn = Formula("y=5x+2");
+$f   = Formula("f(x)=5x+2");
+
+#:% section=statement
+BEGIN_PGML
+Enter [`y = 5x+2`] [___]{$eqn}
+
+Enter [`f(x) = 5x+2`] [___]{$f}
+
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/ErrorMessageCustomization.pg b/tutorial/sample-problems/problem-techniques/ErrorMessageCustomization.pg
new file mode 100644
index 0000000000..e57c71a97f
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/ErrorMessageCustomization.pg
@@ -0,0 +1,47 @@
+## DESCRIPTION
+## This shows how to customize (remap) the error messages students receive after submitting an
+## incorrect response or making a syntax error when entering their answer.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('custom error')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Custom Error Message
+#:% type = technique
+#:% categories = [custom error]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: To update the error message, the string in the `Context()->{error}{msg}`
+#: hash must match exactly and then is replaced with the customized
+#: version.
+Context()->{error}{msg}{"Missing operand after '-'"} =
+    "Enter '-1' instead of '-'";
+
+$ans1 = Real(-1);
+$ans2 = Formula("x-2");
+
+#:% section = statement
+BEGIN_PGML
+Factor [`-1`] from [`-x+2`]
+
+[`-x+2 =`] [__]{$ans1} [`\cdot \big(`] [__]{$ans2} [`\big)`]
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/EvalVersusSubstitute.pg b/tutorial/sample-problems/problem-techniques/EvalVersusSubstitute.pg
new file mode 100644
index 0000000000..732ca19d70
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/EvalVersusSubstitute.pg
@@ -0,0 +1,89 @@
+## DESCRIPTION
+## Shows the difference between eval and substitute for MathObject Formulas
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('formula', 'eval', 'substitute')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Eval Versus Substitute
+#:% type = technique
+#:% categories = [formula]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: First, we start with a formula using `Compute`.
+#:
+#: * `eval` returns a number, which is a `Value::Real`
+#: * `substitute` returns a Formula which is a `Value::Formula`
+#:
+#: The `ref` command is a perl command to determine the reference type. In
+#: these cases they are MathObjects with type `Value::Real` and `Value::Formula`
+#:
+#: For the function `$g`, the line `$g->eval(x => '3');` throws an error
+#: because it is expected to return a number (`Value::Real`).
+#:
+#: The next section shows the effect of changing `reduceConstants` to 0 (false).
+#: Notice that there is no effect on `eval`, the result is the same number
+#: as before, however with `substitute` the value 3 is substituted in but left
+#: within the formula, which is not reduced.
+#:
+#: Lastly, to show the effect of `reduceConstantFunctions`, if we set
+#: `reduceConstants` back to 1 and `reduceConstantFunctions` to 0, we
+#: see that the inside of the square root is reduced (because they are
+#: constants), but the square root remains.
+$f  = Compute("sqrt(3x + 1)");
+$f1 = $f->eval(x => "3");
+$f2 = $f->substitute(x => "3");
+
+Context()->variables->add(y => 'Real');
+$g = Compute('7xy');
+# This next line is an error.
+# $g1 = $g->eval(x => '3');
+$g2 = $g->substitute(x => '3');
+$g3 = $g->eval(x => 3, y => -1);
+
+Context()->flags->set(reduceConstants => 0);
+$f3 = $f->eval(x => 3);
+$f4 = $f->substitute(x => 3);
+
+Context()->flags->set(reduceConstantFunctions => 0, reduceConstants => 1);
+$f5 = $f->substitute(x => 3);
+
+#:% section=statement
+BEGIN_PGML
+This shows the difference between [|eval|] and [|substitute|].  First, we start
+with a function [`[$f]`]:
+
+* [|$f->eval(x=>'3')|] returns [$f1] and the type is [@ ref $f1@]
+* [|$f->substitute(x=>'3')|] returns [$f2] and the type is [@ ref $f2 @]
+
+Next, we do the same with the function [`[$g]`]
+
+* [|$g->eval(x=>'3')|] throws an error.
+* [|$g->substitute(x=>'3')|] returns [$g2] and the type is [@ ref $g2 @]
+* [|$g->eval(x=>'3', y => -1)|] returns [$g3] and the type is [@ ref $g3 @]
+
+If [|reduceConstants|] is set to 0 (False) in the flags, we get
+
+* [|$f->eval(x => 3)|] returns [$f3]
+* [|$f->substitute(x => 3)|] returns [$f4]
+
+If [|reducedConstants|] is set back to 1 and [|reduceConstantFunctions|] is
+set to 0, then
+
+* [|$f->substitute(x => 3)|] returns [$f5]
+
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/ExtractingCoordinatesFromPoint.pg b/tutorial/sample-problems/problem-techniques/ExtractingCoordinatesFromPoint.pg
new file mode 100644
index 0000000000..72051da989
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/ExtractingCoordinatesFromPoint.pg
@@ -0,0 +1,72 @@
+## DESCRIPTION
+## This problem shows how to extract the coordinates from a point.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('point', 'coordinates')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Extracting Coordinates from a Point
+#:% type = technique
+#:% categories = [point]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: In the problem setup section of the file, we put the value of the subtraction
+#: of two `Points` in two variables, `$d1`, the `x`-coordinate, and `$d2`,
+#: the `y`-coordinate. This is achieved by calling Point's value method, as shown.
+#:
+#: Alternative method: If you want to get only one of the coordinates of a
+#: `Point`, you can use the extract method, for example:
+#: `$x = $point->extract(1);`. This gets the first coordinate of `$point`
+#: (x) and assigns it to the variable `$x`.
+#:
+#: We don't use `Context('Vector')`; and `norm( $point[0] - $point[1] )` here to
+#: determine length because we don't want to accept an answer like `|<5,7>-<7,8>|`.
+#:
+#: Alternative method: You can use `$length=norm( $point[0] - $point[1] );`
+#: with `Context('Vector');` if you want to accept answers that are valid in
+#: the `Vector` context (such as the absolute value of a vector).
+#:
+#: We need to put parentheses around `$d1` and `$d2` in the `Compute` expression
+#: because if `$d1 = -6`, then `-6^2 = -36`, not `36`, as desired. However, if
+#: the code is `($d1)^2` then that evaluates as `(-6)^2 = 36`, as desired.
+Context('Point');
+
+push(@point, Point(random(1, 5),  random(-5, -1)));
+push(@point, Point(random(5, 10), random(6,  11)));
+
+# now we have two points, $point[0] = (x1,y1)
+# and $point[1] = (x2,y2).
+# the following makes $d1 = x1 - x2, $d2 = y1 - y2
+($d1, $d2) = ($point[0] - $point[1])->value;
+
+$length = Compute("sqrt( ($d1)^2+($d2)^2 )");
+$mid    = ($point[1] + $point[0]) / 2;
+
+BEGIN_PGML
+Consider the two points [`[$point[0]]`] and [`[$point[1]]`].
+
+The distance between them is: [___]{$length}
+
+The midpoint of the line segment that joins them is:
+[___]{$mid}
+
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/FactoringAndExpanding.pg b/tutorial/sample-problems/problem-techniques/FactoringAndExpanding.pg
new file mode 100644
index 0000000000..25d52d4aa0
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/FactoringAndExpanding.pg
@@ -0,0 +1,100 @@
+## DESCRIPTION
+## This shows how to check answers that require students to factor or expand
+## a polynomial expression.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('answer', 'custom')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Factoring and Expanding Polynomials
+#:% type = technique
+#:% categories = [polynomials, factoring, expanding]
+
+#:% section = preamble
+#: In the initialization section, we need to include the macros file
+#: `contextLimitedPolynomial.pl`, `contextPolynomialFactors.pl` and
+#: `contextLimitedPowers.pl`.
+DOCUMENT();
+loadMacros(
+    'PGstandard.pl',               'PGML.pl',
+    'contextLimitedPolynomial.pl', 'contextPolynomialFactors.pl',
+    'contextLimitedPowers.pl',     'PGcourse.pl'
+);
+
+#:% section=setup
+#: To construct this quadratic, we choose a nice factored form `(x+$a)(x-$b)` and
+#: from it we construct its vertex form `(a(x-h)^2+k)` and expanded form
+#: `(ax^2+bx+c)`.
+#:
+#: For the expanded form we use the `LimitedPolynomial-Strict` context,
+#: construct the coefficients `$p[0]` and `$p[1]` as Perl reals, and then
+#: construct `$expandedform` using these pre-computed coefficients. This is
+#: because the `LimitedPolynomial-Strict` context balks at answers that are
+#: not already simplified completely.
+#:
+#: For the factored form we need to change to the `PolynomialFactors-Strict`
+#: context and restrict the allowed powers to either 0 or 1 using the
+#: `LimitedPowers::OnlyIntegers` block of code. Note: restricting all exponents
+#: to 0 or 1 means that repeated factors will have to be entered in the form
+#: `k(ax+b)(ax+b)` instead of `k(ax+b)^2`. Also, restricting all exponents to
+#: 0 or 1 means that the polynomial must factor as a product of linear
+#: factors (no irreducible quadratic factors can appear). Of course,
+#: we could allow exponents to be 0, 1, or 2, but then students would be
+#: allowed to enter reducible quadratic factors. There are no restrictions
+#: on the coefficients, i.e., the quadratic could have any nonzero leading c
+#: oefficient. We set `singleFactors=>0` so that repeated, non-simplified
+#: factors do not generate errors.
+
+#  Vertex form
+Context("Numeric");
+$n          = list_random(4, 6);
+$a          = random(2, 4, 1);
+$b          = ($a + $n);
+$h          = ($b - $a) / 2;
+$k          = $h**2 + $a * $b;
+$vertexform = Compute("(x-$h)^2-$k");
+
+#  Expanded form
+Context("LimitedPolynomial-Strict");
+$p0           = $h**2 - $k;
+$p1           = 2 * $h;
+$expandedform = Formula("x^2 - $p1 x + $p0")->reduce;
+
+#  Factored form
+Context("PolynomialFactors-Strict");
+Context()->flags->set(singleFactors => 0);
+LimitedPowers::OnlyIntegers(
+    minPower => 0,
+    maxPower => 1,
+    message  => "either 0 or 1",
+);
+$factoredform = Compute("(x+$a)(x-$b)");
+
+#:% section=statement
+BEGIN_PGML
+
+The quadratic expression [` [$vertexform] `] is written in vertex form.
+
+a. Write the expression in expanded form [` ax^2 + bx + c `].
+
+    [_____]{$expandedform}
+
+b. Write the expression in factored form [` k(ax+b)(cx+d) `].
+
+    [_____]{$factoredform}
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/FormattingDecimals.pg b/tutorial/sample-problems/problem-techniques/FormattingDecimals.pg
new file mode 100644
index 0000000000..56faf42ad2
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/FormattingDecimals.pg
@@ -0,0 +1,94 @@
+## DESCRIPTION
+## We show how to use format decimals, and, conveniently also how to use logarithmic functions in PG problems.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('formatting decimals', 'logarithm')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Formatting Decimals
+#:% type = technique
+#:% categories = [formatting decimals, logarithm]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: Since the domain of a logarithmic function is all positive real numbers,
+#: we should set the domain of function evaluation to `[2,4]` in order to avoid
+#: vertical asymptotes and places where a logarithmic function takes values
+#: close to zero.
+#:
+#: Use perl's `sprintf( format, number );` command to format the decimal. The
+#: `"%0.3f"` portion truncates after 3 decimal places and uses zeros (not spaces)
+#: to right-justify. For answers involving money, you should set `"%0.2f"` for
+#: two decimal places and zero filling (for example, `sprintf("%0.2f",0.5);`
+#: returns `0.50`). You can do a web search for more options to perl's sprintf,
+#: and also for WeBWorK's PODLINK('contextCurrency.pl'). If you do further
+#: calculations with `$b`, be aware that numerical error may be an
+#: issue since you've reduced the number of decimal places.
+#:
+#: We used the logarithm change of base formula
+#: `log10(a) = log(a) / log(10) = ln(a) / ln(10)` to get a logarithm base 10.
+#:
+#: It is possible to set a context flag that will use the base 10 log via
+#: `Context()->flags->set(useBaseTenLog=>1);` The default is that this is set to zero.
+#:
+#: If you would like to define log base 2 (or another base) see
+#: PROBLINK('AddingFunctions.pg') for how to define and add a new function
+#: to the context so that students can enter it in their answers.
+Context("Numeric");
+Context()->variables->set(x => { limits => [ 2, 4 ] });
+
+$a = random(3, 7, 1);
+
+# both ln and log are natural log (base e)
+$b    = sprintf("%0.3f", ln($a));
+$ans1 = Real("$b");
+
+$f    = Formula("ln(x)");    # or log(x)
+$ans2 = $f->eval(x => $a);
+
+# log base 10 is log10, logten,
+# ln(x)/ln(10), or log(x)/log(10)
+
+$c    = sprintf("%0.3f", ln($a) / ln(10));    # or log($a)/log(10)
+$ans3 = Real("$c");
+
+$g    = Formula("ln(x)/ln(10)");              # or log(x)/log(10)
+$ans4 = $g->eval(x => $a);
+
+#:% section=statement
+#: Notice the difference in decimal formatting when "Show Correct Answers"
+#: is checked and you click "Submit Answers".
+BEGIN_PGML
+Notice the formatting and rounding differences
+between [` [$ans1] `] and [` [$ans2] `].
+
+Try entering [` \ln([$a]), \log([$a]), \ln([$a])/\ln(10), \log([$a])/\log(10),
+\mathrm{logten}([$a]), \mathrm{log10}([$a]) `].
+
+
+1. [` \ln([$a]) = `] [_____]{$ans1}
+
+2. [` \ln([$a]) = `] [_____]{$ans2}
+
+3. [` \log_{10}([$a]) = `] [_____]{$ans3}
+
+4. [` \log_{10}([$a]) = `] [_____]{$ans4}
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/FormulasToConstants.pg b/tutorial/sample-problems/problem-techniques/FormulasToConstants.pg
new file mode 100644
index 0000000000..7d07ffd92f
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/FormulasToConstants.pg
@@ -0,0 +1,57 @@
+## DESCRIPTION
+## Formulas up to additive constants.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(WeBWorK tutorial)
+## Date(05/28/2023)
+## Institution(Missouri Western State University)
+## Author(Glenn Rice)
+## KEYWORDS('formulas', 'constants')
+
+#:% name = Formulas up to additive constants
+#:% type = technique
+#:% categories = [constant]
+
+#:% section = preamble
+#: There are two types of comparison demonstrated here. One is "an
+#: antiderivative of f(x)", and the other is "the most general antiderivative of
+#: f(x)". The former requires that the student answers F(x), F(x) + 1,
+#: F(x) - sqrt(8), etc., all be marked correct, and the latter, that F(x) + C,
+#: F(x) + 5 - k, etc., all be marked correct.
+#:
+#: To check the most general antiderivative of a function, that is, a formula up
+#: to an arbitrary additive constant, the `parserFormulaUpToConstant.pl` macro
+#: is used. To evaluate an antiderivative of a function, that is, a formula that
+#: is unique up to a (specified) additive constant, this macro is not needed.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',                'PGML.pl',
+    'parserFormulaUpToConstant.pl', 'PGcourse.pl'
+);
+
+#:% section = setup
+#: Define an antiderivative function `$func` and the most general antiderivative
+#: function `$gfunc`. For the latter is is not required to include `+ C`. It
+#: would be equivalent to specify `$gfunc = FormulaUpToConstant('sin(x)')`.
+$func  = Formula('sin(x)');
+$gfunc = FormulaUpToConstant('sin(x) + C');
+
+#:% section = statement
+#: Call the MathObjects `cmp()` method and specify the `upToConstant => 1` flag.
+#: This allows the student's answer to differ from the correct answer by any
+#: constant. Both `sin(x)` and `sin(x) + 5` would be marked correct, but
+#: `sin(x) + C` is not correct since it is a family of answers and not a
+#: specific antiderivative. Note that for the formula up to an arbitrary
+#: constant the comparison will correctly mark student's answers that have
+#: different arbitrary constants. Thus, a student answer to the second question
+#: of `sin(x) + k` will be marked correct as will `sin(x) + c`.
+BEGIN_PGML
+An antiderivative of [`\cos(x)`] is [_]{$func->cmp(upToConstant => 1)}
+
+The most general antiderivative is [_]{$gfunc}
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/GraphsInTables.pg b/tutorial/sample-problems/problem-techniques/GraphsInTables.pg
new file mode 100644
index 0000000000..cb37e408c4
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/GraphsInTables.pg
@@ -0,0 +1,141 @@
+## DESCRIPTION
+## Creating a set of graphs and displaying the options in a table.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('parametric', 'graph')
+
+#:% name = Graphs in a Table
+#:% types = [Sample, technique]
+
+#:% section = preamble
+#: We use `PGtikz.pl` to generate the graph, `parserPopUp.pl` for the
+#: popup (select), `niceTables.pl` for layout and `PGchoicemacros.pl`
+#: for the `shuffle` and `invert` functions.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl', 'PGML.pl',
+    'PGtikz.pl',     'parserPopUp.pl',
+    'niceTables.pl', 'PGchoicemacros.pl',
+    'PGcourse.pl'
+);
+
+#:% section=setup
+#: Pick one equation and graph at random (using `$k`) to be the correct choice.
+#: Shuffle the graphs using a permutation, and use the inverse permutation to
+#: recall the correct answer in the answer evaluation section.
+#:
+#: For accessibility, there are `alt_text` statements describing each graph. Because
+#: the graphs are shuffled and the correct one picked randomly, the `alt_text`
+#: must be in an array in the same order as the functions.
+# The form of the functions for the tikz plotting.
+#:
+#: If, instead, we had six graphs and desired a three-column array of graphs,
+#: we would want to change `tex_size=>310` as in the following bit of code.
+#:
+#:```{#for-loop .perl}
+#: for $i (0..5) {
+#:   # create the plots
+#:
+#:   $fig[$i]=image($graph[$i], width => 200, tex_size => 310);
+#: }
+#:```
+#: You are strongly discouraged from using more than three columns in an array of
+#: graphs because otherwise you have to scale the graphs down so much that they
+#: become unreadable (especially in TeX mode).
+#:
+#: The `LayoutTable` is part of PODLINK('niceTables.pl') and is useful for
+#: laying out elements.
+#:
+#: Toward the bottom the line `[$tab]*` inserts the table.  Since the result
+#: is HTML, the `*` at the end formats the result correctly.
+#:
+@eqn_plot = ('-exp(\x)', 'exp(-\x)', '-exp(-\x)', 'exp(\x)');
+
+# The tex form of the functions.
+@eqn = (
+    "\( y = -e^{x} \)",
+    "\( y = e^{-x} \)",
+    "\( y = -e^{-x} \)",
+    "\( y = e^{x} \)"
+);
+
+# Alternate text for each image.
+@alt_text = (
+    'A graph starting near the negative x-axis on the left, decreasing to the lower left in a concave down manner',
+    'A graph in the upper left and decreasing to the x-axis in a concave up manner',
+    'A graph in the lower left and increasing to the x-axis in a concave down manner',
+    'A graph starting near the negative x-axis on the left, increasing to the upper right in a concave up manner',
+);
+
+for $i (0 .. 3) {
+    $graph[$i] = createTikZImage();
+    $graph[$i]->tikzLibraries('arrows.meta');
+    $graph[$i]->BEGIN_TIKZ
+  \tikzset{>={Stealth[scale=1.5]}}
+  \filldraw[
+      draw=LightBlue,
+      fill=white,
+      rounded corners=10pt,
+      thick,use as bounding box
+  ] (-3.5,-3.5) rectangle (3.5,3.5);
+  \draw[->] (-3.5,0) -- (3.5,0) node[above left,outer sep=3pt] {\(x\)};
+  \draw[->] (0,-3.5) -- (0,3.5) node[below right,outer sep=3pt] {\(y\)};
+  \draw[DarkBlue,very thick] plot [samples=150,domain=-3:3]
+      (\x,{$eqn_plot[$i]});
+END_TIKZ
+    $fig[$i] = image(
+        $graph[$i],
+        width           => 200,
+        tex_size        => 450,
+        extra_html_tags => "alt='$alt_text[$i]'"
+    );
+}
+
+$k = random(0, 3);
+
+@perm = shuffle(4);
+@fig  = @fig[@perm];
+@inv  = invert(@perm);
+
+@letter = ("A", "B", "C", "D");
+
+$popup = PopUp([ "?", "A", "B", "C", "D" ], $letter[ $inv[$k] ]);
+
+$tab = LayoutTable(
+    [
+        [ 'A',     'B' ],
+        [ $fig[0], $fig[1] ],
+        [ 'C',     'D' ],
+        [ $fig[2], $fig[3] ],
+    ],
+    texalignment => 'cc'
+);
+
+#:% section = statement
+BEGIN_PGML
+Consider the exponential equation [$eqn[$k]].
+Without using a calculator, sketch a
+graph of this equation on paper.
+
+Which graph A-D below most closely matches
+the graph you drew?  [___]{$popup}
+
+[$tab]*
+
+(Click on a graph to enlarge it.)
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/HtmlLinks.pg b/tutorial/sample-problems/problem-techniques/HtmlLinks.pg
new file mode 100644
index 0000000000..854fae5543
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/HtmlLinks.pg
@@ -0,0 +1,69 @@
+## DESCRIPTION
+## This shows how to make an html link in a PG problem.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('link')
+
+#:% name = HTML Links
+#:% type = [snippet, technique]
+
+#:% section = preamble
+#: An example below uses units, so we load `parserNumberWithUnits.pl`.
+DOCUMENT();
+loadMacros(
+    'PGstandard.pl',            'PGML.pl',
+    'parserNumberWithUnits.pl', 'PGcourse.pl'
+);
+
+#:% section=setup
+$ans = NumberWithUnits('4', 'ft');
+
+#:% section=statement
+#: We need no additions to the PG file except in the text section, where we use
+#: the `htmlLink` function to insert the link. There are four examples here in
+#: all, the page to load is given as the first argument to `htmlLink`, and the
+#: text to display as the link as the second argument.
+#:
+#: 1. This is a link to a general URL.
+#:
+#: 2. The second example shows how to link to a page that is in the same directory
+#: on the WeBWorK server as the PG file: the alias function puts in the correct
+#: link for this file. Setting the target to be _blank will open a new (blank)
+#: window or tab.
+#:
+#: 3. The third example shows how to link to a page that is under the html
+#: subdirectory of a course's main directory. In this example, which is taken
+#: from the problem `Library/Rochester/setDiffEQ6AutonomousStability/ur_de_6_3.pg`,
+#: phaseplaneplotters is a subdirectory that has been added under the course's
+#: html directory. The course's html directory can be linked using `${htmlURL}`
+#: as in the example given or by using
+#: `alias("${htmlDirectory}phaseplaneplotters/index.html")`.
+#:
+#: 4. The fourth example uses the built-in `helpLink` feature of WeBWorK. The
+#: following is a list of all help topics: angle, decimal, equation, exponent
+#: formula, fraction, inequality, limit, log, matrix, number, point, vector,
+#: interval, unit, syntax.
+BEGIN_PGML
+The answer to all questions is on
+[@ htmlLink( "http://www.google.com/", "this page" ) @]*
+
+A link to a
+[@ htmlLink( alias('local.html'), "local problem", "TARGET='_blank'" ) @]*
+
+Click [@htmlLink("${htmlURL}phaseplaneplotters/index.html",
+  "sketch the graph.", "TARGET='plotter'" )@]* to use xFunctions for
+plotting.
+
+Enter 4 feet: [__]{$ans}
+
+Don't forget to enter [@ helpLink("units") @]*
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/Images.pg b/tutorial/sample-problems/problem-techniques/Images.pg
new file mode 100644
index 0000000000..4ea85d77c0
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/Images.pg
@@ -0,0 +1,84 @@
+## DESCRIPTION
+## Inserting images in PGML.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('images')
+
+#:% name = Inserting Images in PGML
+#:% type = [technique]
+
+#:% section = preamble
+#: We include `PGgraphmacros.pl`, `PGtikz.pl`, `PGlateximage.pl` and
+#: `parserGraphTool.pl` to create images to be shown.
+DOCUMENT();
+
+loadMacros(
+    'PGstandard.pl',    'PGML.pl',
+    'PGgraphmacros.pl', 'PGtikz.pl',
+    'PGlateximage.pl',  'parserGraphTool.pl',
+    'PGcourse.pl'
+);
+
+#:% section = setup
+#: A WWPlot (from `PGgraphmacros.pl`), a TikZ plot, LaTeXImage, and
+#: Graphtool is made.
+$WWPlot = init_graph(-1, -1, 4, 4);
+add_functions($WWPlot, "x^2/4 for x in <-1,4> using color:blue and weight:2");
+
+$TikZ = createTikZImage();
+$TikZ->BEGIN_TIKZ
+\draw (0,0) circle[radius=1.5];
+END_TIKZ
+
+$LaTeXImage = createLaTeXImage();
+$LaTeXImage->texPackages([ [ 'xy', 'all' ] ]);
+$LaTeXImage->BEGIN_LATEX_IMAGE
+\xymatrix{ A \ar[r] & B \ar[d] \\\\
+           D \ar[u] & C \ar[l] }
+END_LATEX_IMAGE
+
+$gt = GraphTool("{circle, solid, (1, 1), (2, 2)}");
+
+#:% section = statement
+#: In each of these cases, we use the PGML syntax
+#:```
+#:[!alt text!]{image}{width (optional)}{height (optional)}
+#:```
+#:
+#: * The image can be a string (either a local image file or a URL), a
+#: WWPlot, TikZ plot, LaTeXImage, or graphtool plot. The local file should be
+#: in the same directory as the problem.
+#:
+#: * You should always include some alternate text for accessibility.
+#:
+#: * If the `width` is not included, the width is 100 (in pixels)
+#:
+#: * If the `height` is not included, it takes on the natural value (not to
+#: stretch the image)
+#:
+#: * The `tex_size` will be computed by `width * 1000/600`
+BEGIN_PGML
+
+* A static image: [!Graph of an exponential!]{'image.png'}{120}
+
+* A static image from an external link (note: this does not work for hardcopy)
+[!Runestone Logo!]{"https://runestone.academy/runestone/static/images/RAIcon.png"}{120}
+
+* A WWplot graph [!A simple parabola plot!]{$WWPlot}{120}
+
+* A TikZ graph [!A circle!]{$TikZ}{120}
+
+* A LaTeXImage: [!A graph with node A going to node B going to node C, going to node D, and back to node A!]{$LaTeXImage}{120}
+
+* A graphtool plot [!A graphtool plot with a circle!]{$gt}{120}
+
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/InequalityEvaluators.pg b/tutorial/sample-problems/problem-techniques/InequalityEvaluators.pg
new file mode 100644
index 0000000000..b69ac982dd
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/InequalityEvaluators.pg
@@ -0,0 +1,67 @@
+## DESCRIPTION
+## This shows how to use inqualities in a problem.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('interval')
+
+# created as a full problem by Peter Staab  2023.06.02
+
+#:% name = Inequality Evaluator
+#:% type = [technique]
+#:% categories = interval
+#:% subject = algebra
+#:% see_also = [IntervalEvaluators.pg]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextInequalities.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: Using `Context('Inequalities-Only')`, if the student enters the inequality
+#: `-16 <= y <= 9` their answer will be marked correct, but the equivalent
+#: interval `[-16,9]` would be incorrect. If we had used
+#: `Context('Inequalities')` instead, both the inequality and the interval
+#: would be marked correct.
+#:
+#: Uncommenting the lines containing `EmptySet` creates an empty set as a named
+#: constant and uses that name.
+#:
+#: Uncommenting `Context()->flags->set(ignoreEndpointTypes=>1);` would also mark
+#: the student answers `-16 < y < 9` or `-16 <= y < 9` or `-16 < y <= 9` correct.
+Context("Inequalities-Only");
+Context()->variables->add(y => "Real");
+# Context()->constants->add(EmptySet => Set());
+# Context()->flags->set(noneWord=>"EmptySet");
+# Context()->flags->set(ignoreEndpointTypes=>1);
+
+# f(x) = x^2 - 16 on -1 <= x <= 5
+$f = Formula("x^2 - 16");
+
+$range = Compute("-16 <= y <= 9");
+
+Context()->variables->remove("x");
+
+#:% section=statement
+BEGIN_PGML
+What is the range of
+[`y = f(x) = [$f] `] on the domain [` -1 \leq x \leq 5 `]?
+
+
+Range: [___]{$range}
+
+Enter your answer using inequalities (not intervals).
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/IntervalEvaluators.pg b/tutorial/sample-problems/problem-techniques/IntervalEvaluators.pg
new file mode 100644
index 0000000000..e8d7c0ea99
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/IntervalEvaluators.pg
@@ -0,0 +1,59 @@
+## DESCRIPTION
+## This shows how to use intervals in a problem.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('interval')
+
+# created as a full problem by Peter Staab  2023.06.02
+
+#:% name = Interval Evaluator
+#:% type = [technique]
+#:% categories = interval
+#:% subject = algebra
+#:% see_also = [InequalityEvaluators.pg]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: In the problem set-up section of the file, we set the `Context` to be the
+#: `Interval` context. Note that we can relax checking of endpoints in the
+#: `Context` or in the actual answer checking, as noted below.
+#:
+#: Once we're in the `Interval` context, we can define intervals as we'd expect:
+#: as shown here, or with limits at infinity:
+#:
+#:```{#interval .perl}
+#: $int2 = Compute('(-inf,1]');
+#:```
+#: This would give the interval from negative infinity to 1, including
+#: the point at one. Note the Context flag to make endpoint checking "fuzzy."
+Context('Interval');
+# to allow open or closed intervals, uncomment
+#    the following line.
+# Context()->flags->set(ignoreEndpointTypes=>1);
+
+$int = Compute('(1,3)');
+
+#:% section=statement
+BEGIN_PGML
+On what interval is the parabola [`y = (1-x)(x-3)`]
+above the [`x`]-axis?
+
+For [`x`] in [_____]{$int}
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/Knowls.pg b/tutorial/sample-problems/problem-techniques/Knowls.pg
new file mode 100644
index 0000000000..cdbefc13b8
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/Knowls.pg
@@ -0,0 +1,46 @@
+## DESCRIPTION
+## This shows how to use intervals in a problem.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('interval')
+
+# created as a full problem by Peter Staab  2023.06.02
+
+#:% name = Knowls
+#:% type = [technique, snippet]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=statement
+#: Knowls appear in the text section of the problem file. You can specify
+#: a value, as in the first example, which gives the text to appear in the
+#: Knowl, or the URL of a file with the HTML content for the knowl, as
+#: shown in the second example here.
+#:
+#: To include math text in the knowl, it is necessary to pipe the text
+#: through EV3P and escapeSolution HTML, as shown in the third example.
+BEGIN_PGML
+Here is a knowl
+[@ knowlLink("click me", value =>
+  'This is the inside of a knowl.  If you click again, I will go away') @]*
+
+Here is another knowl
+[@ knowlLink("click me",
+  url=>'https://openwebwork.org') @]*
+
+
+[@ knowlLink("a math knowl",
+value=>escapeSolutionHTML(EV3P("the sine function is \\(\\frac{2}{3}\\)")), base64=>1);
+@]*
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/LayoutTable.pg b/tutorial/sample-problems/problem-techniques/LayoutTable.pg
new file mode 100644
index 0000000000..dcdcddd889
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/LayoutTable.pg
@@ -0,0 +1,103 @@
+## DESCRIPTION
+## This shows how to use LayoutTable for layout.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('tutorial', 'table')
+
+#:% name = Layout Table
+#:% type = [technique]
+#:% categories = table
+#:% see_also = [DataTables.pg]
+
+#:% section = preamble
+#: This shows how to use the `LayoutTable` function in `niceTables.pl` to
+#: give a nice two column format.
+#:
+#: Note the `LayoutTable` does the right thing for accessibility and
+#: webpage responsiveness.
+DOCUMENT();
+loadMacros(
+    'PGstandard.pl', 'PGML.pl', 'niceTables.pl', 'PGtikz.pl',
+    'PGcourse.pl'
+);
+
+#:% section=setup
+#: We use the `LayoutTable` function from `niceTables.pl` to demonstrate some
+#: of it's features.
+#:
+#: The basic form of a `LayoutTable` is identical to that of `DataTable` or
+#:```{#datatable .perl}
+#:$table = LayoutTable([
+#:   [row1],
+#:   [row2],
+#:   ...
+#:   [rowN]
+#: ],
+#: options);
+#:```
+#: where the data goes in as an array ref of array refs.  However, if using
+#: a table for layout purposes, `LayoutTable` has more appropriate default
+#: options.  See
+#: PODLINK('the niceTables.pl POD','niceTables.pl') for more details.
+#:
+#: Notice in this example that we make two columns.  The left column is
+#: written using older style PG, with `$PAR` as a paragraph break.
+$a   = random(0, 3);
+$ans = Compute("x^2+$a")->reduce;
+
+$left = qq|
+A common situation is that there is a problem with a graph and
+the problem is on the left column and the graph is on the right
+column.
+$PAR
+This even works if we add an equation like \(e^{i\pi}+1 = 0\)
+$PAR
+Or if we add an answer blank.
+$PAR
+A formula for the function graphed on the right is \(f(x)=\)| . ans_rule(10);
+
+$graph = createTikZImage();
+$graph->tikzLibraries('arrows.meta');
+$graph->BEGIN_TIKZ
+\tikzset{>={Stealth[scale=1.5]}}
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-6,7) rectangle (6,-1);
+\draw[->,thick] (-6,0) -- (6,0) node[above left,outer sep=3pt] {\(x\)};
+\foreach \x in {-5,...,-1,1,2,...,5}
+    \draw(\x,5pt) -- (\x,-5pt) node [below] {\(\x\)};
+\draw[->,thick] (0,-1) -- (0,7) node[below right,outer sep=3pt] {\(y\)};
+\foreach \y in {1,...,6}
+    \draw (5pt,\y) -- (-5pt,\y) node[left] {\(\y\)};
+\draw[blue,ultra thick] plot[domain=-2.5:2.5,smooth] (\x,{\x*\x+$a});
+END_TIKZ
+
+#:% section=statement
+#: Since the only output is the table, we use this line to output the
+#: problem as the two columns. This is the `LayoutTable` with only
+#: one row.
+TEXT(LayoutTable(
+    [ [ $left, image($graph, width => 400, tex_size => 600) ] ],
+    align => 'lc'
+));
+
+#:% section = answer
+#: Since `ans_rule` is used to produce answer blanks, this in needed.
+ANS($ans->cmp);
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/Multianswer.pg b/tutorial/sample-problems/problem-techniques/Multianswer.pg
new file mode 100644
index 0000000000..4a69c57920
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/Multianswer.pg
@@ -0,0 +1,110 @@
+## DESCRIPTION
+## A simple multianswer problem.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('tolerance')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Multianswer Problem
+#:% type = [technique, sample]
+#:% subject = [algebra, precalculus]
+#:% categories = [multianswer]
+
+#:% section = preamble
+#: Since we are using the Multianswer technique, `parserMultianswer.pl`
+#: must be loaded.
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserMultiAnswer.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: This problem is shown as an example of using `parserMultiAnswer.pl`.
+#: A better solution for this type of problem is shown in
+#: PROBLINK('FactoredPolynomial.pg').
+#:
+#: In the setup section of the file we define a `MultiAnswer` object that
+#: knows how to deal with the problem. Here we define an object that will take two
+#: answers and check that they are correct (in either order).
+#:
+#: First, the `singleResult=>0` line indicates that the different answers in the
+#: problem will be evaluated as separate answers, rather than as a single unit.
+#: Other useful flags include `allowBlankAnswers`, `checkTypes`, `separator` and
+#: `tex_separator`. These are noted below.
+#:
+#: Then, the `checker=> section` defines a subroutine to evaluate the problem.
+#: It will always have as input a reference to an array of correct answers, a
+#: reference to an array of student answers, and a reference to the object
+#: itself. (There is a fourth input, too, an answer hash, but we don't need
+#: that here.)
+#:
+#: The checker routine then returns a reference to a list of results for the
+#: problem. In this case there are two answer blanks, so there are two return
+#: values. All return values should be `0` or `1`, according to whether the
+#: answer for that answer blank is correct or not. Note that if we made
+#: this an "all or nothing" problem (that is, we set `singleResult=>1`),
+#: then there is only one return value needed, so that we could just
+#: `return 0` or `return 1`.
+#:
+#: It is possible to set an answer message that will be displayed when the
+#: problem is checked, too. For example, if we wanted to set a message when
+#: one of the parts was wrong, we could replace the section of the checker
+#: code that deals with incorrect answers with:
+#:
+#:```{.perl}
+#: if ($f1 == $f1stu || $f2 == $f1stu) {
+#:   $self->setMessage(1,"This is correct.");
+#:   $self->setMessage(2,"Check your answer " .
+#:       "by using FOIL.");
+#:   return [1,0];
+#: } elsif ($f1 == $f1stu || $f2 == $f2stu) {
+#:   $self->setMessage(1,"Check your answer " .
+#:       "by using FOIL.");
+#:   $self->setMessage(2,"This is correct.");
+#:   return [0,1];
+#: } else {
+#:   return [0,0];
+#: }
+#:```
+$fac1 = Formula("(1 - x)");
+$fac2 = Formula("(1 + x)");
+
+$multians = MultiAnswer($fac1, $fac2)->with(
+    singleResult => 0,
+    checker      => sub {
+        my ($correct, $student, $self) = @_;
+        my ($f1stu, $f2stu) = @{$student};
+        my ($f1,    $f2)    = @{$correct};
+        if (($f1 == $f1stu && $f2 == $f2stu)
+            || ($f1 == $f2stu && $f2 == $f1stu))
+        {
+            return [ 1, 1 ];
+        } else {
+            if ($f1 == $f1stu || $f2 == $f1stu) {
+                return [ 1, 0 ];
+            } elsif ($f1 == $f2stu || $f2 == $f2stu) {
+                return [ 0, 1 ];
+            } else {
+                return [ 0, 0 ];
+            }
+        }
+    }
+);
+
+BEGIN_PGML
+Factor: [`1-x^2 = \big(`] [___]{$multians}
+[`\big)\big(`] [___]{$multians} [`\big)`]
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/NumericalTolerance.pg b/tutorial/sample-problems/problem-techniques/NumericalTolerance.pg
new file mode 100644
index 0000000000..18648e2997
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/NumericalTolerance.pg
@@ -0,0 +1,76 @@
+## DESCRIPTION
+## Explains the difference in tolerance type and numerical tolerance.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('tolerance')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Numerical Tolerance
+#:% type = technique
+#:% categories = [numbers, tolerance]
+#:% see_also = [DigitsTolType.pg]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: This shows three different ways of setting the toltype and tolerance of the answer. The
+#: `tolType` can be `absolute` (specifying a decimal distance from the correct answer that
+#: will be allowed) or `relative` (specifying a percent error that will be allowed).
+#:
+#: Thus if the correct answer is 17, a tolerance of 0.01 will mean that the student answer
+#: must be in the interval `(16.99,17.01)` if the `tolType` is `absolute`, and in the interval
+#: `(16.83,17.17)` if `tolType` is `relative` (or omitted, as relative tolerance is the default).
+#:
+#: 1. The default `Context('Numeric')` is used (but not needed) and within the Compute call,
+#: the `tolerance` type and level is set.
+#:
+#: 2. The `tolerance` and `toltype` is set on the answer check with the cmp call.  See the
+#: problem statement below.
+#:
+#: 3. The `tolerance` and `toltype` can be set on the `Context`.  This is useful if the desired
+#: toltype and/or tolerance is the same for many answer.  Typically this would go at the
+#: top of the setup section.
+$ans1 = Compute('1.5708')->cmp(
+    tolType   => 'absolute',
+    tolerance => .0001,
+);
+
+$ans2 = Compute('1.5708');
+
+Context('Numeric')->flags->set(
+    tolerance => 0.0001,
+    tolType   => 'absolute',
+);
+
+$ans3 = Compute('1.5708');
+#:% section = statement
+BEGIN_PGML
+For each of the following Enter your answer accurate to four decimal places .
+
+1. Enter [`` \frac{\pi}{2}= ``] [____]{$ans1}
+
+2. Enter [`` \frac{\pi}{2}= ``] [____]{$ans2->cmp(
+	tolType   => 'absolute',
+	tolerance => .0001,
+)}
+
+3. Enter [`` \frac{\pi}{2}= ``] [____]{$ans3}
+
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/OtherVariables.pg b/tutorial/sample-problems/problem-techniques/OtherVariables.pg
new file mode 100644
index 0000000000..16938547c1
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/OtherVariables.pg
@@ -0,0 +1,54 @@
+## DESCRIPTION
+## Add variables to the context.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('variables')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Adding Variables to the Context
+#:% type = technique
+#:% categories = [variables]
+
+#:% section = preamble
+
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: Typically you either add or set the variables for the entire problem at the
+#: top of the setup section.  In this case, we add y, z and t, all real numbers.
+#:
+#: This allows us to use a greek letter as a variable. Note that we have used
+#: add for this.  If we set this with `are`, then the other variables will be
+#: deleted upon answer checked and the student will get a `variable not defined
+#: in this context` error.
+Context()->variables->add(t => 'Real', y => 'Real', z => 'Real');
+$f = Compute('-16 t^2 + 5 t + 4');
+$g = Compute('x^2+y^2+z^2');
+
+Context()->variables->add(rho => [ 'Real', TeX => '\rho' ]);
+$h = Compute("sqrt(1+rho^2)");
+
+#:% section=statement
+BEGIN_PGML
+Enter the following formulas:
+
+* [`[$f]=`] [____]{$f}
+* [`[$g]=`] [____]{$g}
+* [`[$h]=`] [____]{$h}
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/Percent.pg b/tutorial/sample-problems/problem-techniques/Percent.pg
new file mode 100644
index 0000000000..5bbbc5d6b0
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/Percent.pg
@@ -0,0 +1,39 @@
+## DESCRIPTION
+## This demonstrates the Percent context.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('percent')
+
+#:% name = Percent Context
+#:% type = [technique]
+
+#:% section = preamble
+#: The `contextPercent.pl` must be loaded.
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextPercent.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: The `Percent` context must be loaded.
+Context('Percent');
+
+$p = random(5, 95, 5);
+
+#:% section = statement
+#: The answer can be entered with a `%` or with the work `percent`.
+BEGIN_PGML
+Enter [$p]% [__]{Real($p)}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/RandomFunction.pg b/tutorial/sample-problems/problem-techniques/RandomFunction.pg
new file mode 100644
index 0000000000..1c0b36f547
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/RandomFunction.pg
@@ -0,0 +1,53 @@
+## DESCRIPTION
+## This demonstrates how to get a random function.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2023)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('random function')
+
+#:% name = Random Function
+#:% type = [technique]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: First, there are some random numbers generated as well as an array of
+#: functions using those values.  The statement
+#: `random(0,$#funs)` generates a random number between 0 and (in this case 4,
+#: but in general 1 less than the length of the array)
+#: and then that element of the array is selected.
+# Define some random values and functions
+$a = non_zero_random(-8, 8);
+$b = random(1, 8);
+$n = random(2, 4);
+
+@funs = (
+    "1 + $a*x + $b x^2",
+    "$a / (1 + $b x)",
+    "$a x^3 + $b",
+    "($a - x) / ($b + x^2)",
+    "cos($n*x)"
+);
+
+# This select one of the functions at random.
+$f = Formula($funs[ random(0, $#funs) ])->reduce;
+
+#:% section = statement
+BEGIN_PGML
+Enter [``[$f]``] [____]{$f}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/RestrictAnswerToFraction.pg b/tutorial/sample-problems/problem-techniques/RestrictAnswerToFraction.pg
new file mode 100644
index 0000000000..742278821f
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/RestrictAnswerToFraction.pg
@@ -0,0 +1,68 @@
+## DESCRIPTION
+## Restricting answers that should reduce to a fraction.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('answer', 'fraction')
+
+#:% name = Restrict Answers to a Fraction
+#:% type = [technique, sample]
+#:% subject = [answer]
+#:% see_also = [RestrictingFunctions.pg]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'contextFraction.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Here we specify that we are using the `Fractions-NoDecimals` Context, which
+#: requires that answers be fractions and not decimals. To ensure that
+#: students do the simplification rather than typing the answer without
+#: expanding it, we undefine operators other than division (see Restricting
+#: Functions and Operators).
+#:
+#: Note that because we've undefined these operators for all MathObjects,
+#: we can't define the answer as `$frac=Compute("$b/($c + $a^2)");`.
+#: The operators + and ^ are undefined, so we don't have them available.
+#: In this case we do the calculation of the denominator using Perl first,
+#: and then use the MathObject to create the answer.
+#:
+#: Also note that by default a Fraction will be reduced to lowest terms.
+Context("Fraction-NoDecimals");
+Context()->operators->undefine('+', '-', '*', '*', '**', '^');
+
+$a    = random(2, 4);
+$b    = random(1, 9);
+$c    = random(1, 9);
+$den  = $c + $a * $a;
+$frac = Compute("$b/$den");
+$ans  = $frac->cmp(
+    studentsMustReduceFractions => 1,
+    strictFractions             => 1,
+    strictMinus                 => 1,
+    strictMultiplication        => 1
+);
+#:% section = statement
+BEGIN_PGML
+Find and simplify completely the value of
+[`f([$a])`] if [`` f(x) = \frac{[$b]}{[$c] + x^2}. ``]
+
+[`f([$a]) = `] [__]{$ans}
+
+_(Simplify your answer as much as possible, and enter a fraction instead of
+a decimal.)_
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/RestrictingFunctions.pg b/tutorial/sample-problems/problem-techniques/RestrictingFunctions.pg
new file mode 100644
index 0000000000..72758d57fb
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/RestrictingFunctions.pg
@@ -0,0 +1,44 @@
+## DESCRIPTION
+## Restricting answers that should reduce to a constant.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('answer', 'constant')
+
+#:% name = Restrict Answers to a Constant
+#:% type = [technique, sample]
+#:% subject = [answer]
+#:% see_also = [RestrictAnswerToFraction.pg]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: Here we've turned off type warnings in the answer checking, so that a
+#: student entering an un-simplified answer (e.g.,
+#: `2 sin(x) cos(x) + 2 cos(x) (-sin(x))`) will have it marked wrong
+#: (but not get feedback that says "you should have entered a number").
+$expr  = Formula("sin(x)^2 + cos(x)^2");
+$deriv = Compute(0)->cmp(showTypeWarnings => 0);
+
+#:% section = statement
+BEGIN_PGML
+Find and completely simplify:
+
+[``\frac{d}{dx}\bigl(\sin^2 x + \cos^2 x\bigr) = ``] [__]{$deriv}
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/SimplePopUp.pg b/tutorial/sample-problems/problem-techniques/SimplePopUp.pg
new file mode 100644
index 0000000000..af098659ea
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/SimplePopUp.pg
@@ -0,0 +1,64 @@
+## DESCRIPTION
+## Answers are lists of points
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Fitchburg State University)
+## Author(Peter Staab)
+## MO(1)
+## KEYWORDS('algebra', 'list of points')
+
+#:% name = Simple Popup
+#:% type = technique
+
+#:% section = preamble
+#: We need to load `parserPopUp.pl` for this feature.
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'parserPopUp.pl', 'PGcourse.pl');
+
+#:% section = setup
+#: This shows a number of ways to use either `PopUp` (the legacy version) or
+#: `DropDown` (a more flexible version).  Both create an HTML select object.
+#: The `PopUp` takes a array reference of option and the correct answer and
+#: creates the options.  Notice in `Popup` the first element is shown, but
+#: selectable, whereas in `DropDown`, the first either defaults to `?` or
+#: whatever is in the `placeholder` option.  In `Dropdown`, the first element
+#: is not selectable.
+#:
+#: Similar to other `parser` objects, inserting another array reference,
+#: randomizes those options.
+#:
+#: Lastly, the `DropDownTF` creates a true/false dropdown for simplicity.
+$popup = PopUp([ "?", "one", "two", "three" ], "three");
+
+$dropdown1 = DropDown([ 'one', 'two', 'three' ], 'two');
+$dropdown2 = DropDown([ 'one', 'two', 'three' ],
+    'one', placeholder => 'Select an option');
+$dropdown3 =
+    DropDown([ 'one', [ 'two', 'three', 'four', 'five' ], 'six' ], 'six');
+
+$tf = DropDownTF('T');
+
+#:% section = statement
+BEGIN_PGML
+
+- [_]{$popup} (ans: 'three')
+- [_]{$dropdown1} (ans: 'two')
+- [_]{$dropdown2} (ans: 'one')
+- [_]{$dropdown3} (ans: 'six')
+- [_]{$tf} (ans: 'True')
+
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+COMMENT('MathObject version. Uses PGML.');
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/StaticImages.pg b/tutorial/sample-problems/problem-techniques/StaticImages.pg
new file mode 100644
index 0000000000..c76d2c586c
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/StaticImages.pg
@@ -0,0 +1,69 @@
+## DESCRIPTION
+## Show a static image.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('parametric', 'graph')
+
+#:% name = Graphic Images, Static
+#:% types = technique
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = statement
+#: Just use the `image` macro in the main section of the
+#: problem to include the image. The images to be included should be GIF or
+#: PNG or JPG files. PNG files are recommended since they generally look
+#: better when rescaled. In order for PDF hardcopy generation to work properly,
+#: the names of image files must have only one period in them (imagename.png
+#: works but image.name.png does not). PDF files will work on hardcopy but do
+#: not immediately render in the browser without first clicking on the image
+#: box.
+#:
+#: If using PGML, the `image` command must be surrounded by the `[@ @]*` tags
+#: which calls the `image` function.  The `*` is needed to format the result
+#: correctly.  The `image` function returns HTML.
+#:
+#: For accessibility you should always add the option
+#: `extra_html_tags = 'alt_text = "..."'` describing in detail the image.
+#:
+#: For each PG problem with static images, you should put both the PG file
+#: and the image files into their own separate subdirectory. This subdirectory
+#: should be located somewhere under the course templates directory and have
+#: the same root name as the PG file. For example, if you have a PG file
+#: called `Contour-plots.pg` which uses static graphic files
+#: `Contour-plot-01.gif`and `Contour-plot-02.gif`, you should create a
+#: subdirectory somewhere under the course templates directory called
+#: `Contour-plots` and put the PG file and all the GIF files in it. Putting a
+#: PG file and all of its graphics files into their own separate subdirectory
+#: like this makes it easier to find the graphics files that go with each PG
+#: file, thereby making the problem easier to maintain. The reason for having
+#: the subdirectory and the root name of the PG file be the same is as follows.
+#: When the library is browsed via directories, the library browser in WeBWorK
+#: is configured to recognize that when a subdirectory has the same name as
+#: the root name of the only PG file in that subdirectory, the subdirectory
+#: and PG file should be treated as a single entity.
+#:
+#: We should always, of course, include options such as specifying the tex_size,
+#: etc., in this call, as shown in the including dynamic images code snippet.
+#: Taking the `tex_size => "667"` and dividing by 10 results in the percentage
+#: of the available space used by the graphic -- in this case 66.7 percent.
+#: Usually the available space is constrained by the width of one column of
+#: a two-column printed page.
+
+BEGIN_PGML
+[@ image('image.png') @]*
+
+[@ image('image.png', width => 400, tex_size => 600,
+  extra_html_tags => 'An graph of a decreasing exponential function.') @]*
+END_PGML
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/StringsInContext.pg b/tutorial/sample-problems/problem-techniques/StringsInContext.pg
new file mode 100644
index 0000000000..3248dea7b6
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/StringsInContext.pg
@@ -0,0 +1,61 @@
+## DESCRIPTION
+## Shows how to add strings to the context.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('context', 'string')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Adding Strings to a Context
+#:% type = technique
+#:% categories = [context, strings]
+#:% see_also = [StringOrOtherType.pg]
+
+#:% section = preamble
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = setup
+#:  Add the strings that are to be allowed in answers to the Context. Note that the
+#: add call has the form `string => { options }`. The most common use of options is to allow
+#: "aliases", i.e., strings that are marked the same as others, e.g.,
+#:```{.perl}
+#: Context()->strings->add(none => {}, N => { alias => "none" });
+#:```
+#: (Which would allow "N" to be used instead of "none".)
+#:
+#: By default, strings are case-insensitive. To make them case sensitive, include this
+#: as an option in the Context call.
+#:
+#: There are some shortcuts available if you need to add many allowable strings all at once.
+#: See PODLINK('parserAutoStrings.pl').
+Context()->strings->add(none => {});
+
+# or, if we wanted a case-sensitive string,
+#    we would instead use
+# Context()->strings->add(none=>{caseSensitive=>1});
+
+#:% section = statement
+#: It's usually a good idea to include some indication of what strings are expected or allowed in the answer.
+BEGIN_PGML
+Enter the positive real value of [`x`] for which [`x^2 = -2`] :
+
+[`x = `] [___]{'none'}
+
+_(Enter **none** if there are no values that satisfy the equation .) _
+END_PGML
+
+#:% section = solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/TikZImages.pg b/tutorial/sample-problems/problem-techniques/TikZImages.pg
new file mode 100644
index 0000000000..a390ee7bef
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/TikZImages.pg
@@ -0,0 +1,89 @@
+## DESCRIPTION
+## Create a graph using tikz.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(PGML tutorial 2015)
+## Date(06/01/2015)
+## Institution(Hope College)
+## Author(Paul Pearson)
+## MO(1)
+## KEYWORDS('graph', 'tikz')
+
+#:% name = Graphic Images, TikZ
+#:% types = [Sample, technique]
+#:% subject = parametric
+
+#:% section = preamble
+#: We use `PGtikz.pl` to generate the graph,
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGtikz.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: * The `createTikZImage()` function creates an image to be built using tikz.
+#: By default an `svg` image will be generated, which will generally look better
+#: than a `png` image.
+#: * In certain cases the `svg` creation methods do not give the correct output,
+#: and so in those cases a `png` image may be generated instead by adding
+#: `$graph_image->ext('png');`.
+#: * The command `\tikzset{>={Stealth[scale=1.5]}}` scales the arrows by a
+#: factor of 1.5.
+#: * The command that starts with `\filldraw` creates a nice background of
+#: the graph with contrast to the rest of the problem page.
+#: * The `$graph_image->tikzLibraries("arrows.meta");` will load the `arrows.meta`
+#: Tikz library.
+#: * The variables `$a` and `$b` are defined for use in the TikZ code that
+#: follows.  If the TikZ code references non-existent pg variables the
+#: image creation fails silently.
+#: * The actual tikz image is built between `$graph_image->BEGIN_TIKZ` and
+#: `END_TIKZ`
+$graph_image = createTikZImage();
+$graph_image->tikzLibraries("arrows.meta");
+
+# Randomization
+$a = non_zero_random(-6, 6);    # horizonatal translation
+$b = random(-4, 4);             # vertical translation
+
+$graph_image->BEGIN_TIKZ
+\tikzset{>={Stealth[scale=1.5]}}
+\filldraw[
+    draw=LightBlue,
+    fill=white,
+    rounded corners=10pt,
+    thick,use as bounding box
+] (-11.5,-11.5) rectangle (11.5,11.5);
+\draw[<->,thick] (-11,0) -- (11,0) node[above left,outer sep=4pt]{\(x\)};
+\draw[<->,thick] (0,-11) -- (0,11) node[below right,outer sep=4pt]{\(y\)};
+\foreach \x in {-10,-8,...,-2,2,4,...,10}
+	\draw[thin] (\x,5pt) -- (\x,-5pt) node[below]{\(\x\)};
+\foreach \y in {-10,-8,...,-2,2,4,...,10}
+	\draw[thin] (5pt,\y) -- (-5pt,\y) node[left]{\(\y\)};
+\draw[<->,red] plot[domain={-3.2+$a}:{3.2+$a}] (\x,{pow(\x-$a,2)+$b});
+END_TIKZ
+
+#:% section=statement
+#: This is how to insert the tikz image. Note the `width` and `tex_size`
+#: parameters can change the size of the image on the web and as hardcopy.
+#:
+#: * the `width` option is the size in pixels of the image on the screen.
+#: * the `tex_size` option is the scale factor for hardcopy where 1000 is
+#: the full width of either the page or the column.  This image will be
+#: 60% of the page width.
+#:
+#: If the problem times out then often there is a problem with the tikz
+#: commands. Troubleshooting is often needed by running the same code in
+#: a latex file and compiling it.
+BEGIN_PGML
+
+>> [@ image($graph_image, width => 400, tex_size => 600) @]* <<
+
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/WeightedGrader.pg b/tutorial/sample-problems/problem-techniques/WeightedGrader.pg
new file mode 100644
index 0000000000..e57fa63def
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/WeightedGrader.pg
@@ -0,0 +1,45 @@
+## DESCRIPTION
+## This shows how to use intervals in a problem.
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('weighted grader')
+
+# created as a full problem by Peter Staab  2023.06.02
+
+#:% name = Weighted Grader
+#:% type = [technique]
+#:% categories = [grader]
+
+#:% section = preamble
+DOCUMENT();
+loadMacros('PGstandard.pl', 'PGML.pl', 'weightedGrader.pl', 'PGcourse.pl');
+
+#:% section=setup
+#: Call `install_weighted_grader();` so that the weighted grader is used.
+install_weighted_grader();
+
+#:% section=statement
+#: Assign weights to answers by passing the `weight` via `cmp_options`.  The
+#: example here gives weights as percents that sum to 100, but weights of
+#: (2, 5, 3), (4, 10, 6), or (0.2, 0.5, 0.3) would give the same weighting.
+BEGIN_PGML
+* This answer is worth 20%.  Enter 1 [___]{1}{ cmp_options => { weight => 20 } }
+
+* This answer is worth 50%. Enter 3 [___]{3}{ cmp_options => { weight => 50 } }
+
+* This answer is worth 30%. Enter 7 [___]{7}{ cmp_options => { weight => 30 } }
+END_PGML
+
+#:% section=solution
+BEGIN_PGML_SOLUTION
+Solution explanation goes here.
+END_PGML_SOLUTION
+
+ENDDOCUMENT();
diff --git a/tutorial/sample-problems/problem-techniques/image.png b/tutorial/sample-problems/problem-techniques/image.png
new file mode 100644
index 0000000000..4b867a812a
Binary files /dev/null and b/tutorial/sample-problems/problem-techniques/image.png differ
diff --git a/tutorial/sample-problems/problem-techniques/local.html b/tutorial/sample-problems/problem-techniques/local.html
new file mode 100644
index 0000000000..de828e8fc0
--- /dev/null
+++ b/tutorial/sample-problems/problem-techniques/local.html
@@ -0,0 +1,4 @@
+<html>
+  <h1>Local File</h1>
+  <p>This is an example of a local html file.</p>
+</html>
\ No newline at end of file
diff --git a/tutorial/sample-problems/snippets/CommentsForInstructors.pg b/tutorial/sample-problems/snippets/CommentsForInstructors.pg
new file mode 100644
index 0000000000..149d99a42b
--- /dev/null
+++ b/tutorial/sample-problems/snippets/CommentsForInstructors.pg
@@ -0,0 +1,28 @@
+## DESCRIPTION
+## Shows a Comment
+## ENDDESCRIPTION
+
+## DBsubject(WeBWorK)
+## DBchapter(WeBWorK tutorial)
+## DBsection(Problem Techniques)
+## Date(06/01/2008)
+## Institution(University of Michigan)
+## Author(Gavin LaRose)
+## MO(1)
+## KEYWORDS('snippet', 'comment')
+
+# updated to full problem by Peter Staab (06/01/2023)
+
+#:% name = Comment for Instructors
+#:% type = snippet
+
+DOCUMENT();
+
+loadMacros('PGstandard.pl', 'PGML.pl', 'PGcourse.pl');
+
+#:% section = comment
+#: Include the `COMMENT();` just before the `ENDDOCUMENT();` Comments are only visible
+#: when the PG file is viewed in the Library Browser, so students will not see them.
+COMMENT('This problem is not randomized.');
+
+ENDDOCUMENT();
diff --git a/tutorial/templates/general-layout.mt b/tutorial/templates/general-layout.mt
new file mode 100644
index 0000000000..9ebfefcfea
--- /dev/null
+++ b/tutorial/templates/general-layout.mt
@@ -0,0 +1,95 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>PG Sample Problems</title>
+	<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+	<style>
+		.navbar {
+			height: 70px;
+		}
+		.main-content {
+			margin-top: 70px;
+		}
+		#sidebar {
+			--bs-offcanvas-width: 320px;
+		}
+		@media only screen and (min-width: 768px) {
+			#sidebar {
+				width: 320px;
+				height: calc(100vh - 70px);
+			}
+			.main-content {
+				margin-left: 320px;
+			}
+		}
+	</style>
+	<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js" defer></script>
+</head>
+
+<body>
+	<nav class="navbar fixed-top bg-primary border-bottom border-dark" data-bs-theme="dark">
+		<div class="container-fluid">
+			<ul class="nav nav-pills">
+				<li class="nav-item dropdown">
+					<a class="nav-link fs-3 dropdown-toggle active" href="#" role="button"
+						data-bs-toggle="dropdown" aria-expanded="false">
+						<%= $active eq 'categories' ? 'Sample Problems'
+							: $active eq 'techniques' ? 'Problem Techniques'
+							: $active eq 'subjects' ? 'Subject Area Problems'
+							: 'Problems by Macro' =%>
+					</a>
+					<ul class="dropdown-menu">
+						<li>
+							<a class="dropdown-item <%= $active eq 'categories' ? 'active' : '' %>"
+								href="categories.html" <%= $active eq 'categories' ? 'aria-current="page"' : '' %>>
+								Sample Problems
+							</a>
+						</li>
+						<li>
+							<a class="dropdown-item <%= $active eq 'techniques' ? 'active' : '' %>"
+								href="techniques.html" <%= $active eq 'techniques' ? 'aria-current="page"' : '' %>>
+								Problem Techniques
+							</a>
+						</li>
+						<li>
+							<a class="dropdown-item <%= $active eq 'subjects' ? 'active' : '' %>"
+								href="subjects.html" <%= $active eq 'subjects' ? 'aria-current="page"' : '' %>>
+								Subject Area Problems
+							</a>
+						</li>
+						<li>
+							<a class="dropdown-item <%= $active eq 'macros' ? 'active' : '' %>"
+								href="macros.html" <%= $active eq 'macros' ? 'aria-current="page"' : '' %>>
+								Problems by Macro
+							</a>
+						</li>
+					</ul>
+				</li>
+			</ul>
+			<button class="navbar-toggler d-md-none" type="button" data-bs-toggle="offcanvas"
+				data-bs-target="#sidebar" aria-controls="sidebar" aria-label="Toggle Sidebar">
+				<span class="navbar-toggler-icon"></span>
+			</button>
+		</div>
+	</nav>
+	<aside class="offcanvas-md offcanvas-start overflow-y-auto position-fixed border-end border-dark flex-shrink-0"
+		tabindex="-1" id="sidebar" aria-labelledby="sidebar-label">
+		<%= $sidebar %>
+	</aside>
+	<div class="main-content">
+		<div class="tab-content p-3">
+			<%= $main_content %>
+		</div>
+	</div>
+	<script type="module">
+		const offcanvas = bootstrap.Offcanvas.getOrCreateInstance(document.getElementById('sidebar'));
+		for (const link of document.querySelectorAll('#sidebar-list .list-group-item-action')) {
+			link.addEventListener('click', () => offcanvas.hide());
+		}
+	</script>
+</body>
+
+</html>
diff --git a/tutorial/templates/general-main.mt b/tutorial/templates/general-main.mt
new file mode 100644
index 0000000000..8a46ce2eb7
--- /dev/null
+++ b/tutorial/templates/general-main.mt
@@ -0,0 +1,27 @@
+% if ($type eq 'techniques') {
+	% for (['A' .. 'C'], ['D' .. 'F'], ['G' .. 'N'], ['O' .. 'Z']) {
+		<div class="tab-pane fade" id="<%= $_->[0] %>" role="tabpanel" aria-labelledby="<%= $_->[0] %>-tab" tabindex="0">
+			<h1 class="fs-3">Sample Problems for Techniques: <%= $_->[0] %> .. <%= $_->[-1] %></h1>
+			<ul>
+				% my $b = join('', @$_);
+				% for (sort grep { substr($_, 0, 1 ) =~ qr/^[$b]/i } keys(%$list)) {
+					<li><a href="<%= $list->{$_} =%>"><%= $_ =%></a></li>
+				% }
+			</ul>
+		</div>
+	% }
+% } else {
+	% for (sort(keys %$list)) {
+		% my %topics = (categories => 'Catetory', subjects => 'Subject', macros => 'Macro');
+		% my $id = $_ =~ s/\s/_/gr;
+		<div class="tab-pane fade" id="<%= $id %>" role="tabpanel" aria-labelledby="<%= $id %>-tab"
+			tabindex="0">
+			<h1 class="fs-3">Sample Problems for <%= $topics{$type} %>: <%= $_ %></h1>
+			<ul>
+				% for my $link (sort (keys %{$list->{$_}})) {
+					<li><a href="<%= $list->{$_}{$link} =%>"><%= $link %></a></li>
+				% }
+			</ul>
+		</div>
+	% }
+% }
diff --git a/tutorial/templates/general-sidebar.mt b/tutorial/templates/general-sidebar.mt
new file mode 100644
index 0000000000..2d89c51ee5
--- /dev/null
+++ b/tutorial/templates/general-sidebar.mt
@@ -0,0 +1,28 @@
+<div class="offcanvas-header">
+	<h2 class="offcanvas-title fs-3" id="sidebar-label"><%= $label =%></h2>
+	<button type="button" class="btn-close" data-bs-dismiss="offcanvas"
+		data-bs-target="#sidebar" aria-label="Close">
+	</button>
+</div>
+
+<h2 class="fs-3 d-none d-md-block px-3 pt-3"><%= $label =%></h2>
+<div class="offcanvas-body px-md-3 pb-md-3 w-100">
+	<div class="list-group w-100" role="tablist" id="sidebar-list">
+	  % if ($label eq 'Problem Techniques') {
+			% for (['A' .. 'C'], ['D' .. 'F'], ['G' .. 'N'], ['O' .. 'Z']) {
+			<a class="list-group-item list-group-item-action" id="<%= $_->[0] %>-tab" href="#<%= $_->[0] %>"
+				data-bs-toggle="list" role="tab" aria-controls="<%= $_->[0] %>">
+				<%= $_->[0] %> .. <%= $_->[-1] %>
+			</a>
+			% }
+		% } else {
+			% for (sort(keys %$list)) {
+				% my $id = $_ =~ s/\s/_/gr;
+				<a class="list-group-item list-group-item-action" id="<%= $id %>-tab" href="#<%= $id %>"
+					data-bs-toggle="list" role="tab" aria-controls="<%= $id %>">
+					<%= $_ %>
+				</a>
+			% }
+		% }
+	</div>
+</div>
diff --git a/tutorial/templates/problem-template.mt b/tutorial/templates/problem-template.mt
new file mode 100644
index 0000000000..5bfe05abe0
--- /dev/null
+++ b/tutorial/templates/problem-template.mt
@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title><%= $filename %></title>
+
+	<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/css/bootstrap.min.css" rel="stylesheet">
+	<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/codemirror@5.65.11/lib/codemirror.min.css">
+	<script src="https://cdn.jsdelivr.net/npm/codemirror@5.65.11/addon/runmode/runmode-standalone.min.js" defer>
+	</script>
+	<script src="<%= $pg_doc_home %>/PG.js" defer></script>
+	<link rel="stylesheet" href="<%= $pg_doc_home %>/sample-problem.css" >
+</head>
+
+% # Default explanations
+% my $default = {
+	% preamble  => 'These standard macros need to be loaded.',
+	% setup     => 'This perl code sets up the problem.',
+	% statement => 'This is the problem statement in PGML.',
+	% answer    => 'This is used for answer checking.',
+	% solution  => 'A solution should be provided here.'
+% };
+
+<body>
+	<div class="container-fluid p-3">
+		<div class="row">
+			<div class="col">
+				<h1><%= $name %></h1>
+				<p><%= $description %></p>
+			</div>
+			<div class="col text-end">
+				<a href="<%= $pg_doc_home =%>/../">Return to the PG docs home</a>
+			</div>
+		</div>
+		<div class="row">
+			<div class="col">
+				<h2>Complete Code</h2>
+				<p>
+				Download file: <a href="<%= $filename =%>"><%= $filename =%></a>
+				</p>
+			</div>
+			% if (scalar(@{$metadata->{$filename}{macros}}) > 0 ) {
+				<div class="col">
+					<h2>POD for Macro Files</h2>
+					<ul>
+						% for my $macro (@{$metadata->{$filename}{macros}}) {
+							% if ($macro_locations->{$macro}) {
+								<li><a href="<%= $pod_root %>/<%= $macro_locations->{$macro} %>"><%= $macro =%></a></li>
+							% } else {
+								<li class="text-danger"><%= $macro %></li>
+							% }
+						% }
+					</ul>
+				</div>
+				%}
+			% if ($metadata->{$filename}{related} && scalar(@{$metadata->{$filename}{related}}) > 0) {
+			<div class="col">
+				<h2>See Also</h2>
+				<ul>
+					% for (@{$metadata->{$filename}{related}}) {
+						<li><a href="<%= $pg_doc_home =%>/<%= $metadata->{$_}{dir} =%>/<%= $_ =~ s/.pg$//r =%>.html">
+							<%= $metadata->{$_}{name} =%></a></li>
+					% }
+				</ul>
+			</div>
+			% }
+		</div>
+		<div class="row">
+			<div class="col text-center"><h2 class="fw-bold fs-3">PG problem file</h2></div>
+			<div class="col text-center"><h2 class="fw-bold fs-3">Explanation</h2></div>
+		</div>
+		% for (@$blocks) {
+			<div class="row">
+				<div class="col-sm-12 col-md-6 order-md-first order-last p-0 position-relative overflow-x-hidden">
+					<button class="clipboard-btn btn btn-sm btn-secondary position-absolute top-0 end-0 me-1 mt-1 z-1"
+						type="button" data-code="<%== $_->{code} %>" aria-label="copy to clipboard">
+						<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor"
+							class="bi bi-clipboard-fill" viewBox="0 0 16 16">
+							<path fill-rule="evenodd" d="M10 1.5a.5.5 0 0 0-.5-.5h-3a.5.5 0 0 0-.5.5v1a.5.5 0 0 0 .5.5h3a.5.5 0 0 0 .5-.5v-1Zm-5 0A1.5 1.5 0 0 1 6.5 0h3A1.5 1.5 0 0 1 11 1.5v1A1.5 1.5 0 0 1 9.5 4h-3A1.5 1.5 0 0 1 5 2.5v-1Zm-2 0h1v1A2.5 2.5 0 0 0 6.5 5h3A2.5 2.5 0 0 0 12 2.5v-1h1a2 2 0 0 1 2 2V14a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V3.5a2 2 0 0 1 2-2Z"/>
+						</svg>
+					</button>
+					<pre class="CodeMirror cm-s-default m-0 h-100 p-3 border border-secondary overflow-x-scroll"><%== $_->{code} %></pre>
+				</div>
+				<div class="explanation <%= $_->{section} %> col-sm-12 col-md-6 order-md-last order-first p-3 border border-dark">
+					<p><b><%= ucfirst($_->{section}) %></b></p>
+					% if ($_->{doc}) {
+						<%= $_->{doc} %>
+					%} else {
+						<%= $default->{$_->{section}} %>
+					%}
+				</div>
+			</div>
+		% }
+	</div>
+
+	<script type="module">
+		for (const pre of document.body.querySelectorAll('pre.CodeMirror')) {
+			CodeMirror.runMode(pre.textContent, 'PG', pre);
+		}
+
+		for (const btn of document.querySelectorAll('.clipboard-btn')) {
+			if (navigator.clipboard) btn.addEventListener('click', () => navigator.clipboard.writeText(btn.dataset.code));
+			else btn?.remove();
+		}
+	</script>
+</body>
+
+</html>