% FraGoLi documentation for v. 1.1.1 y. 2025
% 
% Copyright (C) 2025 Paul Eduard Koenig
% pauleduardkoenig (at) gmail [dot] com
% Goethe University Frankfurt, Institute of Linguistics
%
% --------------------------------
%
% O))))))))                    O))))             O))         
% O))                        O)    O))           O))       O)
% O))      O) O)))   O))    O))           O))    O))         
% O))))))   O))    O))  O)) O))         O))  O)) O))      O))
% O))       O))   O))   O)) O))   O))))O))    O))O))      O))
% O))       O))   O))   O))  O))    O)  O))  O)) O))      O))
% O))      O)))     O)) O)))  O)))))      O))    O))))))))O))
% 
% --------------------------------
% 
% This file may be distributed and/or modified under the
% conditions of the LaTeX Project Public License, either
% version 1.3c of this license or (at your option) any later
% version. The latest version of this license is in:
% http://www.latex-project.org/lppl.txt
% and version 1.3c or later is part of all distributions of
% LaTeX version 2008-05-04 or later.
% 
% This work has the LPPL maintenance status `maintained'.
% The Current Maintainer of this work is Paul Eduard Koenig.
% This work consists of the files fragoli.sty and fragoli_doc.tex

\documentclass[10pt, a4paper]{article}
\usepackage{hyperref}
\usepackage[left=2.5cm, right=2.0cm, top=1cm, bottom=1cm, includeheadfoot]{geometry}
\usepackage{enumerate}
\usepackage{babel}
\usepackage[utf8]{inputenc}
\usepackage[linguistics]{forest}
\usepackage[usetypes=true]{fragoli}
\usepackage{listings}
\usepackage{showexpl}
\usepackage{expex}

\lstdefinestyle{Common}
{
	language={[LaTeX]TeX},
	numbers=left,
	numbersep=1em,
	numberstyle=\tiny,
	frame=single,
	framesep=\fboxsep,
	framerule=\fboxrule,
	rulecolor=\color{red},
	xleftmargin=\dimexpr\fboxsep+\fboxrule,
	xrightmargin=\dimexpr\fboxsep+\fboxrule,
	breaklines=true,
	breakindent=0pt,
	tabsize=2,
	columns=flexible,
	includerangemarker=false,
	rangeprefix=//\ ,
}
\lstdefinestyle{A}
{
	style=Common,
	numbers=none,
	backgroundcolor=\color{yellow!10},
	basicstyle=\scriptsize\ttfamily,
	keywordstyle=\color{blue}\bf,
	identifierstyle=\color{black},
	stringstyle=\color{red},
	commentstyle=\color{green}
}
\lstdefinestyle{B}
{
	style=Common,
	gobble=5,
	frame=none,
	backgroundcolor=\color{yellow!20},
	basicstyle=\ttfamily,
	keywordstyle=\color{blue}\bf,
	identifierstyle=\color{black},
	stringstyle=\color{red},
	commentstyle=\color{green}
}
\newenvironment{itemizeexample}{
	\begin{itemize}
		\setlength\itemsep{-.5em}
	}
	{
	\end{itemize}
}
\newenvironment{itemizeexamplecommand}{
	\begin{itemize}
		\setlength\itemsep{-0.2em}
	}
	{
	\end{itemize}
}
\newlength{\halb}				\setlength{\halb}{0.5\textwidth}				\addtolength{\halb}{-1mm}


%---------------------------------------------------------------- START --------------------------------------------

\title{\FraGoLi\\Documentation for the \LaTeX\ package \texttt{\her{fragoli}}}
\author{fragoli \textbackslash\text{v} 1.1.1\\Paul Eduard Koenig\\Goethe University Frankfurt,\\Institute of Linguistics\\\texttt{\href{mailto:pauleduardkoenig@gmail.com}{pauleduardkoenig@gmail.com}}}


\begin{document}
	\maketitle
	\begin{abstract}
		This document provides an overview of the \LaTeX\ package \texttt{fragoli} (Frankfurt Goethe Linguistic). The package is primarily designed for use in the field of semantics, offering a streamlined syntax to facilitate the rapid derivation of semantic formulae. Its notation style is loosely based on the supplementary materials accompanying the introductory course in linguistic semantics by \textit{Thomas Ede Zimmermann}.
	\end{abstract}
	\tableofcontents
	\section{Background}
	This package brings together and refines a collection of \LaTeX\ commands and concepts developed over the years within the institute of linguistics at the Goethe University Frankfurt. In the process of preparing research papers, assignments, and examinations, numerous custom \LaTeX\ headers and commands were shared within the department—some mutually compatible, others not. This package consolidates these resources into a cohesive system. Special thanks are due to \textit{Thomas Ede Zimmermann}, \textit{C\'{e}cile Meier}, \textit{Daniel Gutzmann}, and \textit{Jan Köpping}, whose files form the foundation of this package. Also thanks to \textit{Manuel Lipstein} for his feedback. 
	
	The primary goal of this package is to provide a minimal and user-friendly syntax for constructing large and complex semantic derivations, following the specific notational style used at Goethe University Frankfurt. It includes a comprehensive set of commands for text formatting and various types of bracketing, ensuring a consistent style—particularly when distinguishing between meta-language and object-language within a single derivation or formula.
	
	The semantics-specific commands in this package are organized into three categories: direct interpretation, represented using standard bracketing \\\sdi{expression}; indirect interpretation, which is further divided into translation \sit{expression} and denotation \sid{expression}. These commands offer extensive customization options and include predefined macros for commonly used constants, lambda expressions, and logical notation in formal semantics and type theory.
	
	Additionally, the package includes specialized commands and environments that extend beyond standard semantic notation. One such feature is the \textit{cps} environment, which implements a rainbow bracketing system inspired by modern programming editors and IDEs. This system assigns matching colors to parentheses at the same depth, with each level of nesting receiving a distinct color. This visual aid significantly enhances the readability of complex derivations and formulae, making them easier to process and debug. However, due to the intricate way \LaTeX\ handles command execution order, this feature currently does not integrate well with commands that generate parentheses as part of their output. While future updates may address this limitation, at present, only manually written parentheses within the \textit{cps} environment are affected by the coloring scheme. 
	As an example see: \\\verb=\begin{cps}(level1(level2(level3)(level3)))\end{cps}= which results in:  \\\begin{cps}(level1(level2(level3)(level3)))\end{cps}.
	This feature is automtically enabled in some other env. like the \textit{semcalc} framework. To change the colors one needs to manually override the colors \textit{fglcpcolor0} to \textit{fglcpcolor5} like this: \\\verb=\definecolor{fglcpcolor0}{RGB}{000, 000, 000}=.
	
	The core component of this package is the \textit{fgls} environment, which provides abbreviated versions of all commands and is designed for constructing larger semantic formulae and derivations. Given the extensive set of custom commands—ranging from one to four letters—potential conflicts with other packages may arise, so careful usage within other environments is advised.
	For example, the minimal syntax facilitated by this environment is illustrated below:
	\begin{lstlisting}[style=B]
			\begin{fgls}[\sone]
				\e{sees} = \ly\lx\n{\Mx sees \My in \cs}
			\end{fgls}
	\end{lstlisting} which renders as: \begin{fgls}[\sone]\ignorespacesafterend\e{sees} = \ly\lx\n{\Mx sees \My in \cs}\end{fgls}.
	The advantage of this syntax lies in its ability to maintain consistent formatting of variables across various levels of nesting. Previously, manually handling the font styles of variables introduced the risk of in\-con\-sis\-ten\-cies—such as losing the correct formatting (e.g., boldface for object-language variables) when copying \LaTeX\ code into new formulae. This issue is eliminated by using commands like \verb=\mx=, which consistently produces an italic, non-bold x for meta-language variables. Additionally, the use of\ \verb=\n{exp...}= ensures structural integrity, as failing to close the expression correctly now results in a compiler error, preventing unintended formatting issues. Also the optional parameter \verb=[\sone]= automatically sets the current situation for all commands inside the local \textit{fgls} env., which makes changes easy.
	
	All of this is designed to make writing large semantic formulae faster and more error pronone and ro provide beautiful and consistent output.
	\section{Examples}
	To construct a complex semantic derivation, use the \textit{semderivation} environment and introduce each derivation step with the \verb=\ds= command. Within this environment, both the \textit{cps} and \textit{fgls} environments are enabled, allowing for consistent formatting and structured derivations. The \textit{semderivation} environment internally initializes an \textit{itemize} environment, requiring each derivation step to be formatted as an item, which is automatically handled when using the \verb=\ds= command. The first step of any derivation should always use the \verb=\dS= command to omit the initial equal sign for proper formatting.\\
	A local situation can be set within the environment using \\\verb=\begin{semderivation}[situation]derivation...\end{semderivation}=, overriding all default situations in commands that include one. Additionally, a custom reference name can be assigned using \\\verb=\begin{semderivation}[situation][refName]derivation...\end{semderivation}=. \\This reference name allows for automatic referencing of each derivation step, making it possible to cite specific steps within the text. By default, references are numbered sequentially starting from 1. However, a fixed reference name can be specified for consistency across citations.
	
	To reference a specific derivation step, use:
	
	\verb=\ref{sem:deri:refName:ds:dsCount}=
	
	Here, \texttt{refName} refers either to the automatically assigned sequential derivation number or a user-defined reference name, while \texttt{dsCount} denotes the index of the derivation step, beginning at 1.
	
	Example:
	\begin{lstlisting}[style=B]
			\begin{semderivation}[\szero][exampleone]
				\dS{\e{Peter loves Maria}}
				\ds{\e{loves Maria}(\e{Peter})}
				\ds{\e{loves Maria}(Peter)}
				\ds{\e{loves}(\e{Maria})(Peter)}
				\ds{\e{loves}(Maria)(Peter)}
				\ds{\ly\lx\n{\Mx loves \My in \cs}(Maria)(Peter)}
				\ds{\lx\n{\Mx loves Maria in \cs}(Peter)}
				\ds{\n{Peter loves Maria in \cs}}
			\end{semderivation}
	\end{lstlisting} 
	results in the following derivation: \begin{semderivation}[\szero][exampleone]
		\dS{\e{Peter loves Maria}}
		\ds{\e{loves Maria}(\e{Peter})}
		\ds{\e{loves Maria}(Peter)}
		\ds{\e{loves}(\e{Maria})(Peter)}
		\ds{\e{loves}(Maria)(Peter)}
		\ds{\ly\lx\n{\Mx loves \My in \cs}(Maria)(Peter)}
		\ds{\lx\n{\Mx loves Maria in \cs}(Peter)}
		\ds{\n{Peter loves Maria in \cs}}
	\end{semderivation}
	Note that the default situation has been changed from \sstar to \szero. To ensure consistency within a derivation, it is recommended to specify the desired situation as an environment parameter and reference it within the derivation using the \verb=\cs= command, which represents the current situation. To reference a specific derivation step, use:
	\\\verb=\ref{sem:deri:exampleone:ds:3}=
	which will produce: Step \ref{sem:deri:exampleone:ds:3}.
	\\A complete semantic derivation may include not only derivation steps but also trees, rules, and lexical entries. In such cases, use the \textit{semcalc} environment, which is specifically designed for educational purposes. Each \textit{semcalc} environment should follow a standardized structure, though not all components are mandatory:
	\begin{lstlisting}[style=B]
			\begin{semcalc}
				\begin{semtree}
					tree
				\end{semtree}
				\begin{semrule}
					rules...
				\end{semrule}
				\begin{semlex}
					lexicon...
				\end{semlex}
				\begin{semderi}
					derivation...
				\end{semderi}
			\end{semcalc}
	\end{lstlisting}
	All these sub-environments function exclusively within the \textit{semcalc} or \textit{fgls} environments. A detailed ex\-pla\-na\-ti\-on of each sub-environment is provided in the section \ref{sec:semcalc}.
	\\Example for a full semantic calculation for: \sde[\stwo]{Peter sleeps}
	\begin{lstlisting}[style=B]
			\begin{semcalc}[\stwo]
				\begin{semtreesem}
					\begin{forest}
					[{\e{Peter sleeps}\\S:\typet},name=0
					[{\e{Peter}\\NN:\typee},name=00]
					[{\e{sleeps}\\V:\typeet},name=01]
					]
					\end{forest}
				\end{semtreesem}
				\begin{semlang}
					\rlang{Peter, sleeps}[NN][VP]
				\end{semlang}
				\begin{semrule}
					\rsrdesbjpred
					\rentrysub{\j{Compositional Determination of the Extension of Subject-Predications}\\If \j{S} is a sentence with a predicate \j{P} and a proper name \j{NN} as its subject, then for all \j{s\ \ci\ LR} the above holds.}
				\end{semrule}
				\begin{semlex}
					\sldenn{Peter}
					\sldex{sleeps}
				\end{semlex}
				\begin{semderi}
					\dS{\e{Peter sleeps}}
					\ds[\rr{1}]{\e{sleeps}(\e{Peter})}
					\ds[\rl{1}]{\e{sleeps}(Peter)}
					\ds[\rl{2}]{\lfx{sleeps}(Peter)}
					\ds[\lc]{\n{Peter sleeps in \cs}}
				\end{semderi}
			\end{semcalc}
	\end{lstlisting}
	The code above will result in the following derivation structure:
	\begin{semcalc}[\stwo]
		\begin{semtreesem}
			\begin{forest}
				[{\e{Peter sleeps}\\S:\typet},name=0
				[{\e{Peter}\\NN:\typee},name=00]
				[{\e{sleeps}\\V:\typeet},name=01]
				]
			\end{forest}
		\end{semtreesem}
		\begin{semlang}
			\rlang{Peter, sleeps}[NN][VP]
		\end{semlang}
		\begin{semrule}
			\rsrdesbjpred
			\rentrysub{\j{Compositional Determination of the Extension of Subject-Predications}\\If \j{S} is a sentence with a predicate \j{P} and a proper name \j{NN} as its subject, then for all \j{s\ \ci\ LR} the above holds.}
		\end{semrule}
		\begin{semlex}
			\sldenn{Peter}
			\sldex{sleeps}
		\end{semlex}
		\begin{semderi}
			\dS{\e{Peter sleeps}}
			\ds[\rr{1}]{\e{sleeps}(\e{Peter})}
			\ds[\rl{1}]{\e{sleeps}(Peter)}
			\ds[\rl{2}]{\lfx{sleeps}(Peter)}
			\ds[\lc]{\n{Peter sleeps in \cs}}
		\end{semderi}
	\end{semcalc}
	As shown on the right, each step references the corresponding rule or lexical entry to indicate to the reader which resource was used to reach the next step. These resources can also be referenced outside of the \textit{semderivation} environment using the command \verb=\ref{sem:deri:refNameresCoderesNumber}=, where \texttt{refName} refers to the derivation reference name (as explained earlier), \texttt{resNumber} is the index of the desired resource (starting from 1), and \texttt{resCode} specifies the kind of resource. There are four types of resource codes: \texttt{r}, \texttt{rs}, \texttt{l}, and \texttt{la}, which stand for resource, resource-syntax, lexicon, and language, respectively. For further details, see Command \ref{command:resourceCounter}.
	\\
	An additional example of a more complex derivation involving indirect interpretation would look like this:
	\begin{lstlisting}[style=B]
			\begin{semderivation}
				\dS{\e[g,\!\cs]{\r[S]{\r[DP]{jeden Esel}\r[S]{\lx\r[S]{Hans \r[VP]{\tx\ f\"{u}tterte}}}}}}
				\ds[\fa]{\e{jeden Esel}(\e[g,\!\cs]{\lx\r[S]{Hans \r[VP]{\tx\ f\"{u}tterte}}})}
				\ds[\abs]{\e{jeden Esel}(\lz\e[g{\asmoD{z}[x]},\!\cs]{Hans \r[VP]{\tx\ f\"{u}tterte}})}
				\ds[\fa]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r[VP]{\tx\ f\"{u}tterte}}(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
				\ds[\fa]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r{f\"{u}tterte}}(\e[g{\asmoD{z}[x]},\cs]{\tx})(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
				\ds[SemVar]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r{f\"{u}tterte}}(\mz)(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
				\ds[\lex]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r{f\"{u}tterte}}(\mz)(Hans)})}
				\ds[\lex]{\e{jeden Esel}(\lz\r{\ly\lx\n{\mx\ f\"{u}tterte \my\ in \cs}(\mz)(Hans)})}
				\ds[\lc]{\e{jeden Esel}(\lz\r{\lx\n{\mx\ f\"{u}tterte \mz\ in \cs}(Hans)})}
				\ds[\lc]{\e{jeden Esel}(\lz\n{Hans f\"{u}tterte \mz\ in \cs})}
				\ds[\lex]{\lX\n{\sa\e{Esel} $\subseteq$ \sa\mX}(\lz\n{Hans f\"{u}tterte \mz\ in \cs})}
				\ds[\lc]{\n{\sa\e{Esel} $\subseteq$ \sA{\lz\n{Hans f\"{u}tterte \mz\ in \cs}}}}
				\ds[\lex]{\n{\sA{\lx\n{\mx\ ist ein Esel in \cs}} $\subseteq$ \sA{\lz\n{Hans f\"{u}tterte \mz\ in \cs}}}}
				\ds[Def. \cd]{\n{\s{\Sv ist ein Esel in \cs} $\subseteq$ \s{Hans f\"{u}tterte \Sv in \cs}}}
				\ds[\nc]{\n{\cset{Esel} $\subseteq$ \s{Hans f\"{u}tterte \Sv in \cs}}}
				\ds{1 gdw. alle Individuen, die Esel sind in \cs\ auch Individuen sind, die von Hans in \cs\ gef\"{u}ttert werden, sonst 0.}
			\end{semderivation}
	\end{lstlisting}
	which would result in a derivation that looks like this (derivation for \textit{Hans fed every donkey} with quantifier raising):
	\begin{semderivation}
		\dS{\e[g,\!\cs]{\r[S]{\r[DP]{jeden Esel}\r[S]{\lx\r[S]{Hans \r[VP]{\tx\ fütterte}}}}}}
		\ds[\fa]{\e{jeden Esel}(\e[g,\!\cs]{\lx\r[S]{Hans \r[VP]{\tx\ fütterte}}})}
		\ds[\abs]{\e{jeden Esel}(\lz\e[g{\asmoD{z}[x]},\!\cs]{Hans \r[VP]{\tx\ fütterte}})}
		\ds[\fa]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r[VP]{\tx\ fütterte}}(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
		\ds[\fa]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r{fütterte}}(\e[g{\asmoD{z}[x]},\cs]{\tx})(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
		\ds[SemVar]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r{fütterte}}(\mz)(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
		\ds[\lex]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r{fütterte}}(\mz)(Hans)})}
		\ds[\lex]{\e{jeden Esel}(\lz\r{\ly\lx\n{\mx\ fütterte \my\ in \cs}(\mz)(Hans)})}
		\ds[\lc]{\e{jeden Esel}(\lz\r{\lx\n{\mx\ fütterte \mz\ in \cs}(Hans)})}
		\ds[\lc]{\e{jeden Esel}(\lz\n{Hans fütterte \mz\ in \cs})}
		\ds[\lex]{\lX\n{\sa\e{Esel} $\subseteq$ \sa\mX}(\lz\n{Hans fütterte \mz\ in \cs})}
		\ds[\lc]{\n{\sa\e{Esel} $\subseteq$ \sA{\lz\n{Hans fütterte \mz\ in \cs}}}}
		\ds[\lex]{\n{\sA{\lx\n{\mx\ ist ein Esel in \cs}} $\subseteq$ \sA{\lz\n{Hans fütterte \mz\ in \cs}}}}
		\ds[Def. \cd]{\n{\s{\Sv ist ein Esel in \cs} $\subseteq$ \s{Hans fütterte \Sv in \cs}}}
		\ds[\nc]{\n{\cset{Esel} $\subseteq$ \s{Hans fütterte \Sv in \cs}}}
		\ds{1 gdw. alle Individuen, die Esel sind in \cs\ auch Individuen sind, die von Hans in \cs\ gefüttert werden, sonst 0.}
	\end{semderivation}
	Note that the comments on the right should signal the reader which rule or lexical entry or notational convention has been used to get to the next step.
	\section{Usage}
	To use the \texttt{\her{fragoli}} package place the \her{fragoli.sty} file in the same folder as your document and include:
	\begin{lstlisting}[style=A]
			\usepackage{fragoli}
	\end{lstlisting}
	\subsection{Package Options}
	To combine multiple package options use \her{, } like:
	\begin{lstlisting}[style=A]
			\usepackage[userainbow=true, language=german]{fragoli}
	\end{lstlisting}
	\subsubsection{language}
	\begin{lstlisting}[style=A]
			\usepackage[language=LANGUAGE]{fragoli}
	\end{lstlisting}
	This option will effect the default lexicon and rule entries as well as the labels for a semantic derivation. The default ist set to \texttt{\her{english}}, valid options are:
	\begin{itemizeexample}
		\item[-] english (e.g. R1: \sit{Every-} = \lambH{Q}(\lambH{P}\lambheN\lambbY{\sand{\obli{Q}(\obli{x})}{\obli{P}(\obli{x})}}))
		\item[-] german (e.g. R1: \sit{Jed-} = \lambH{Q}(\lambH{P}\lambheN\lambbY{\sand{\obli{Q}(\obli{x})}{\obli{P}(\obli{x})}}))
	\end{itemizeexample}
	\subsubsection{userainbow}
	\begin{lstlisting}[style=A]
			\usepackage[userainbow=BOOL]{fragoli}
	\end{lstlisting}
	This option will effect the automatic coloring of parentheses levels within a semantic derivation or the \textit{cps} environment. The default is set to \texttt{\her{true}}, valid options are true/false. To change the colors one needs to manually override the color values \textit{fglcpcolor0} to \textit{fglcpcolor5} like this: \\\verb=\definecolor{fglcpcolor0}{RGB}{000, 000, 000}=.
	\begin{itemizeexample}
		\item[-] true (e.g. \begin{cps}(level0(level1((level3(level4(level5(level6))))level2)))\end{cps})
		\item[-] false (e.g. (level0(level1((level3(level4(level5(level6))))level2))))
	\end{itemizeexample}
	\subsubsection{usetypes}
	\begin{lstlisting}[style=A]
			\usepackage[usetypes=BOOL]{fragoli}
	\end{lstlisting}
	This option will effect if the default types in lexicon and rule entries are displayed. The default ist set to \texttt{\her{false}}, valid options are true/false.
	\begin{itemizeexample}
		\item[-] true (e.g. R1: \sit{Every-} = \lambH{Q}[\type{et}](\lambH{P}[\type{et}]\lambhen[x][\type{e}]\lambbY{\sand{\obli{Q}(\obli{x})}{\obli{P}(\obli{x})}}))
		\item[-] false (e.g. R1: \sit{Every-} = \lambH{Q}(\lambH{P}$\neg$($\exists$$x$)\lambbY{\sand{\obli{Q}(\obli{x})}{\obli{P}(\obli{x})}}))
	\end{itemizeexample}
	\subsubsection{typestyle}
	\begin{lstlisting}[style=A]
			\usepackage[typestyle=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default parentheses style of all types added with the \verb=\type{#1}= command. The default ist set to \texttt{\her{normal}}, valid options are:
	\begin{itemizeexample}
		\item[-] normal (e.g. $\langle$$et$$\rangle$)
		\item[-] classic (e.g. ($et$))
		\item[-] alternative (e.g. $<$$et$$>$)
	\end{itemizeexample}
	\subsubsection{lambdaheadstyle}
	\begin{lstlisting}[style=A]
			\usepackage[lambdaheadstyle=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default type positioning/style of all lambda heads when adding a type as argument. The default ist set to \texttt{\her{normal}}, valid options are:
	\begin{itemizeexample}
		\item[-] normal (e.g. $\lambda$\obli{Q}\textsubscript{\type{et}}\!.)
		\item[-] domain (e.g. $\lambda$\obli{Q} $\in$ D\textsubscript{\type{et}}\!.)
		\item[-] upper (e.g. $\lambda$\obli{Q}\textsuperscript{\type{et}}\!.)
	\end{itemizeexample}
	\subsubsection{usedscount}
	\begin{lstlisting}[style=A]
			\usepackage[usedscount=BOOL]{fragoli}
	\end{lstlisting}
	This option will effect if the row count will be displayed in every semantic derivation step in the \textit{semderivation} and \textit{semderi} environments. The default ist set to \texttt{\her{true}}, valid options are true/false. To change the color one needs to manually override the color value like this: \\\verb=\definecolor{fgldeivationrowcountcolor}{RGB}{000, 000, 000}=.
	\begin{center}
		\begin{minipage}[h][2cm][t]{15em}
			true:\begin{itemizeexample}
				\item[] \lambh{x}\lambbY{$x$+2}(2)
				\item[$\stackrel{\color{fgldeivationrowcountcolor}2.\color{black}}{=}$] 2+2
				\item[$\stackrel{\color{fgldeivationrowcountcolor}3.\color{black}}{=}$] 4
			\end{itemizeexample}
		\end{minipage}
		\begin{minipage}[h][2cm][t]{15em}
			false:\begin{itemizeexample}
				\item[] \lambh{x}\lambbY{$x$+2}(2)
				\item[=] 2+2
				\item[=] 4
			\end{itemizeexample}
		\end{minipage}
	\end{center}
	\subsubsection{showawnser}
	\begin{lstlisting}[style=A]
			\usepackage[showawnser=BOOL]{fragoli}
	\end{lstlisting}
	This option will effect the question and awnser environments. If set to true everything written within a question environment will be colored light grey and look like this: \color{fglquestioncolor}example text\color{black}\ and everything written within an awnser environment will be visible. If set to false every awnser environment will be hidden and the question env. content will be colored black. To change the color one needs to manually override the color value like this: \verb=\definecolor{fglquestioncolor}{RGB}{000, 000, 000}=.
	\subsubsection{rulesituation}
	\begin{lstlisting}[style=A]
			\usepackage[rulesituation=SITUATION]{fragoli}
	\end{lstlisting}
	This option will effect every predefined semantic rule resource (NOT the lexical entries or the default situation within the fgls env.). By default the situation displayed will be $s$. Note that every predefined rule can be customized individually again.
	\subsubsection{situation}
	\begin{lstlisting}[style=A]
			\usepackage[situation=SITUATION]{fragoli}
	\end{lstlisting}
	This option will effect every predefined situation (EXCEPT for all the predefined rules). By default the situation displayed will be \sstar. Note that every predefined situation can be customized individually again. This will effect for example every command that contains a situation and also every shortcut in the \textit{fgls} environment, also every predefined lexical entry and all other occurences of situations.
	\section{Commands}
	Most commands in this package have two versions, one normal and one bold version. For the bold version just write the last letter in uppercase (except for a few commands).
	\subsection{Text}
	This section lists commands modifying the appearance of text.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\oo{text}[height]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to overline
					\item[] \texttt{height}(def=-2ex): Set the overlining height
				\end{itemizeexamplecommand}
				\item[] Description: Double overlining (that works with line breaks)
				\item[] Example: \oo{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\oO{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to overline
				\end{itemizeexamplecommand}
				\item[] Description: Double overlining (that works with line breaks) with more space (-2.5ex)
				\item[] Example: \oO{Test}}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Object Language}
	Marks text as object language in opposition to meta language.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\obl{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to format
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as object language
				\item[] Example: \obl{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\obli{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to format
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as object language italic
				\item[] Example: \obli{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\obla{arg}[arg2][arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: First argument
					\item[] \texttt{argN}: nth argument
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as object language arguments with up to 8 optional arguments in normal parentheses behind the first argument
				\item[] Example: \obla{arg}[optional1][optional2]}...
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\oblia{arg}[arg2][arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: First argument
					\item[] \texttt{argN}: nth argument
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as object language italic arguments with up to 8 optional arguments in normal parentheses behind the first argument
				\item[] Example: \oblia{arg}[optional1][optional2]}...
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Meta Language}
	Marks text as meta language in opposition to object language. Used to ensure text is not formatted in a chain of commands.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\mel{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to format
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as meta language
				\item[] Example: \mel{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\meli{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to format
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as meta language italic
				\item[] Example: \meli{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\mela{arg}[arg2][arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: First argument
					\item[] \texttt{argN}: nth argument
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as meta language arguments with up to 8 optional arguments in normal parentheses behind the first argument
				\item[] Bold Option: Yes
				\item[] Example: \mela{arg}[optional1][optional2]}...
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\melia{arg}[arg2][arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: First argument
					\item[] \texttt{argN}: nth argument
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as meta language italic arguments with up to 8 optional arguments in normal parentheses behind the first argument
				\item[] Bold Option: Yes
				\item[] Example: \melia{arg}[optional1][optional2]}...
		\end{itemizeexamplecommand}
	\xe
	\subsection{Bracketing}
	This section lists general text bracketing commands.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\set[var]{properties}[name]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}(def=x): Varibale name and/or domain specifier
					\item[] \texttt{properties}: Set-builder notation
					\item[] \texttt{var}(def=): The name of the set
				\end{itemizeexamplecommand}
				\item[] Description: Creating an inensional build set. Each use of this command will override the \verb=\setvar= command. This command should be used inside the set properties to reference the set variable. The reference will always cut the content of the optional \textit{var} argument before the first space character. Use \verb=\Setvar= to automatically add a space behind the command. To change the style of the set from : to e.g. $|$ replace the \verb=\@fglsetspacer= constant using \verb=\newcommand{\@fglsetspacer}{$|$}=.
				\item[] Bold Option: Yes
				\item[] Example: \verb=\set[n \in \mathbb{N}]{\Setvar is even}[A]= will result in: \set[n \in \mathbb{N}]{\Setvar is even}[A]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\bool{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text inside truth brackets
				\end{itemizeexamplecommand}
				\item[] Description: Creating truth conditional bracketing.
				\item[] Bold Option: Yes
				\item[] Example: \bool{it rains in \sstar}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambby[subInner][subOuter]{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{subInner}: Optional subscript behind opening bracket. Text will be in mathmode. (mostly used in tree like structures)
					\item[] \texttt{subOuter}: Optional subscript behind closing bracket. Text will be in mathmode (mostly used to identify types)
					\item[] \texttt{text}: Text inside rectangle brackets 
				\end{itemizeexamplecommand}
				\item[] Description: Creating rectangle brackets, mainly used for a lambda function body.
				\item[] Bold Option: Yes
				\item[] Example: \lambbY{P $\land$ Q}
				\item[] Example: \lambbY[Inner][Outer]{P $\land$ Q}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\zit{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text inside double quotation marks
				\end{itemizeexamplecommand}
				\item[] Description: Creating double quotation marks around passed text.
				\item[] Bold Option: No
				\item[] Example: \zit{Autounfall}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\her{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text inside single quotation marks
				\end{itemizeexamplecommand}
				\item[] Description: Creating single quotation marks around passed text.
				\item[] Bold Option: No
				\item[] Example: \her{Autounfall}}
		\end{itemizeexamplecommand}
	\xe
	\subsection{Logic}
	This section covers commands for logic symbols modified for semantic purposes.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sneg
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a negation symbol.
				\item[] Bold Option: Yes
				\item[] Example: \sneg}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\strue
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a verum symbol.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \strue}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sfalse
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a falsum symbol.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \sfalse}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\snec
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a necessity symbol.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \snec}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sposs
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a possible symbol.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \sposs}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\simp{arg1}{arg2}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: Antecedent.
					\item[] \texttt{arg2}: Consequent.
				\end{itemizeexamplecommand}
				\item[] Description: Creating a material implication.
				\item[] Bold Option: Yes
				\item[] Example: \simp{a}{b}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\simpnc{arg1}{arg2}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: Antecedent.
					\item[] \texttt{arg2}: Consequent.
				\end{itemizeexamplecommand}
				\item[] Description: Creating a material implication but without the notational convention.
				\item[] Bold Option: Yes
				\item[] Example: \simpnc{a}{b}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sor{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st disjunct
					\item[] \texttt{arg2}: 2nd disjunct
					\item[] \texttt{argN}: nth disjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a disjunctive formula with min. 2 disjuncts.
				\item[] Bold Option: Yes
				\item[] Example: \sor{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sornc{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st disjunct
					\item[] \texttt{arg2}: 2nd disjunct
					\item[] \texttt{argN}: nth disjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a disjunctive formula with min. 2 disjuncts but without the notational convention.
				\item[] Bold Option: Yes
				\item[] Example: \sornc{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sxor{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st disjunct
					\item[] \texttt{arg2}: 2nd disjunct
					\item[] \texttt{argN}: nth disjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating an exclusive disjunctive formula with min. 2 disjuncts.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \sxor{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sxornc{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st disjunct
					\item[] \texttt{arg2}: 2nd disjunct
					\item[] \texttt{argN}: nth disjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating an exclusive disjunctive formula with min. 2 disjuncts but without the notational convention.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \sxornc{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sand{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st conjunct
					\item[] \texttt{arg2}: 2nd conjunct
					\item[] \texttt{argN}: nth conjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a conjunctive formula with min. 2 conjuncts.
				\item[] Bold Option: Yes
				\item[] Example: \sand{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sandnc{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st conjunct
					\item[] \texttt{arg2}: 2nd conjunct
					\item[] \texttt{argN}: nth conjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a conjunctive formula with min. 2 conjuncts but without the notational convention.
				\item[] Bold Option: Yes
				\item[] Example: \sandnc{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\slogic{symbol}{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{symbol}: the junctor symbol (math mode is enforced)
					\item[] \texttt{arg1}: 1st conjunct
					\item[] \texttt{arg2}: 2nd conjunct
					\item[] \texttt{argN}: nth conjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a blank formula with min. 2 arguments.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \verb=\slogic{\oplus}{a}{b}= will result in: \slogic{\oplus}{a}{b}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\slogicnc{symbol}{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{symbol}: the junctor symbol (math mode is enforced)
					\item[] \texttt{arg1}: 1st conjunct
					\item[] \texttt{arg2}: 2nd conjunct
					\item[] \texttt{argN}: nth conjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a blank formula with min. 2 arguments but without the general notational convention.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \verb=\slogicnc{\oplus}{a}{b}}= will result in:  \slogicnc{\oplus}{a}{b}}
		\end{itemizeexamplecommand}
	\xe
	\subsection{Lambda}
	This section covers commands for creating lambda functions.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfx{body}[headVar][headType]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar(def=x)}: lambda head variable
					\item[] \texttt{headType}: head variable type
				\end{itemizeexamplecommand}
				\item[] Description: Creats a full lambda function with changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfx{\textit{x} sleeps in \sstar}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfyx{body}[headVar1][headVar2][headType1][headType2]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar1(def=y)}: first lambda head variable
					\item[] \texttt{headVar2(def=x)}: second lambda head variable
					\item[] \texttt{headType1}: first head variable type
					\item[] \texttt{headType2}: second head variable type
				\end{itemizeexamplecommand}
				\item[] Description: Creats a full lambda function with two changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfyx{\textit{x} kills \textit{y} in \sstar}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfzyx{body}[headVar1][headVar2][headVar3][headType1][headType2][headType3]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar1(def=z)}: first lambda head variable
					\item[] \texttt{headVar2(def=y)}: second lambda head variable
					\item[] \texttt{headVar3(def=x)}: third lambda head variable
					\item[] \texttt{headType1}: first head variable type
					\item[] \texttt{headType2}: second head variable type
					\item[] \texttt{headType3}: third head variable type
				\end{itemizeexamplecommand}
				\item[] Description: Creats a full lambda function with three changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfzyx{\textit{x} gives \textit{y} \textit{z} in \sstar}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfsx{body}[headVar][situationVar][headType][situationType]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar(def=x)}: lambda head variable
					\item[] \texttt{situationVar(def=s)}: lambda head variable for the situation
					\item[] \texttt{headType}: head variable type
					\item[] \texttt{situationType}: situation type (should be used if you want to display the type)
				\end{itemizeexamplecommand}
				\item[] Description: Creats a full lambda function with changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfsx{\textit{x} sleeps in \sblank}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfsyx{body}[headVar1][headVar2][situationVar][headType1][headType2][situationType]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar1(def=y)}: first lambda head variable
					\item[] \texttt{headVar2(def=x)}: second lambda head variable
					\item[] \texttt{situationVar(def=s)}: lambda head variable for the situation
					\item[] \texttt{headType1}: first head variable type
					\item[] \texttt{headType2}: second head variable type
					\item[] \texttt{situationType}: situation type (should be used if you want to display the type)
				\end{itemizeexamplecommand}
				\item[] Description: Creats a full lambda function with two changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfsyx{\textit{x} kills \textit{y} in \sblank}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfszyx{body}[headVar1][headVar2][headVar3][situationVar][headType1][headType2][headType3][situationType]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar1(def=z)}: first lambda head variable
					\item[] \texttt{headVar2(def=y)}: second lambda head variable
					\item[] \texttt{headVar3(def=x)}: third lambda head variable
					\item[] \texttt{situationVar(def=s)}: lambda head variable for the situation
					\item[] \texttt{headType1}: first head variable type
					\item[] \texttt{headType2}: second head variable type
					\item[] \texttt{headType3}: third head variable type
					\item[] \texttt{situationType}: situation type (should be used if you want to display the type)
				\end{itemizeexamplecommand}
				\item[] Description: Creats a full lambda function with three changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfszyx{\textit{x} gives \textit{y}\textit{z} in \sblank}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambh{var}[type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambh{x}[\type{e}]
				\item[] Example: \lambH{x}[\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhe[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating an existential head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambhe[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhen[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a negated existential head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambhen[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhu[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a uniqueness head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \lambhu[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhun[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a negated uniqueness head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \lambhun[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambha[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a universal head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambha[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhan[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a negated universal head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambhan[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	
	\subsection{Semantics}
	General semantics commands.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\type{type}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{type}: the type (e.g. et)
				\end{itemizeexamplecommand}
				\item[] Description: Creating a type. Should max consist of two letters or nested type functions.
				\item[] Bold Option: No
				\item[] Example: \verb=\type{e\type{et}}= = \type{e\type{et}} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sarg{index}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{index}: the situation index
				\end{itemizeexamplecommand}
				\item[] Description: Creating a situation variable with an index.
				\item[] Bold Option: Yes (uppercase r results in superscript indexing)
				\item[] Example: \sarg{5} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\trace{variable}[traceSymbol]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{variable}: the variable for which the trace is for
					\item[] \texttt{traceSymbol (def=\textit{t})}: the trace symbol
				\end{itemizeexamplecommand}
				\item[] Description: Creates a trace with a given variable.
				\item[] Bold Option: Yes 
				\item[] Example: \trace{x}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sarrow{function}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{variable}: the characteristic function.
				\end{itemizeexamplecommand}
				\item[] Description: Creates a downarrow and puts the function behind it without space.
				\item[] Bold Option: Yes (will put everything behind arrow in square brackets)
				\item[] Example: \sarrow{\sde{sleeps}}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\cset{function}[argument][situation]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{variable}: the characteristic set.
					\item[] \texttt{argument(def=)}: optional specifier argument.
					\item[] \texttt{situation(def=\sstar)}: the situation argument.
				\end{itemizeexamplecommand}
				\item[] Description: Creates a set.
				\item[] Bold Option: No
				\item[] Example: \verb=\cset{Kills}[Peter]= will create the set of every person that got killed by Peter in the situation \sstar, which will look like this: \cset{Kills}[Peter]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\func[name]{domain1}{range1}[domain2][range2][domain3][range3][domain4][range4]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: the optional function name.
					\item[] \texttt{domain1}: the first domain.
					\item[] \texttt{range1}: the first range.
					\item[] \texttt{domain2}: the optional second domain.
					\item[] \texttt{range2}: the optional second range.
					\item[] \texttt{domain3}: the optional third domain.
					\item[] \texttt{range3}: the optional third range.
					\item[] \texttt{domain4}: the optional fourth domain.
					\item[] \texttt{range4}: the optional fourth range.
				\end{itemizeexamplecommand}
				\item[] Description: Creates a function in array notation. This command can be nested. It is a \her{quick and dirty} version of the \textit{fglfunc} environment and should only be used for small functions. Problems regarding vertical spacing can arise when creating bigger functions via nesting, in that case use Environment \ref{env:fglfunc} and change the spacing parameter.
				\item[] Since: 1.1.1
				\item[] Example: \verb=\func[A]{\szero}{B}[\sone][C][\stwo][D]= will create:\\\func[A]{\szero}{B}[\sone][C][\stwo][D]
				\item[] Example: \verb=\func[B]{a}{1}[b][1][c][\func{x}{1}[y][2][x][3]]= will create:\\\func[B]{a}{1}[b][1][c][\func{x}{1}[y][2][x][3]]}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Direct Interpretation}
	This section covers commands for direct semantic interpretation.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sdi{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to interpret.
				\end{itemizeexamplecommand}
				\item[] Description: Creatin double square bracketing for an object language expression without a situation argument.
				\item[] Bold Option: Yes
				\item[] Example: \sdi{sleeps} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sdim{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to interpret.
				\end{itemizeexamplecommand}
				\item[] Description: Creatin double square bracketing for a meta language expression without a situation argument.
				\item[] Bold Option: Yes
				\item[] Example: \sdim{sleeps} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sde[situation]{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: the situation argument.
					\item[] \texttt{expression}: the expression to interpret.
				\end{itemizeexamplecommand}
				\item[] Description: Creatin double square bracketing for an object language expression with a situation argument.
				\item[] Bold Option: Yes
				\item[] Example: \sde{sleeps} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sdem[situation]{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: the situation argument.
					\item[] \texttt{expression}: the expression to interpret.
				\end{itemizeexamplecommand}
				\item[] Description: Creatin double square bracketing for a meta language expression with a situation argument.
				\item[] Bold Option: Yes
				\item[] Example: \sdem{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Indirect Interpretation}
	This section covers commands for indirect semantic interpretation.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sic[situation]{constant}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\textit{i})}: the situation argument.
					\item[] \texttt{constant}: the function abriviation.
				\end{itemizeexamplecommand}
				\item[] Description: Makes constant italic and adds an argument in the subscript.
				\item[] Bold Option: No (uppercase removes notational convention of subscript)
				\item[] Example: \sic{Q}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sicn[situation]{constant}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\textit{i})}: the situation argument.
					\item[] \texttt{constant}: the function abriviation.
				\end{itemizeexamplecommand}
				\item[] Description: Makes negated constant italic and adds an argument in the subscript.
				\item[] Bold Option: Yes (c uppercase removes notational convention of subscript)
				\item[] Example: \sicn{Q}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sit{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to translate.
				\end{itemizeexamplecommand}
				\item[] Description: Creats single bar bracketing for indirect translation of an expression.
				\item[] Bold Option: Yes
				\item[] Example: \sit{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sitnobf{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to translate.
				\end{itemizeexamplecommand}
				\item[] Description: Creats single bar bracketing for indirect translation of an expression but without making the expression bold.
				\item[] Bold Option: Yes
				\item[] Example: \sitnobf{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sitnobfi{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to translate.
				\end{itemizeexamplecommand}
				\item[] Description: Creats single bar bracketing for indirect translation of an expression but making it italic and not bold.
				\item[] Bold Option: Yes
				\item[] Example: \sitnobfi{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sid[assignment]{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{assignment}: the assignment function.
					\item[] \texttt{expression}: the expression to denote.
				\end{itemizeexamplecommand}
				\item[] Description: Creats double bar bracketing for indirect denotation of an expression with optional assignment function.
				\item[] Bold Option: Yes
				\item[] Example: \sid{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidg[assignmentReplacement]{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{assignmentReplacement}: will be written behind the g.
					\item[] \texttt{expression}: the expression to denote.
				\end{itemizeexamplecommand}
				\item[] Description: Creats double bar bracketing for indirect denotation of an expression with \textit{g} a assignment function.
				\item[] Bold Option: Yes
				\item[] Example: \sidg{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\asmod{replacement}[original]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{replacement}: the new variable to replace the original
					\item[] \texttt{original(def=x)}: the variable to be replaced
				\end{itemizeexamplecommand}
				\item[] Description: Creates an assignment function with a replacement.
				\item[] Bold Option: Yes
				\item[] Example: \asmod{r}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\asf{arg}[replacement1][original1][replacement2][original2][replacement3][original3][assignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: argument to be assigned.
					\item[] \texttt{replacement1}: the new variable to replace the original
					\item[] \texttt{original1(def=x)}: the variable to be replaced
					\item[] \texttt{replacement2}: the new variable to replace the original
					\item[] \texttt{original2(def=y)}: the variable to be replaced
					\item[] \texttt{replacement3}: the new variable to replace the original
					\item[] \texttt{original3(def=z)}: the variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
				\end{itemizeexamplecommand}
				\item[] Description: Applies an argument to an assignment function and 3 optional replacement spots.
				\item[] Bold Option: Yes
				\item[] Example: \asf{p}[r][x]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidmod{expression}{replacement1}[original1][replacement2][original2][replacement3][original3][assignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to denote.
					\item[] \texttt{replacement1}: the new variable to replace the original
					\item[] \texttt{original1(def=x)}: the variable to be replaced
					\item[] \texttt{replacement2}: the new variable to replace the original
					\item[] \texttt{original2(def=y)}: the variable to be replaced
					\item[] \texttt{replacement3}: the new variable to replace the original
					\item[] \texttt{original3(def=z)}: the variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
				\end{itemizeexamplecommand}
				\item[] Description: Creats double bar bracketing for indirect denotation of an expression with \textit{g} as assignment function and 3 optional replacement spots. More specified versions of this function are
				\item[] Bold Option: Yes (case of d switches bracketing from bold to normal; case of o switches case of original variable from bold to normal)
				\item[] Example: \sidmod{test}{r}[x][b][u][h]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidr{expression}{replacement}[original][assignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to denote.
					\item[] \texttt{replacement}: the new variable to replace the original
					\item[] \texttt{original(def=x)}: the variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
				\end{itemizeexamplecommand}
				\item[] Description: Creats double bar bracketing for indirect denotation of an expression with \textit{g} as assignment function and a replacement spot.
				\item[] Bold Option: Yes (case of d switches bracketing from bold to normal; case of r switches case of original variable from bold to normal)
				\item[] Example: \sidR{sleeps}{r}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidrr{expression}{replacement1}{replacement2}[original1][original2][assignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to denote.
					\item[] \texttt{replacement1}: the 1st new variable to replace the original
					\item[] \texttt{replacement2}: the 2nd new variable to replace the original
					\item[] \texttt{original1(def=x)}: the 1st variable to be replaced
					\item[] \texttt{original2(def=y)}: the 2nd variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
				\end{itemizeexamplecommand}
				\item[] Description: Creats double bar bracketing for indirect denotation of an expression with \textit{g} a assignment function and two replacement spots.
				\item[] Bold Option: Yes (case of d switches bracketing from bold to normal; case of r switches case of original variable from bold to normal)
				\item[] Example: \sidRR{sleeps}{r}{t}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidrrr{expression}{replacement1}{replacement2}{replacement3}[original1][original2][original3][assignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to denote.
					\item[] \texttt{replacement1}: the 1st new variable to replace the original
					\item[] \texttt{replacement2}: the 2nd new variable to replace the original
					\item[] \texttt{replacement3}: the 3rd new variable to replace the original
					\item[] \texttt{original1(def=x)}: the 1st variable to be replaced
					\item[] \texttt{original2(def=y)}: the 2nd variable to be replaced
					\item[] \texttt{original3(def=z)}: the 3rd variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
				\end{itemizeexamplecommand}
				\item[] Description: Creats double bar bracketing for indirect denotation of an expression with \textit{g} a assignment function and three replacement spots.
				\item[] Bold Option: Yes (case of d switches bracketing from bold to normal; case of r switches case of original variable from bold to normal)
				\item[] Example: \sidRRR{sleeps}{r}{t}{w}}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Rules}
	This section covers the most general rules for direct and indirect semantic interpretation along with some general rules used for derivation in compositional semantics.
	\subsection{Constants}
	This section will list all pre-defined \texttt{\her{fragoli}} commands acting as constants for common types or general symbols in semantics.
	\subsubsection{Situations}
	\texttt{\her{fragoli}} offers the most common situtation variables for fast usage. The following are available: blank, \textit{*} and from \textit{0} to \textit{10}. Examples:
	\begin{center}
		\begin{minipage}[h][3.2cm][t]{15em}
			\begin{lstlisting}[style=B]
			\sblank
			\sblanK
			\sstar
			\sstaR
			\szero
			\szerO
			\sone
			\sonE
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3.2cm][t]{15em}
			\ \\
			\sblank\\
			\sblanK\\
			\sstar\\
			\sstaR\\
			\szero\\
			\szerO\\
			\sone\\
			\sonE
		\end{minipage}
	\end{center}
	\subsubsection{Lambda Heads}
	\texttt{\her{fragoli}} offers a wide range of pre-defined lambda heads for fast usage. All heads are available in a lower- and uppercase version as well as a normal and bold version. E.g. \verb=\lmds= will create \zit{\lmds}. The last letter defines the lamba head variable; If the last letter is uppercase, the head variable will also be uppercase. The case of \zit{d} defines if the head is bold (uppercase) or normal (lowercase). The following letters are available: \zit{a-z}. Example for all \textit{p} versions:
	\begin{center}
		\begin{minipage}[h][1.6cm][t]{15em}
			\begin{lstlisting}[style=B]
			\lmdp
			\lmDp
			\lmdP
			\lmDP
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][1.6cm][t]{15em}
			\ \\\lmdp\\
			\lmDp\\
			\lmdP\\
			\lmDP
		\end{minipage}
	\end{center}
	\subsubsection{Types}
	\texttt{\her{fragoli}} offers a set of predefined types - covering the most common ones. These constants will not be affected by the package option \textit{usetypes} and will also be displayed if \textit{usetypes=false}. If you want them to only be displayed if \textit{usetypes=true}, add an @ after the backslash (e.g. \verb=\@typet=). The parentheses style will be affected by the package option \textit{typestyle}. The syntax for these types is defined by the letter case of every letter following \textit{type}. Every adjacent letter with matching uppercase will be on the same level. E.g. \verb=\typeeET= vs. \verb=\typeEEt= will result in \typeeET\ vs. \typeEEt. For types with a depth greater than 3 the syntax will also contain \textit{l} \& \textit{r} as left and right parentheses. \verb=\typeletETrt= vs. \verb=\typeetlETtr= will result in \typeretETlt\ vs. \typeetrETtl. Examples:
	\begin{center}
		\begin{minipage}[h][3.8cm][t]{15em}
			\begin{lstlisting}[style=B]
			\typee
			\types
			\typeet
			\typett
			\typeSEt
			\typeeET
			\typeslEetr
			\typeretETlt
			\typeetrETtl
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3.8cm][t]{15em}
			\ \\\typee\\
			\types\\
			\typeet\\
			\typett\\
			\typeSEt\\
			\typeeET\\
			\typesleETr\\
			\typeretETlt\\
			\typeetrETtl
		\end{minipage}
	\end{center}
	\subsubsection{Traces}
	\texttt{\her{fragoli}} also offers commands for the most common traces for fast usage. The following are available (also as bold option): 
	\begin{center}
		\begin{minipage}[h][3.2cm][t]{15em}
			\begin{lstlisting}[style=B]
			\tracex
			\traceX
			\tracey
			\traceY
			\tracez
			\traceZ	
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3.2cm][t]{15em}
			\ \\
			\tracex\\
			\traceX\\
			\tracey\\
			\traceY\\
			\tracez\\
			\traceZ	
		\end{minipage}
	\end{center}
	\section{Environments}
	This section provides an overview of all newly introduced environments. Most environments include a set of specialized commands that are only accessible within the respective environment. Some environments are restricted, meaning they can only be used within a specific parent environment.
	\subsection{exams}
	The \textit{question} and \textit{answer} environments are designed to be used together. The intended purpose is to create a single \LaTeX\ file for homework assignments or exams that contains both the questions and their solutions—useful for tutorial sessions or sample solutions. By simply adjusting the package argument, one can toggle between displaying only the questions or including the solutions as well.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{question}
				content...
			\end{question}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments: None
				\item[] Description: Creates an environment that represents a question. If the \textit{showanswer} package argument is set to \textit{true}, the content within this environment will be displayed in light gray; otherwise, it will appear in black. \color{fglquestioncolor}example text\color{black}\ 
				\item[] New Commands: No
				\item[] Restricted: No
				\item[] Example: \verb=\begin{question}How does the knights move?\end{question}=}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{awnser}
				content...
			\end{awnser}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments: None
				\item[] Description: Creates an environment that represents an answer. If the \textit{showanswer} package argument is set to \textit{true}, the content within this environment will be displayed; otherwise, it will be hidden.
				\item[] New Commands: No
				\item[] Restricted: No
				\item[] Example: \\\verb=\begin{awnser}It generally moves like an L and sometimes in blitz games it can be very unpredictable.\end{awnser}=}
		\end{itemizeexamplecommand}
	\xe
	\subsection{fglfunc}\label{env:fglfunc}
	The \textit{fglfunc} environment should be used to create large functions in array notaion. This env. supports nesting. The \textit{fgls} and \textit{cps} environments are not enabled. When nesting multiple times it is recommended to change the vertical spacing to at least 14. Be carefull with linebreaks within the env. as this can result in an additional blank row or compiling errors!
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{fglfunc}[functionName][verticalSpacing][domainMode]
				content...
			\end{fglfunc}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{functionName}: The main function name.
					\item[] \texttt{verticalSpacing(def=10)}: The vertical spacing between each row.
					\item[] \texttt{domainMode(def=n)}: The text formatting mode of the domains.
				\end{itemizeexamplecommand}
				\item[] Description: Creates an environment for fast and easy function creation. Possible domain modes are \textit{n/m/b} which stand for \textit{normal}, \textit{mathmode}, and \textit{bold}. They will effect the text formatting of each domain.
				\item[] New Commands: Yes
				\item[] Restricted: No
				\item[] Since: 1.1.1
				\item[] Example: See below.}
		\end{itemizeexamplecommand}
	\xe
	\\Example for a short nested function K:
	\begin{lstlisting}[style=B]
			\begin{fglfunc}[\sde{kisses}][15]
					\f{Peter}{
					\b{
						\f{Peter}{0}
						\f{Maria}{1}
						\f{Frida}{0}}\d}
					\f{Maria}{
					\b{
						\f{Peter}{0}
						\f{Maria}{0}
						\f{Frida}{0}}\d}
					\d
			\end{fglfunc}
	\end{lstlisting}
	The code above will result in the following array structure:\\
	\begin{fglfunc}[\sde{kisses}][15]
						\f{Peter}{
						\b{
							\f{Peter}{0}
							\f{Maria}{1}
							\f{Frida}{0}\d}}
						\f{Maria}{
						\b{
							\f{Peter}{1}
							\f{Maria}{0}
							\f{Frida}{0}\d}}
						\d
	\end{fglfunc}
	\subsubsection{Commands}
	A few short commands are provided for fast and easy to read code.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\f{domain}{range}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{domain}: The domain.
					\item[] \texttt{range}: the range.
				\end{itemizeexamplecommand}
				\item[] Description: Will create a new row in the array representing an assignment.
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\b{function}[functionName]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{function}: A nested function.
					\item[] \texttt{functionName}: The nested function name.
				\end{itemizeexamplecommand}
				\item[] Description: Will create a box with left and right brackets for a new nested function. To manually add left or right brackets you can use \verb=\l= and \verb=\r=. Do not add line breaks inside the box command.
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\d[domain][symbol][range]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{domain(def=$\vdots$)}: An optional domain.
					\item[] \texttt{symbol}: The function symbol.
					\item[] \texttt{range}: An optional range.
				\end{itemizeexamplecommand}
				\item[] Description: Will create a new row with optional parameters. Should be used to indicate infinity or to add comments.
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{cps}
	The colored parentheses environment is designed to improve readability in semantic derivations. Most modern integrated development environments feature a similiar feature/plugin - called rainbow brackets. Parentheses on the same nesting level will receive the same color. Currently only \zit{()} are supported. After five levels of nesting the colors will repeat. Currently the feature is limited to parentheses directly written in the environment, those inserted by commands will not be affected (work in progress).
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{cps}
				scontent...
			\end{cps}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments: None
				\item[] Description: Parentheses on the same nesting level will receive the same color.
				\item[] New Commands: No
				\item[] Restricted: No
				\item[] Example: \begin{cps}(1(2((4((6(7))5))3)))\end{cps}}
		\end{itemizeexamplecommand}
	\xe
	\subsection{fgls}
	The fragoli-semantics environment is designed to improve speed and readability in semantic derivations by adding shortcuts and specialised versions of general commands.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{fgls}[situation]
				content...
			\end{fgls}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments: \begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: The situation which will be displayed on all commands that make use of a situation (e.g. \verb=\e{}=).
				\end{itemizeexamplecommand}
				\item[] Description: Adds shortcuts and specialised versions of general commands.
				\item[] New Commands: Yes
				\item[] Restricted: No}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\fglsem[situation][formulae]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: The situation which will be displayed on all commands that make use of a situation (e.g. \verb=\e{}=).
					\item[] \texttt{formulae}: The semantic formulae.
				\end{itemizeexamplecommand}
				\item[] Description: Command wrapper for the \textit{fgls} environment. Should be used for short formulae. Will remove initial indent.
				\item[] Since: 1.1.1
			}
	\end{itemizeexamplecommand}
	\xe
	\subsubsection{Constants}
	This section will list all pre-defined commands acting as constants for common types or general symbols in the \textit{fgls} environment.
	\begin{enumerate}
		\item Object Language\\\verb=\or= is currently not available.
		\begin{center}
			\begin{minipage}[h][4.8cm][t]{15em}
				\begin{lstlisting}[style=B]
			\ox
			\oy
			\oz
			\oi
			\oj
			\os
			\oR
			\oq
			\op
			\x
			\y
			\z
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][4.8cm][t]{15em}
				\begin{fgls}
					\ \\
					\ox\\
					\oy\\
					\oz\\
					\oi\\
					\oj\\
					\os\\
					\oR\\
					\oq\\
					\op\\
					\x\\
					\y\\
					\z
				\end{fgls}
			\end{minipage}
		\end{center}
		Each object language constant exists in two forms: lowercase and uppercase. The uppercase version is represented by capitalizing the second letter of the command. Additionally, each constant has a secondary mode that automatically adds a space following the constant. To activate this mode, capitalize the first letter of the command. Both forms can be used simultaneously. The letters x, y, and z have special single-character commands, as they are the most commonly used. As a trade-off, these letters do not have a secondary mode that automatically appends a space.
		\item Meta Language
		\begin{center}
			\begin{minipage}[h][5.2cm][t]{15em}
				\begin{lstlisting}[style=B]
			\mx
			\my
			\mz
			\mi
			\mj
			\ms
			\mr
			\mp
			\mq
			\mu
			\mv
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][5.2cm][t]{15em}
				\begin{fgls}
					\ \\
					\mx\\
					\my\\
					\mz\\
					\mi\\
					\mj\\
					\ms\\
					\mr\\
					\mp\\
					\mq\\
					\mu\\
					\mv
				\end{fgls}
			\end{minipage}
		\end{center}
		Each meta language constant exists in two forms: lowercase and uppercase. The uppercase version is represented by capitalizing the second letter of the command. Additionally, each constant has a secondary mode that automatically adds a space following the constant. To activate this mode, capitalize the first letter of the command. Both forms can be used simultaneously. For advanced existential quantifiers see Section \ref{sub:quantorcommands}.
		\item Logic \begin{center}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{lstlisting}[style=B]
			\qe
			\qu
			\qa
			\jn
			\jc
			\jd
			\ji
			\jj
			\jx
			\jb
			\jp
			\jt
			\jf
			\je
			\jo
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{fgls}
					\ \\
					\qe\\
					\qu\\
					\qa\\
					\jn\\
					\jc\\
					\jd\\
					\ji\\
					\jj\\
					\jx\\
					\jb\\
					\jp\\
					\jt\\
					\jf\\
					\je\\
					\jo
				\end{fgls}
			\end{minipage}
			
		\end{center}
		Every logic constant exists in two versions, normal and bold. For the bold version just write the second letter in uppercase. All junctor constants have a second mode that automatically adds a space behind them. To use this mode just write the first letter in uppercase. Both versions can be combined.
		\item Set theory \begin{center}
			\begin{minipage}[h][4cm][t]{15em}
				\begin{lstlisting}[style=B]
			\ci
			\cd
			\ce
			\cb
			\cq
			\ca
			\cu
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][4cm][t]{15em}
				\begin{fgls}
					\ \\
					\ci\\
					\cd\\
					\ce\\
					\cb\\
					\cq\\
					\ca\\
					\cu
				\end{fgls}
			\end{minipage}
		\end{center}
		Every set notation exists in two versions, normal and bold. For the bold version just write the second letter in uppercase. All operators have a second mode that automatically adds a space behind them. To use this mode just write the first letter in uppercase. Both versions can be combined.
		\item Relations \begin{center}
			\begin{minipage}[h][4cm][t]{15em}
				\begin{lstlisting}[style=B]
			\rn
			\rg
			\rl
			\rp
			\rpe
			\rs
			\rse
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][4cm][t]{15em}
				\begin{fgls}
					\ \\
					\rn\\
					\rg\\
					\rl\\
					\rp\\
					\rpe\\
					\rs\\
					\rse
				\end{fgls}
			\end{minipage}
		\end{center}
		Every relation operator exists in two versions, normal and bold. For the bold version just write the last letter in uppercase. All operators have a second mode that automatically adds a space behind them. To use this mode just write the first letter in uppercase. Both versions can be combined.
		\item Arguments Variable
		\begin{center}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{lstlisting}[style=B]
			\ax
			\aX
			\ay
			\aY
			\az
			\aZ
			\ai
			\aI
			\as
			\aS
			\ar
			\aR
			\ap
			\aP
			\aq
			\aQ
			\ae
			\aE
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{fgls}
					\ \\
					\ax\\
					\aX\\
					\ay\\
					\aY\\
					\az\\
					\aZ\\
					\ai\\
					\aI\\
					\as\\
					\aS\\
					\ar\\
					\aR\\
					\ap\\
					\aP\\
					\aq\\
					\aQ\\
					\ae\\
					\aE
				\end{fgls}
			\end{minipage}
		\end{center}
		
		\begin{center}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{lstlisting}[style=B]
			\Ax
			\AX
			\Ay
			\AY
			\Az
			\AZ
			\Ai
			\AI
			\As
			\AS
			\Ar
			\AR
			\Ap
			\AP
			\Aq
			\AQ
			\Ae
			\AE
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{fgls}
					\ \\
					\Ax\\
					\AX\\
					\Ay\\
					\AY\\
					\Az\\
					\AZ\\
					\Ai\\
					\AI\\
					\As\\
					\AS\\
					\Ar\\
					\AR\\
					\Ap\\
					\AP\\
					\Aq\\
					\AQ\\
					\Ae\\
					\AE
				\end{fgls}
			\end{minipage}
		\end{center}
		\begin{center}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{lstlisting}[style=B]
			\bx
			\bX
			\by
			\bY
			\bz
			\bZ
			\bi
			\bI
			\bs
			\bS
			\br
			\bR
			\bp
			\bP
			\bq
			\bQ
			\be
			\bE
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{fgls}
					\ \\
					\bx\\
					\bX\\
					\by\\
					\bY\\
					\bz\\
					\bZ\\
					\bi\\
					\bI\\
					\bs\\
					\bS\\
					\br\\
					\bR\\
					\bp\\
					\bP\\
					\bq\\
					\bQ\\
					\be\\
					\bE
				\end{fgls}
			\end{minipage}
		\end{center}
		\item Situations
		\\\verb=\cs= will always return the current situation set in the current fgls env. (def=\sstar)
		\begin{center}
			\begin{minipage}[h][2.5cm][t]{15em}
				\begin{lstlisting}[style=B]
			\ss
			\sz
			\so
			\st
			\si
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][2.5cm][t]{15em}
				\begin{fgls}
					\ \\
					\ss\\
					\sz\\
					\so\\
					\st\\
					\si
				\end{fgls}
			\end{minipage}
		\end{center}
	Each situation constant exists in two forms: normal and bold. The bold version is represented by capitalizing the second letter of the command. Additionally, each situation constant has a secondary mode, which automatically adds a space following the constant. To activate this mode, capitalize the first letter of the command. Both forms can be used simultaneously. It is important to note that the symbol \textit{i} has a special rule: when the first letter is lowercase, the constant is always represented in subscript, while the version with an uppercase first letter is treated as a normal variable with an added space at the end.
	\end{enumerate}
	\subsubsection{Commands}
		Text-Commands:
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\o{text}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{text}: Text to format.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\obl{text}=
					\item[] Bold Option: No
					\item[] Example: \obl{text}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\v{text}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{text}: Text to format.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\obli{text}=
					\item[] Bold Option: No
					\item[] Example: \obli{text}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\m{text}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{text}:  Text to format.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\mel{text}=
					\item[] Bold Option: No
					\item[] Example: \mel{text}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\j{text}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{text}:  Text to format.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\meli{text}=
					\item[] Bold Option: No
					\item[] Example: \meli{text}}
			\end{itemizeexamplecommand}
		\xe
		Argument-Commands:
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\a{arg}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{arg}:  object language variable as argument.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\obl{(}\obli{arg}\obl{)}=
					\item[] Bold Option: No
					\item[] Example: \obl{(}\!\obli{a}\!\obl{)}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\A{arg}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{arg}:  object language constant as argument.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\obl{(arg)}=
					\item[] Bold Option: No
					\item[] Example: \obl{(\!a\!)}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\sa{function}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{function}:  the characteristic function.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sarrow{function}=
					\item[] Bold Option: Yes
					\item[] Example: \sarrow{\sde{Peter}}}
			\end{itemizeexamplecommand}
		\xe
		Lambda-Commands:
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfx{word}[lambdaBody][lambdaHead][situation][headType]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\texttt{lambdaHead} \texttt{word} in \sstar}.
						\item[] \texttt{lambdaHead(def=x)}:  the lambda head variable
						\item[] \texttt{situation(def=\sstar)}:  the situation inside the lambda body.
						\item[] \texttt{headType}:  the lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \verb=\lambfx{lambdaBody}[lambdaHead][headType]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfx{\textit{x} sleeps in \sstar}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfy{word}[lambdaBody][lambdaHead1][lambdaHead2][situation][headType1][headType2]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\texttt{lambdaHead1} \texttt{word} \texttt{lambdaHead2} in \sstar}.
						\item[] \texttt{lambdaHead1(def=y)}:  the first lambda head variable
						\item[] \texttt{lambdaHead2(def=x)}:  the second lambda head variable
						\item[] \texttt{situation(def=\sstar)}:  the situation inside the lambda body
						\item[] \texttt{headType1}:  the first lambda head type
						\item[] \texttt{headType2}:  the second lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \verb=\lambfyx{lambdaBody}[lambdaHead1][lambdaHead2][headType1][headType2]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfyx{\textit{x} kills \textit{y} in \sstar}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfz{word}[lambdaBody][lambdaHead1][lambdaHead2][lambdaHead3][situation][headType1][headType2][headType3]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\textit{lambdaHead1} \texttt{word} \texttt{lambdaHead2} \textit{lambdaHead3} in \sstar}.
						\item[] \texttt{lambdaHead1(def=z)}:  the first lambda head variable
						\item[] \texttt{lambdaHead2(def=y)}:  the second lambda head variable
						\item[] \texttt{lambdaHead3(def=x)}:  the third lambda head variable
						\item[] \texttt{situation(def=\sstar)}:  the situation inside the lambda body
						\item[] \texttt{headType1}:  the first lambda head type
						\item[] \texttt{headType2}:  the second lambda head type
						\item[] \texttt{headType3}:  the third lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \verb=\lambfzyx{lambBody}[lambHead1][lambHead2][lambHead3][headType1][headType2][headType3]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfzyx{\textit{x} gives \textit{y} \textit{z} in \sstar}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfsx{word}[lambdaBody][situationHead][lambdaHead2][situationType][headType2]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\texttt{lambdaHead2} \texttt{word} in \texttt{situationHead}}.
						\item[] \texttt{situationHead(def=s)}:  the situation lambda head variable
						\item[] \texttt{lambdaHead2(def=x)}:  the second lambda head variable
						\item[] \texttt{headType1}:  the situation lambda head type (should be used if type should be displayed)
						\item[] \texttt{headType2}:  the second lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \verb=\lambfsx{lambdaBody}[lambdaHead1][lambdaHead2][headType1][headType2]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfsx{\textit{x} sleeps in \sblank}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfsy{word}[lambdaBody][situationHead][lambdaHead2][lambdaHead3][situationType][headType2][headType3]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\texttt{lambdaHead3} \texttt{word} \texttt{lambdaHead2} in \texttt{situationHead}}.
						\item[] \texttt{situationHead(def=s)}:  the situation lambda head variable
						\item[] \texttt{lambdaHead2(def=y)}:  the second lambda head variable
						\item[] \texttt{lambdaHead3(def=x)}:  the third lambda head variable
						\item[] \texttt{headType1}:  the situation lambda head type (should be used if type should be displayed)
						\item[] \texttt{headType3}:  the second lambda head type
						\item[] \texttt{headType3}:  the third lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \\\verb=\lambfsyx{lambdaBody}[lambdaHead1][lambdaHead2][lambdaHead3][headType1][headType2][headType3]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfsyx{\textit{x} kills \textit{y} in \sblank}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfsz{word}[lambdaBody][situationHead][lambdaHead2][lambdaHead3][lambdaHead4][situationHead][headType2][headType3]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \\\zit{\texttt{lambdaHead4} \texttt{word} \texttt{lambdaHead3} \texttt{lambdaHead2} in \texttt{situationHead}}.
						\item[] \texttt{situationHead(def=s)}:  the situation lambda head variable
						\item[] \texttt{lambdaHead2(def=z)}:  the second lambda head variable
						\item[] \texttt{lambdaHead3(def=y)}:  the third lambda head variable
						\item[] \texttt{lambdaHead4(def=x)}:  the fourth lambda head variable
						\item[] \texttt{headType1}:  the situation lambda head type (should be used if type should be displayed)
						\item[] \texttt{headType2}:  the second lambda head type
						\item[] \texttt{headType3}:  the third lambda head type (fourth lambda head will get the same type due to the 9 args limit in LaTeX)
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \\\verb=\lambfszyx{lambdaBody}[lambdaHead1][lambdaHead2][lambdaHead3][lambdaHead4][headType1][headType2][headType3][headType4]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfszyx{\textit{x} gives \textit{y} \textit{z} in \sblank}}
			\end{itemizeexamplecommand}
		\xe
		There are pre-defined lambda heads for the most common variables. Each one has four different versions which can been seen below for the example of x. The variables are: \textit{x,y,z,p,q,s,r,i,u,v}.
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lx[type]
			\lX[type]
			\Lx[type]
			\LX[type]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{type}:  type of the lambda head variable
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\lambh{var}[type]=
					\item[] Bold Option: Yes (first letter defines if the lambda head is bold, second letter defines the lambda head variable)
					\item[] Example: \lambh{x}, \lambh{X}, \lambH{x}, \lambH{X}}
			\end{itemizeexamplecommand}
		\xe
		Derivation-Commands:
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\r[subInner][subOuter]{arg}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{subInner}: Optional subscript behind opening bracket. Text will be in mathmode. (mostly used in tree like structures)
						\item[] \texttt{subOuter}: Optional subscript behind closing bracket. Text will be in mathmode (mostly used to identify types)
						\item[] \texttt{arg}:  term inside rectangular brackets.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\lambby{arg}=
					\item[] Bold Option: Yes
					\item[] Example: \lambby{arg}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\n{arg}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{arg}:  term inside truth value brackets.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\bool{arg}=
					\item[] Bold Option: Yes
					\item[] Example: \bool{arg}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\s{arg}[var]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{arg}:  Set-builder notation
						\item[] \texttt{var(def=x)}: Varibale name and/or domain specifier
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\set[var]{arg}=. To write the set variable use \verb=\sv= or \\\verb=\Sv= for the version with an extra space appended.
					\item[] Bold Option: Yes
					\item[] Example: \verb=\s{\Sv is a dog}=  will result in: \set{\Setvar is a dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\i{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to interpret.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sdi{arg}=
					\item[] Bold Option: Yes
					\item[] Example: \sdi{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\e[situation]{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{situation(def=\sstar)}:  the situation.
						\item[] \texttt{expression}:  the expression to interpret.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sde[situation]{arg}=
					\item[] Bold Option: Yes
					\item[] Example: \sde{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\c[situation]{constant}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{situation(def=$i$)}:  the situation.
						\item[] \texttt{constant}:  the constant.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sic[situation]{constant}=
					\item[] Bold Option: No (Uppercase version removes notational convention)
					\item[] Example: \sic[\bm{i}]{S}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\t{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to translate.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sit{expression}=
					\item[] Bold Option: Yes
					\item[] Example: \sit{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\ti{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to translate.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sit{\textit{expression}}=
					\item[] Bold Option: Yes
					\item[] Example: \sit{\textit{Dog}}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\tb{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to translate.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sitnobf{expression}=
					\item[] Bold Option: Yes
					\item[] Example: \sitnobf{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\tbi{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to translate.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sitnobfi{expression}=
					\item[] Bold Option: Yes
					\item[] Example: \sitnobfi{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\h{type}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{type}: the Ty2 type.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\type{type}=
					\item[] Bold Option: Yes
					\item[] Example: \type{et}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\d[assignment]{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{assignment(def=g)}: the assignment function.
						\item[] \texttt{expression}: the expression to denote.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sid[assignment]{expression}=
					\item[] Bold Option: Yes
					\item[] Example: \sid[g]{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\dr{expression}[replacement][assignment][original]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}: the expression to denote.
						\item[] \texttt{replacement(def=r)}: the variable to replace the original with.
						\item[] \texttt{assignment(def=g)}: the assignment function.
						\item[] \texttt{original(def=x)}: the original argument to be replaced
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sidr{expression}{replacement}[original][assignment]=
					\item[] Bold Option: No (Uppercase makes original variable bold)
					\item[] Example: \sidr{Dog}{r}[x][g]}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\drr{expression}[replacement1][replacement2][assignment][original1][original2]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}: the expression to denote.
						\item[] \texttt{replacement1(def=r)}: the first variable to replace the original with.
						\item[] \texttt{replacement2(def=d)}: the second variable to replace the original with.
						\item[] \texttt{assignment(def=g)}: the assignment function.
						\item[] \texttt{original1(def=x)}: the fist original argument to be replaced
						\item[] \texttt{original2(def=y)}: the second original argument to be replaced
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sidrr{expression}{replacement1}{replacement2}[original1][original2][assignment]=
					\item[] Bold Option: No (Uppercase makes original variable bold)
					\item[] Example: \sidrr{Dog}{r}{d}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\drrr{expression}[replacement1][replacement2][replacement3][assignment][original1][original2][original3]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}: the expression to denote.
						\item[] \texttt{replacement1(def=r)}: the first variable to replace the original with.
						\item[] \texttt{replacement2(def=d)}: the second variable to replace the original with.
						\item[] \texttt{replacement3(def=t)}: the third variable to replace the original with.
						\item[] \texttt{assignment(def=g)}: the assignment function.
						\item[] \texttt{original1(def=x)}: the fist original argument to be replaced
						\item[] \texttt{original2(def=y)}: the second original argument to be replaced
						\item[] \texttt{original3(def=z)}: the third original argument to be replaced
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for\\ \verb=\sidrrr{expression}{replacement1}{replacement2}{replacement3}[original1][original2][original3][assignment]=
					\item[] Bold Option: No (Uppercase makes original variable bold)
					\item[] Example: \sidrrr{Dog}{r}{d}{t}}
			\end{itemizeexamplecommand}
		\xe
		Quantifier-Commands:\label{sub:quantorcommands}
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\qe[relation][value]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{relation}:  the mathematical relation (mathmode already enabled)
						\item[] \texttt{value}:  the numerical value
					\end{itemizeexamplecommand}
					\item[] Description: Creates an existential quantifier with additional parameters.
					\item[] Bold Option: Yes
					\item[] Space Option: Yes	
					\item[] Since: 1.1.1				
					\item[] Example: \vbox{\begin{fgls}\qE[>][1]\end{fgls}}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\qeg[value]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{value(def=2)}:  the numerical value
					\end{itemizeexamplecommand}
					\item[] Description: Creates an existential quantifier with a greater than or equal to paramter.
					\item[] Bold Option: Yes
					\item[] Space Option: Yes
					\item[] Since: 1.1.1
					\item[] Example: \vbox{\begin{fgls}\qeg\end{fgls}}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\qes[value]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{value(def=2)}:  the numerical value
					\end{itemizeexamplecommand}
					\item[] Description: Creates an existential quantifier with a smaller than or equal to paramter.
					\item[] Bold Option: Yes
					\item[] Space Option: Yes
					\item[] Since: 1.1.1
					\item[] Example: \vbox{\begin{fgls}\qes\end{fgls}}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\qee[value]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{value(def=2)}:  the numerical value
					\end{itemizeexamplecommand}
					\item[] Description: Creates an existential quantifier with an equal to paramter.
					\item[] Bold Option: Yes
					\item[] Space Option: Yes
					\item[] Since: 1.1.1
					\item[] Example: \vbox{\begin{fgls}\qee\end{fgls}}}
			\end{itemizeexamplecommand}
		\xe
	\subsection{semderivation}
	The \textit{semantic-derivation} environment is the heart of the \FraGoLi\ package and is used for fast and easy derivation of a direct or indirect semantic expressions. The \textit{fgls} and \textit{cps} env. are enabled automatically.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semderivation}[label]
			content...
			\end{semderivation}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for easy derivation of direct or indirect semantic expressions.
				\item[] New Commands: Yes
				\item[] Restricted: No}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Constants}
	This section lists all predefined commands that serve as constants for common derivation steps within the \textit{semderivation} environment. These commands are intended to be used as sidenotes. If the language is changed via the package options, the constants will be automatically translated and abbreviated. Some of these are interchangeable.
	\begin{center}
		\begin{minipage}[h][4.6cm][t]{15em}
			\begin{lstlisting}[style=B]
			\alp
			\bta
			\fa
			\abs
			\mod
			\var
			\con
			\id
			\lc
			\nc
			\lex
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][4.6cm][t]{15em}
			\begin{fgls}
				\ \\
				\ensuremath{\alpha}-conversion\\
				\ensuremath{\beta}-reduction\\
				Functional application\\
				Abstraction\\
				Modification\\
				Variable assignment\\
				Con\\
				Id\\
				\ensuremath{\lambda}-conversion\\
				Notation convention\\
				lexical trees
			\end{fgls}
		\end{minipage}
	\end{center}
	\subsubsection{Commands}
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\ds[sidenote]{derivationRow}[itemLabel]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{derivationRow}: The derivational step performed.
					\item[] \texttt{itemLabel}: The itemize item label for the current step, if blank the label will be an equal sign with the current row number on top.
				\end{itemizeexamplecommand}
				\item[] Description: Adds a new step to the derivation without the equals and row counter, should theirfore be used as first row
				\item[] Bold Option: No (Uppercase removes equals and row counter, should be used as first step to indicate the beginning)
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\cdr
			\end{lstlisting}
			{\scriptsize\item[] Arguments: none
				\item[] Description: Returns the current derivation reference string. For example sem:deri:3 if used in the third derivation env. or sem:deri:derithree if used in a semcalc env with derithree as refName argument.
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semcalc}\label{sec:semcalc}
	The \textit{semantic-calculation} environment is designed to improve speed and to provide a clear structure for a full semantic derivation. If not specified otherwise via a package option, \textit{cps} is enabled in the \textit{semderi} environment. The \textit{fgls} shortcuts are enabled.
	
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semcalc}[situation][refName]
			content...
			\end{semcalc}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments: \begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: The situation which will be displayed on all extensions. The default value is set by the situation package parameter.
					\item[] \texttt{refName(def=@fglsderivationcounter)}: The reference name used in the automatic labels that will be created for each resource entry (e.g. rules, lexicon, etc.) and derivation step. By default fragoli will start at 1 and increase eachtime a new semantic derivation is created (including semderivation and semderi env.).
				\end{itemizeexamplecommand}
				\item[] Description: Adds shortcuts and specialised versions of general commands.
				\item[] New Commands: Yes
				\item[] Restricted: No}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Commands}
	Both \textit{resource-entry} commands should be used inside the \textit{semrule} and \textit{semlex} environment to add a rule or lexicon entry to the derivation. The sidenote information should referenz the origin of a rule or lexicon entry (e.g. from a script or paper) or to referenz the rule or lexicon entry used in a derivational step.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rentry[sidenote]{resourceEntry}[label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{resourceEntry}: The resource entry (either a rule or a lexicon entry)
					\item[] \texttt{label}: The item label, if blank the label will be R/L + the current rule/lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: Add either a rule or a lexicon entry.
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rentrysub[sidenote]{resourceSubEntry}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{resourceSubEntry}: Detailed information for a resource entry.
				\end{itemizeexamplecommand}
				\item[] Description: Give additional information about a rule or a lexicon entry.
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\label{command:resourceCounter}\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rr{resourceCounter}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{resourceCounter}: The number of the rule to be referenced
				\end{itemizeexamplecommand}
				\item[] Description: Creates a reference to the rule specified. Its the short version of \verb=\ref{\cdr:r:number}=. For a lexicon entry use \verb=\rl{resourceCounter}=, for a language entry use \verb=\rla{resourceCounter}=, for a syntactic rule entry use \verb=\rrs{resourceCounter}=
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\cdr
			\end{lstlisting}
			{\scriptsize\item[] Arguments: none
				\item[] Description: Returns the current derivation reference string. For example sem:deri:3 if used in the third derivation env. or sem:deri:derithree if used in a semcalc env with derithree as refName argument.
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semlang}
	The \textit{semantic-lang} environment is an optional environment to define the lnguage for any derivation of a direct or indirect semantic expressions. So far no custom commands are implemented. Each language gets automatically label (if used via \verb=\rentry= or predefined language command) with the following pattern: "sem:deri:refName:la:rulecounter". So the first language in the second semcalc env. will have the following label: "sem:deri:2:la:1" assuming that no custom refName has been set.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semlang}[label]
			content...
			\end{semlang}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for defining the language your woking in for this current derivation.
				\item[] New Commands: Yes
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Commands}
	The \FraGoLi\ package offers a quick builder to create a language based of sets of lexical entries.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rlang{entires}[setOne][setTwo][setThree][setFour][setFive][setSix][setSeven][setEight][symbol]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{entires}: Every element of the language, separated by a comma.
					\item[] \texttt{setOne}: An optional set of entries to group similar ones.
					\item[] \texttt{setTwo}: An optional set of entries to group similar ones.
					\item[] \texttt{setThree}: An optional set of entries to group similar ones.
					\item[] \texttt{setFour}: An optional set of entries to group similar ones.
					\item[] \texttt{setFive}: An optional set of entries to group similar ones.
					\item[] \texttt{setSix}: An optional set of entries to group similar ones.
					\item[] \texttt{setSeve}: An optional set of entries to group similar ones.
					\item[] \texttt{setEigth}: An optional set of entries to group similar ones.
					\item[] \texttt{symbol(def=L)}: The symbol for the main language set.
				\end{itemizeexamplecommand}
				\item[] Description: Builds a set that defines the language. If any optional set is added, they will all be unified.
				\item[] Example: \verb=\rlang{Peter, Maria, liebt}[NN][VP]= Result: L = L\textsubscript{NN} $\cup$ L\textsubscript{VP} = \{Peter, Maria, liebt\} 
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semtree}
	The \textit{semantic-tree} environment is an optional environment to add general tree structures to any derivation of a direct or indirect semantic expressions. So far no custom tree generating
	commands are implemented, all tree packages should work but \textit{forest} package is tested best and recommended.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semtree}[label]
			content...
			\end{semtree}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for additional trees of semantic expressions.
				\item[] New Commands: No
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semtreesem}
		The \textit{semantic-tree-semantic} environment is a specialized version of the \textit{semantic-tree} env. and should be used for semantic trees. So far no custom tree generating commands are implemented, all tree packages should work but \textit{forest} package is tested best and recommended.
		\pex
			\ex \begin{itemizeexamplecommand}
				\item[] \begin{lstlisting}[style=B]
				\begin{semtreesem}[label]
				content...
				\end{semtreesem}
				\end{lstlisting}
				{\scriptsize
					\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
					\end{itemizeexamplecommand}
					\item[] Description: Env. for additional semantic trees of semantic expressions.
					\item[] New Commands: No
					\item[] Restricted: Yes (semcalc)}
			\end{itemizeexamplecommand}
		\xe
	\subsection{semtreesyn}
		The \textit{semantic-tree-syntactic} environment is a specialized version of the \textit{semantic-tree} env. and should be used for syntactic trees. So far no custom tree generating commands are implemented, all tree packages should work but \textit{forest} package is tested best and recommended.
		\pex
			\ex \begin{itemizeexamplecommand}
				\item[] \begin{lstlisting}[style=B]
				\begin{semtreesyn}[label]
				content...
				\end{semtreesyn}
				\end{lstlisting}
				{\scriptsize
					\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
					\end{itemizeexamplecommand}
					\item[] Description: Env. for additional syntactic trees of semantic expressions.
					\item[] New Commands: No
					\item[] Restricted: Yes (semcalc)}
			\end{itemizeexamplecommand}
		\xe
	\subsection{semrule}
	The \textit{semantic-rules} environment is used to list all rules used for a derivation of a direct or indirect semantic expressions. Each rule gets automatically label (if used via \verb=\rentry= or predefined rule) with the following pattern: "sem:deri:refNamer:rulecounter". So the first rule in the second semcalc env. will have the following label: "sem:deri:2:r:1" assuming that no custom refName has been set.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semrule}[label][situation]
			content...
			\end{semrule}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
					\item[] \texttt{situation(def=$s$)}: The situation which will be displayed on all extensions. The default value is set by the rulesituation package parameter.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for easy listing of semantic derivation rules.
				\item[] New Commands: Yes
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Commands}
	The \FraGoLi\ package offers the most common semantic rules for both direct and indirect in\-ter\-pre\-ta\-ti\-on based on the accompanying material to an introductory course to linguistic semantics by Prof. Dr. \textit{T. E. Zimmermann}. All pre-defined rules can be custemized with aspect to variables and lambda heads. General commands for fast rule creation are also featured. All commands start with rsr (resource semantic rule) followed by a categorization into general/direct/indirect e.g. \verb=\rsrgarrow= for \texttt{resource-semantic-rule-general-arrow}. All pre-defined rules have the option to add a sidenote. If the package otpion usetypes is enabled all pre-defined rules will show the type on each lambda head. All rules are based on their basic versions just wrapped inside a resource entry command.
	\\Currently the command catagorie abriviations are:
	\begin{center}
		\begin{minipage}[h][3.3cm][t]{10em}
			\begin{lstlisting}[style=B]
			rsrg
			rsrde
			rsrdeqr
			rsrdi
			rsrit
			rsrid
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3.3cm][t]{30em}
			\begin{fgls}
				\ \\
				resource-semantic-rule-general\\
				resource-semantic-rule-direct-exenstion\\
				resource-semantic-rule-direct-extension-quantifier-raising\\
				resource-semantic-rule-direct-intension\\
				resource-semantic-rule-indirect-translation\\
				resource-semantic-rule-indirect-denotation
			\end{fgls}
		\end{minipage}
	\end{center}
	General Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrgarrow[sidenote]{var}{function}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var(def=x)}: Variable.
					\item[] \texttt{function(def=f)}: Function.
				\end{itemizeexamplecommand}
				\item[] Description: Give additional information about a rule or a lexicon entry.
				\item[] Example: \verb=\rsrgarrow= \begin{semcalc}\begin{semrule}[ ]\rsrgarrow\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Direct Interpretation Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrde{arg1}{arg2}[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: left argument.
					\item[] \texttt{arg2}: right argument.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=\sstar)}: The situtaion.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation extension rule.
				\item[] Example: \verb=\rsrde{Left}{Right}= \begin{semcalc}\begin{semrule}[ ]\rsrde{Left}{Right}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdi{arg1}{arg2}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: left argument.
					\item[] \texttt{arg2}: right argument.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdi{Left}{Right}= \begin{semcalc}\begin{semrule}[ ]\rsrdi{Left}{Right}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdesbjpred[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=\sstar)}: The situtaion.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdesbjpred= \begin{semcalc}\begin{semrule}[ ]\rsrdesbjpred\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdesbjquant[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=\sstar)}: The situtaion.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdesbjquant= \begin{semcalc}\begin{semrule}[ ]\rsrdesbjquant\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeobjpred[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=\sstar)}: The situtaion.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdeobjpred= \begin{semcalc}\begin{semrule}[ ]\rsrdeobjpred\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeobjquant[sidenote][arg1][arg2][situation][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{arg1(def=x)}: The first argument.
					\item[] \texttt{arg2(def=y)}: The second argument.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{type1(def=\type{e})}: The type of the first argument
					\item[] \texttt{type2(def=\type{e})}: The type of the second argument
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdeobjquant= \begin{semcalc}\begin{semrule}[ ]\rsrdeobjquant\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdequant[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=\sstar)}: The situtaion.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdequant= \begin{semcalc}\begin{semrule}[]\rsrdequant\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdecoordination[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=\sstar)}: The situtaion.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdecoordination= \begin{semcalc}\begin{semrule}[ ]\rsrdecoordination\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdiconva[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=s)}: The situtaion.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdiconva= \begin{semcalc}\begin{semrule}[ ]\rsrdiconva\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdiconvb[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=s)}: The situtaion.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdiconvb= \begin{semcalc}\begin{semrule}[ ]\rsrdiconvb\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeattitude[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=\sstar)}: The situtaion.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdeattitude= \begin{semcalc}\begin{semrule}[ ]\rsrdeattitude\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Indirect Interpretation Translation Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrit{left}{right}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument.
					\item[] \texttt{right}: Right argument
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrit{Left}{Right}= \begin{semcalc}\begin{semrule}[ ]\rsrit{Left}{Right}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsriti{left}{right}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument.
					\item[] \texttt{right}: Right argument
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsriti{Left}{Right}= \begin{semcalc}\begin{semrule}[ ]\rsriti{Left}{Right}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritibasic{left}{right}{rightArg}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument.
					\item[] \texttt{right}: Right argument
					\item[] \texttt{rightArg}: Argument on the right side.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritibasic{Left}{Right}{Arg}= \begin{semcalc}\begin{semrule}[ ]\rsritibasic{Left}{Right}{Arg}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritcoordination[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritcoordination= \begin{semcalc}\begin{semrule}[ ]\rsritcoordination\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritpredication[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritpredication= \begin{semcalc}\begin{semrule}[ ]\rsritpredication\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritnamedirectobject[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritnamedirectobject= \begin{semcalc}\begin{semrule}[ ]\rsritnamedirectobject\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritquantification[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritquantification= \begin{semcalc}\begin{semrule}[ ]\rsritquantification\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritquantificational[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritquantificational= \begin{semcalc}\begin{semrule}[ ]\rsritquantificational\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritquantificationasobj[sidenote][arg1][arg2][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{arg1(def=x)}: First argument.
					\item[] \texttt{arg1(def=y)}: Second argument.
					\item[] \texttt{type1(def=\type{et})}: Type of the first argument
					\item[] \texttt{type2(def=\type{et})}: Type of the second argument
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritquantificationasobj= \begin{semcalc}\begin{semrule}[ ]\rsritquantificationasobj\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritattitude[sidenote][situation][situationType][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=i)}: The situation.
					\item[] \texttt{situationType(def=\type{s})}: The situation type (should be used to always display type).
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritattitude= \begin{semcalc}\begin{semrule}[ ]\rsritattitude\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritraisedsubj[sidenote][situation][situationType][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=i)}: The situation.
					\item[] \texttt{situationType(def=\type{s})}: The situation type (should be used to always display type).
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritraisedsubj= \begin{semcalc}\begin{semrule}[ ]\rsritraisedsubj\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritcontrolverbs[sidenote][arg1][arg2][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{arg1(def=x)}: First argument.
					\item[] \texttt{arg1(def=i)}: Situation argument.
					\item[] \texttt{type1(def=\type{et})}: Type of the first argument
					\item[] \texttt{type2(def=\type{s})}: Type of the situation argument
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritcontrolverbs= \begin{semcalc}\begin{semrule}[ ]\rsritcontrolverbs\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Indirect Interpretation Denotation Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrid{right}{left}[sidenote][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{right}: Right argument.
					\item[] \texttt{left}: Left argument.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{assignment(def=g)}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrid{Right}{Left}= \begin{semcalc}\begin{semrule}[ ]\rsrid{Right}{Left}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsridinterpretvar[sidenote][assignment][arg][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{assignment(def=g)}: The assignment function var.
					\item[] \texttt{arg(def=x)}: The argument variable.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsridinterpretvar= \begin{semcalc}\begin{semrule}[ ]\rsridinterpretvar\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsridapp[sidenote][assignment][arg1][arg2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{assignment(def=g)}: The assignment function var.
					\item[] \texttt{arg1(def=\ensuremath{\bm{\alpha}})}: The first argument.
					\item[] \texttt{arg2(def=\ensuremath{\bm{\beta}})}: The second argument.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsridapp= \begin{semcalc}\begin{semrule}[ ]\rsridapp\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsridabs[sidenote][assignment][arg][var][replacement][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{arg(def=\ensuremath{\bm{\alpha}})}: The argument.
					\item[] \texttt{var(def=\textit{x})}: The variable to be replaced.
					\item[] \texttt{replacement(def=\textit{u})}: The variable replacement.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsridabs= \begin{semcalc}\begin{semrule}[ ]\rsridabs\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Quantifier Raising Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrsemvar[sidenote][leftTerm][var][situation][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{leftTerm(def=$\phi$)}: The var. for the left term.
					\item[] \texttt{var(def=\textbf{\textit{x}})}: The variable to be replaced.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrsemvar= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrsemvar\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrabs[sidenote][rightTerm][replacement][situation][assignment][function][original][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{rightTerm(def=$\phi$)}: The var. for the left term.
					\item[] \texttt{replacement(def=\textbf{\textit{x}})}: The variable to be replaced.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{function(def=\textit{f})}: The assignment function var.
					\item[] \texttt{original(def=$\xi$)}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrabsr= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrabs\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrlex[sidenote][leftTerm][rightTerm][replacement][situation][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{leftTerm(def=$\alpha$)}: The left term.
					\item[] \texttt{rightTerm(def=$\beta$)}: The right term.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrlex= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrlex\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrfa[sidenote][leftTerm][rightTerm][rightArgTerm][situation][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{leftTerm(def=$\alpha$)}: The left term.
					\item[] \texttt{rightTerm(def=$\beta$)}: The right term.
					\item[] \texttt{rightArgTerm(def=$\gamma$)}: The right argument term.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrfa= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrfa\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrtree[sidenote][lambda][leftTerm][rightTerm][replacement][situation][assignment][type][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{lambda(def=\textit{x})}: The lambda head and replacement.
					\item[] \texttt{leftTerm(def=$\psi$)}: The left term.
					\item[] \texttt{rightTerm(def=$\phi$)}: The right term.
					\item[] \texttt{replacement(def=$\xi$)}: The assignment function modification var.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{type(def=\typee)}: The type of the lambda head.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrtree= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrtree\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semrulesyn}
	The \textit{semantic-rule-syn} is an optional environment and is used to list all syntactic rules used for a derivation of a direct or indirect semantic expressions. Each syntactic rule gets automatically label (if used via \verb=\rentry= or predefined syntactical rule) with the following pattern: \\"sem:deri:refNamers:rulecounter". So the first syntactical rule in the second semcalc env. will have the following label: "sem:deri:2:rs:1" assuming that no custom refName has been set.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semrulesyn}[label]
			content...
			\end{semrulesyn}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for syntactic rules.
				\item[] New Commands: No
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semlex}
	The \textit{semantic-lexicon} environment is used to list all lexicon entries used for a derivation of a direct or indirect semantic expressions. Each lexicon entry gets automatically label (if used via \verb=\rentry= or predefined lexicon entry) with the following pattern: \\"sem:deri:refName:l:lexcounter". So the first lexicon entry in the second semcalc env. will have the following label: "sem:deri:2:l:1" assuming that no custom refName has been set.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semlex}[label]
			content...
			\end{semlex}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for easy listing of semantic lexicon entries.
				\item[] New Commands: Yes
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Commands}
	The \FraGoLi\ package offers the most common semantic lexicon entries for both direct and indirect interpretation based on the accompanying material to an introductory course to linguistic semantics by \textit{T. E. Zimmermann}. All pre-defined lexicon entries can be custemized with aspect to variables and lambda heads. General commands for fast rule lexicon creation are also featured. All commands start with sl (semantic lexicon) followed by a categorization into direct (plus intension/extension) or indirect (plus translation/denotation) e.g. \verb=\sldenn= for \\\texttt{semantic-lexicon-direct-extension-properName}. All pre-defined lexicon entries have the option to add a sidenote. If the package otpion \texttt{usetypes} is enabled all pre-defined rules will show the type on each lambda head.
	\\Direct Interpretation Lexicon Extension
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldex{word}[lambdaBody][sidenote][var][situation][type][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var}} \texttt{word} in \sstar}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var(def=x)}: Lambda head variable.
					\item[] \texttt{situation(def=\sstar)}: The situation
					\item[] \texttt{type(def=\type{e})}: The type of the lambda head variable.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for intransitive verbs or adjectives.
				\item[] Example: \verb=\sldex{sleeps}= \begin{semcalc}\begin{semlex}[ ]\sldex{sleeps}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldey{word}[lambdaBody][sidenote][var1][var2][situation][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var1}} \texttt{word} \textit{\texttt{var2}} in \sstar}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=x)}: Inner lambda head variable.
					\item[] \texttt{var2(def=y)}: Outer lambda head variable.
					\item[] \texttt{situation(def=\sstar)}: The situation
					\item[] \texttt{type1(def=\type{e})}: The type of the inner lambda head variable.
					\item[] \texttt{type2(def=\type{e})}: The type of the outer lambda head variable.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for transitive verbs.
				\item[] Example: \verb=\sldey{kills}= \begin{semcalc}\begin{semlex}[ ]\sldey{kills}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldez{word}[lambdaBody][sidenote][var1][var2][var3][situation][type1][type2]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for.
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var1}} \texttt{word} \textit{\texttt{var2}} in \sstar}.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=x)}: Inner lambda head variable.
					\item[] \texttt{var2(def=y)}: Middle lambda head variable.
					\item[] \texttt{var3(def=z)}: Outer lambda head variable.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{type1(def=\type{e})}: The type of the inner lambda head variable.
					\item[] \texttt{type2(def=\type{e})}: The type of the middle and outer lambda head variable.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for ditransitive verbs.
				\item[] Example: \verb=\sldez{shows}= \begin{semcalc}\begin{semlex}[ ]\sldez{shows}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldenn{name}[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name to create the lexicon entry for.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=\sstar)}: The situation
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for proper names.
				\item[] Example: \verb=\sldenn{Peter}= \begin{semcalc}\begin{semlex}[ ]\sldenn{Peter}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	A little set of common semantic names is pre-defined like \verb=\sldennpeter=. Those names are \zit{Peter, Maria, Anna, Paul, Eike, Ida, Olaf, Michael, Alina, Marta}. All pre-defined names can have sidenotes, custom situations and labels. The command syntax would be 
	\\\verb=\sldennpeter[sidenote][situation][label]=.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slden{nominal}[article][sidenote][var][situation][type][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{noun}: The nominal to create the lexicon entry for.
					\item[] \texttt{article(def=a)}: The article in the lambda boy (will be switched to \textit{ein} if language is set to german). If empty this will also be the case.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var(def=x)}: The lambda head variable
					\item[] \texttt{situation(def=\sstar)}: The situation
					\item[] \texttt{type(def=\type{e})}: The lambda head var type.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for proper names.
				\item[] Example: \verb=\slden{Cat}= \begin{semcalc}\begin{semlex}[ ]\slden{Cat}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	A little set of common semantic nominals is pre-defined like \verb=\sldenman=. Those will fully translate if language is set to \textit{german}. All pre-defined nominals can have sidenotes, custom lambda heads, situations, types and labels. The command syntax would be 
	\\\verb=\sldenman[sidenote][var][situation][type][label]=.
	\begin{center}
		\begin{minipage}[h][3.5cm][t]{15em}
			\begin{lstlisting}[style=B]
			\sldenman
			\sldenwoman
			\sldenchild
			\sldendog
			\sldencat
			\sldenanimal
			\sldenhouse
			\sldendonkey
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3.5cm][t]{15em}
			\begin{fgls}
				\ \\
				Mann\\
				Woman\\
				Child\\
				Dog\\
				Cat\\
				Animal\\
				House\\
				Donkey
			\end{fgls}
		\end{minipage}
	\end{center}
	Direct Interpretation Lexicon Intension
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldix{word}[lambdaBody][sidenote][var][situation][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var}} \texttt{word} in \texttt{situation}}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var(def=x)}: Lambda head variable.
					\item[] \texttt{situation(def=\sblank)}: The situation
					\item[] \texttt{type1(def=\type{e})}: The type of the lambda head variable.
					\item[] \texttt{type2(def=\type{s})}: The type of the situation lambda head variable (should be used if you want to display the type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for intransitive verbs or adjectives.
				\item[] Example: \verb=\sldix{sleeps}= \begin{semcalc}\begin{semlex}[ ]\sldix{sleeps}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldiy{word}[lambdaBody][sidenote][var1][var2][situation][type1][type2][type3]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var}} \texttt{word} in \texttt{situation}}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var(def=x)}: Lambda head variable.
					\item[] \texttt{var2(def=y)}: Lambda head variable.
					\item[] \texttt{situation(def=\sblank)}: The situation
					\item[] \texttt{type1(def=\type{e})}: The type of the inner lambda head variable.
					\item[] \texttt{type2(def=\type{e})}: The type of the middle lambda head variable.
					\item[] \texttt{type3(def=\type{s})}: The type of the situation lambda head variable (should be used if you want to display the type).
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for intransitive verbs or adjectives.
				\item[] Example: \verb=\sldiy{kills}= \begin{semcalc}\begin{semlex}[ ]\sldiy{kills}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldiz{word}[lambdaBody][sidenote][var1][var2][var3][situation][type1][type2]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var}} \texttt{word} in \texttt{situation}}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var(def=x)}: Lambda head variable.
					\item[] \texttt{var2(def=y)}: Lambda head variable.
					\item[] \texttt{var3(def=z)}: Lambda head variable.
					\item[] \texttt{situation(def=\sblank)}: The situation
					\item[] \texttt{type1(def=\type{e})}: The type of the inner middle and second middle lambda head variable.
					\item[] \texttt{type2(def=\type{s})}: The type of the situation lambda head variable (should be used if you want to display the type).
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for intransitive verbs or adjectives.
				\item[] Example: \verb=\sldiz{shows}= \begin{semcalc}\begin{semlex}[ ]\sldiz{shows}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldinn{name}[sidenote][situation][type][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name to create the lexicon entry for.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{situation(def=\sblank)}: The situation
					\item[] \texttt{type(def=\type{s})}: The situation type (should be used to display the type)
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for proper names.
				\item[] Example: \verb=\sldinn{Peter}= \begin{semcalc}\begin{semlex}[ ]\sldinn{Peter}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Indirect Interpretation Lexicon Translation
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slit{left}{right}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument
					\item[] \texttt{right}: Right argument.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation.
				\item[] Example: \verb=\slit{Left}{Right}= \begin{semcalc}\begin{semlex}[ ]\slit{Left}{Right}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitnn{name}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect proper name translation.
				\item[] Example: \verb=\slitnn{Peter}= \begin{semcalc}\begin{semlex}[ ]\slitnn{Peter}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	A little set of common semantic names is pre-defined like \verb=\slitnnpeter=. Those names are \zit{Peter, Maria, Anna, Alina, Marta, Paul, Eike, Ida, Olaf, Michael}. All pre-defined names can have sidenotes, custom situations and labels. The command syntax would be 
	\\\verb=\slitnnpeter[sidenote][situation][label]=.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitf{name}[situation][sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name.
					\item[] \texttt{situation(def=i)}: The situation var.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect function translation.
				\item[] Example: \verb=\slitf{sleeps}= \begin{semcalc}\begin{semlex}[ ]\slitf{sleeps}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitland[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation.
				\item[] Example: \verb=\slitland= \begin{semcalc}\begin{semlex}[ ]\slitland\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlor[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=q)}: First lambda head variable.
					\item[] \texttt{var2(def=p)}: Second lambda head variable.
					\item[] \texttt{type1}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2}: Secon lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation.
				\item[] Example: \verb=\slitlor= \begin{semcalc}\begin{semlex}[ ]\slitlor\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlno[sidenote][var1][var2][var3][type1][type2][type3][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var2(def=x)}: Bound variable (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier no.
				\item[] Example: \verb=\slitlno= \begin{semcalc}\begin{semlex}[ ]\slitlno\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitloneindef[sidenote][var1][var2][var3][type1][type2][type3][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var3(def=x)}: Bound variable (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier one (indefinite).
				\item[] Example: \verb=\slitloneindef= \begin{semcalc}\begin{semlex}[ ]\slitloneindef\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlonenum[sidenote][var1][var2][var3][var4][type1][type2][type3][type4]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var3(def=x)}: Bound variable outer (existential)
					\item[] \texttt{var4(def=y)}: Bound variable inner (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{type4(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier one (numerical).
				\item[] Example: \verb=\slitlonenum= \begin{semcalc}\begin{semlex}[ ]\slitlonenum\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlevery[sidenote][var1][var2][var3][type1][type2][type3][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var3(def=x)}: Bound variable (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier every.
				\item[] Example: \verb=\slitlevery= \begin{semcalc}\begin{semlex}[ ]\slitlevery\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlmost[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier most.
				\item[] Example: \verb=\slitlmost= \begin{semcalc}\begin{semlex}[ ]\slitlmost\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitldefarticle[sidenote][var1][var2][var3][var4][type1][type2][type3][type4]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var3(def=x)}: Bound variable outer (existential)
					\item[] \texttt{var4(def=y)}: Bound variable inner (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{type4(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of definite article (Russell style).
				\item[] Example: \verb=\slitldefarticle= \begin{semcalc}\begin{semlex}[ ]\slitldefarticle\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitadox[sidenote][var1][var2][var3][var4][type1][type2][type3][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=p)}: First lambda head variable.
					\item[] \texttt{var2(def=x)}: Second lambda head variable.
					\item[] \texttt{var3(def=j)}: Bound variable outer (existential)
					\item[] \texttt{var4(def=i)}: Bound variable inner (existential)
					\item[] \texttt{type1(def=\type{st})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{e})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{s})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of hintikka semantics. For other perspectives use \verb=\slitaepi= or \verb=\slitabou=.
				\item[] Example: \verb=\slitadox= \begin{semcalc}\begin{semlex}[ ]\slitadox\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Indirect Interpretation Lexicon Denotation
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slid{left}{right}[sidenote][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument
					\item[] \texttt{right}: Right argument.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation.
				\item[] Example: \verb=\slid{Left}{Right}[][g]= \begin{semcalc}\begin{semlex}[ ]\slid{Left}{Right}[][g]\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidnn{name}[sidenote][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name.
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of a proper name constant.
				\item[] Example: \verb=\slidnn{Peter}= \begin{semcalc}\begin{semlex}[ ]\slidnn{Peter}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	A little set of common semantic names is pre-defined like \verb=\slidnnpeter=. Those names are \\\zit{Peter, Maria, Anna, Alina, Marta, Paul, Eike, Ida, Olaf, Michael}. All pre-defined names can have sidenotes, custom assignment functions and labels. The command syntax would be 
	\\\verb=\slidnnpeter[sidenote][assignment][label]=.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidland[sidenote][var1][var2][assignment][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=v)}: First lambda head variable.
					\item[] \texttt{var2(def=u)}: Second lambda head variable.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{type1(def=\type{t})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{t})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of the logical constant and.
				\item[] Example: \verb=\slidland= \begin{semcalc}\begin{semlex}[ ]\slidland\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidlexists[sidenote][var1][assignment][type1][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=P)}: First lambda head variable.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{type1(def=\type{t})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of the existential quantifier.
				\item[] Example: \verb=\slidlexists= \begin{semcalc}\begin{semlex}[ ]\slidlexists\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidlneg[sidenote][var1][assignment][type1][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=u)}: First lambda head variable.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{type1(def=\type{t})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of the  negation.
				\item[] Example: \verb=\slidlneg= \begin{semcalc}\begin{semlex}[ ]\slidlneg\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidlequal[sidenote][var1][assignment][type1][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=y)}: First lambda head variable.
					\item[] \texttt{var2(def=x)}: Second lambda head variable.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{type1(def=\type{t})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{t})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of the  negation.
				\item[] Example: \verb=\slidlequal= \begin{semcalc}\begin{semlex}[ ]\slidlequal\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidadox[sidenote][var1][assignment][type1][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Sidenote text.
					\item[] \texttt{var1(def=x)}: First lambda head variable.
					\item[] \texttt{var2(def=\szero)}: Second lambda head variable.
					\item[] \texttt{var2(def=\sone)}: Third lambda head variable.
					\item[] \texttt{type1(def=\type{e})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{s})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{s})}: Third lambda head variable type (should be used to display type).
					\item[] \texttt{assignment}: The assignment function.
				\end{itemizeexamplecommand}
				\item[] Description: General indirect interpretation of hintikka semantics. For other perspectives use \verb=\slidaepi= or \verb=\slidabou=. Text gets automatically translated.
				\item[] Example: \verb=\slidadox= \begin{semcalc}\begin{semlex}[ ]\slidadox\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semderi}
	The \textit{semantic-derivation} environment is a specialized version of the \textit{semderivation} env. and is tweaked to work inside a \textit{semcalc} env.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semderi}[label]
			content...
			\end{semderi}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for easy derivation of direct or indirect semantic expressions.
				\item[] New Commands: Yes
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Constants}
	This env. has the same new constants as the \textit{semderivation} env.
	\subsubsection{Commands}
	This env. has the same new commands as the \textit{semderivation} env.
	\section{Changelog}
	\begin{itemize}
		\item[1.1.1] 
				\begin{enumerate}
					\item[-] Fix missing package dependency.
					\item[-] Fix text overline overriding uuline internal length.
					\item[-] Fix parentheses on lambda quantifier heads being bold in non bold mode.
					\item[-] Add lambdaheadstyle package option.
					\item[-] Add new fuction framework.
					\item[-] Add new logic commands.
					\item[-] Add new logic constants.
					\item[-] Add new relation constants.
					\item[-] Add new quantifier commands.
					\item[-] Extend set command.
				\end{enumerate}
		\item[1.0.0] 
		\begin{enumerate}
			\item[-] Initial release.
		\end{enumerate}
		\item[0.2.2] 
		\begin{enumerate}
			\item[-] Add option to set default the default situation in the fgls, semrule, semcalc and semderivation env.
			\item[-] Add current situation command and current derivation ref command.
			\item[-] Automatic labels for all semcalc resources and for all derivation steps.
			\item[-] Add rules from the Quantifier Raising Script by Dr. C\'{e}cile Meier.
			\item[-] Add sarrow command.
			\item[-] Add semrulesyn env.
			\item[-] Add semtreesyn and semtreesem env.
			\item[-] Add semlang env.
			\item[-] Add language builder command to semlang env.
			\item[-] Add traces
		\end{enumerate}
		\item[0.1.2] 
		\begin{enumerate}
			\item[-] Add semtree environment.
			\item[-] Fixed derivation step counter.
			\item[-] Fixed various documentation bugs.
		\end{enumerate}
		\item[0.0.1] 
		\begin{enumerate}
			\item[-] First build.
		\end{enumerate}
	\end{itemize}
\end{document}