% TODO: unify changes
% a? <. T can be deleted in the last step
% remove lessdotCC constraints completely
% delete wildcard tphs a? when needed
% aswell ass free variables:
% a <. T with fv(T) not empty and not in \Delta' must be removed by U = L
% also in T <. T constraints no free variables are allowed on both sides
% the algorithm only removes wildcards, never adds them

\section{Unify}\label{sec:unify}

%TODO: Remove lessdotC constraints. those have to be handeld during constraint generation
% is capture conversion for methods in the same class unsovable? Can it be reduced to polymorphic recursion?
% the other problem is, that there are infinite subtypes.
% For example for a type X^Infinite<X>.Infinite<X>
% here a correct subtype would be an instantiation of the class Omega extends Infinite<Omega> 

The parameter types given to a generic method also affect their return type.
During constraint generation the algorithm does not know the parameter types yet.
We generate $\lessdotCC$ constraints and let \unify{} do the capture conversion.
$\lessdotCC$ constraints are kept until they reach the form $\type{G} \lessdotCC \type{G}$ and a capture conversion is possible.

% A method has infinte possibilities of being called and there is no most general type.
% P<X,Y> m(C<X> c, C<Y> c2)
% depending on 
% A.P<A,A> <. A,B.P<A,B>

% % During the method call it is not sure what kind of return type is needed from the method.
% % The method P<A,B> make(A a, B b) 
% % The type A,B.P<A,B> cannot be a subtype of P<X,X>
% % But if A^X_X and B^X_X
% % Could a constraint C<X> <. a? be expanded to a? = X^u?_l?.C<X>

% Why is there no most general type?
% - the return type depends on the parameter types
The most general type denotable in Java of a class $\exptype{C}{\ol{X}}$
is $\wctype{\ol{X}}{C}{\ol{X}}$

%Is there a direct subtype of a type N including generics? e.g. a <c C<C<x>> 
% AND if yes! why is there not a most generic expression of a method head without the need of Capture Conversion?
% Pair<X,Y> m(List<X> l, List<Y> l2) => X,Y.Pair<X,Y> m()
% X.List<X> <. List<x>
% because we want the most specfic return type and the least specific parameter types!


A method is only equiped with generic parameters if they only appear in a <. T constraints
Polymorphic recursion makes it impossible to infer a generic type who is called in a more specific way.
Is it? Not ours for sure!

The problem is, that we don't know which type is the parameter of the method call.
And a method with a parameter \texttt{List<? extends A>} can have an infinite number of subtypes. %Does it?
% Y.List<Y> <c Z^List<x>.List<Z>
% Y <. List<x>

% X,Y^List<X>.List<Y> <c Z^List<x>.List<Z>

% The idea is to hold out until the left side of a $\lessdotCC$ constraint is known to be a named type
% and then check if the typing is still correct.


The wildcard placeholders are used for intermediat types.
It is not possible to create all super types of a type.
The General rule only creates the ones expressable by Java syntax, which still are infinitly many in some cases \cite{TamingWildcards}.
%thats not true. it can spawn X^T_T2.List<X> where T and T2 are types and we need to choose one inbetween them
Otherwise the algorithm could generate more solutions, but they have to be filterd out afterwards, because they cannot be translated into Java.

Any type can be inserted into wildcard placeholders.
Normal placeholders have to contain types, which are well-formed under the supplied environment.
% It is important that the algorithm also works for any subset of constraints
%TODO: The unify algorithm can do any operation on wildcard placeholders the same as on normal ones.
%TODO: Unify could make way more substitutions for wtvs especially in step 2

\subsection{Description}
The \unify{} algorithm tries to find a solution for a set of constraints like
$\set{\exptype{List}{String} \lessdot \tv{a}, \exptype{List}{Integer} \lessdot \tv{a}}$.
Those two constraints imply that we have to find a type replacement for type variable $\tv{a}$,
which is a supertype of $\exptype{List}{String}$ aswell as $\exptype{List}{Integer}$.

The algorithm works in a recursive fashion.
The input constraints are transformed until they reach a irreducible state,
which the last step of the algorithm eventually transforms into a solution.
A constraint set is convertable to a correct type solution if it only contains constraints of the form
$\tv{a} \doteq \type{T}$ (where $\tv{a} \notin \text{tph}(\type{T})$) and $\tv{a} \lessdot \type{T}$.
We call this \textit{Solved Form}.

The \unify{} algorithm applies conversions according to the subtyping rules (depicted in figure \ref{fig:subtyping}).
At every step we try to find a reduction, which brings us closer to solved form without excluding any possible solution.

A $\bot \lessdot \type{T}$ constraint is always satisfied and can be ignored. It will be removed by the \rulename{Bot} rule.
For the type placeholder $\tv{a}$ in the constraint $\tv{a} \lessdot \bot$ only the $\bot$ type is a possible substitution,
which is set by the \rulename{Pit} rule.

The \rulename{Reduce} rule represents the S-Exists type rule.
This rule uses wildcard placeholders ($\ol{\wtv{a}}$) to find a possible substitution for the wildcards on the right side.
The constraint $\type{N} \lessdot \wcNtype{\overline{\wildcard{X}{\type{U}}{\type{L}}}}{N'}$ is satisfied if
there is a substitution $[\ol{T}/\ol{X}]\type{N} = \type{N'}$ with $\ol{T}$ inside the bounds $\ol{U}$ and $\ol{L}$.

\textbf{Example:}
$\exptype{List}{\tv{a}} \lessdot \wctype{\wildcard{X}{\type{Object}}{\bot}}{List}{\rwildcard{X}}$ 
The \rulename{Reduce} rule converts this to 
$\set{\tv{a} \doteq \wtv{x}, \wtv{x} \lessdot \type{Object}, \bot \lessdot \wtv{x} }$.
After applying \rulename{Swap} and \rulename{Subst-WC} on $\tv{a} \doteq \wtv{x}$ we get
$\set{\tv{a} \lessdot \type{Object}, \bot \lessdot \tv{a}}$ and can now apply the \rulename{Bot} rule.

The \rulename{Erase} rule will remove redundant $\type{T} \doteq \type{T}$ constraints.
But what about constraints like $\wctype{\wildcard{X}{\tv{a}}{\tv{b}}}{List}{\rwildcard{X}} \doteq \wctype{\wildcard{Y}{\type{Object}}{\tv{String}}}{List}{\rwildcard{Y}}$
The \rulename{Equals} rule converts this to 

% The equals rule is complicated, because 
% X.List<X> =. Y.List<Y> -> is the same
% X^String.List<X> =. X.List<X> -> is not!

% T =. T => T <. T


% Special cases: lessdotCC, Normalize/Tame rule, 
The $\lessdotCC$ constraints and the wildcard placeholders $\wtv{a}$ are kept as long as possible.
%TODO: Example where lessdotCC constraints get spared until they can be captured

\subsection{Algorithm}

\newcommand{\gtype}[1]{\type{#1}}
%\newcommand{\tw}[1]{\tv{#1}_?}
The \unify{} algorithm computes the type solution.

\begin{description}
  \item[Input:] An environment $\Delta'$
and a set of constraints $C = \set{ \type{T} \lessdot \type{T}, \type{T} \doteq \type{T} \ldots}$
and a list of constraints $C' = \set{ \type{T} \lessdotCC \type{T}}$.
The input constraints must be of the following format:

\begin{tabular}{lcll}
    $c $ &$::=$ & $\type{T} \lessdot \type{T}, \type{T} \lessdotCC \type{T}$ & Constraint \\
    $\type{T}, \type{U}, \type{L} $ & $::=$ & $\ntv{a} \mid \wtv{a} \mid \ntype{N}$ & Type variable or Wildcard Variable or Type \\
    $\ntype{N}, \ntype{S}$ & $::=$ & $\wctype{\overline{\wildcard{X}{U}{L}}}{C}{\ol{T}} $ & Class Type \\
\end{tabular}\\[0.5em]

\noindent
Additional requirements:
\begin{itemize}
\item Every wildcard $\rwildcard{X} \in \Delta'$ has to have an unique name which is not defined anywhere in the constraint set $C$.
  \item The input only consists of $\lessdot$ constraints
%   \item No free variables in type parameters.
% A constraint like $\tv{a} \lessdot \exptype{List}{\rwildcard{X}}$ is prohibited.
% $\tv{a} \lessdot \wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ is valid.
  \item the input is a list of constraints. It cannot be a set.
  A constraint set containing the constraint $\tv{a} \lessdot \type{T}$ twice
  is a different to one that contains it only once.
  %\item every wildcard is bound to its enclosing type.
  \item All types have to be well-formed: $\wcNtype{\Delta}{N} \in C \implies \Delta_{in} \vdash \wcNtype{\Delta}{N} \ \ok$
\item Naming scheme of every wildcard environment has to be the same.
%TODO: We need this so that wildcard substitutions get the correct name. also the Equals rule needs this condition
%Example: 
Although alpha renaming of wildcards inside a type is allowed by the type system the \unify{} algorithm never does it.
Renaming wildcards leads to additional problems in the substitution rules and in the result containing substitutions with renamed wildcards.
For the \rulename{Equals} to work properly it is adviced to name all wildcards in a specific scheme.
For example by numbering them according to their appereance inside the type parameters
(e.g. $\wctype{\rwildcard{1}, \rwildcard{2}}{Pair}{\rwildcard{1}, \rwildcard{2}}$).
\end{itemize}

\item[Output:]
Set of unifiers $Uni = \set{\sigma_1, \ldots, \sigma_n}$ and an environment $\Delta$
\end{description}

The \unify{} algorithm internally uses the following data types:

\begin{tabular}{lcll}
    $C $ &$::=$ &$\overline{c}$ & Constraint set \\
    $c $ &$::=$ & $\type{T} \lessdot \type{T} \mid \type{T} \lessdotCC \type{T} \mid \type{T} \doteq \type{T}$ & Constraint \\
    $\type{T}, \type{U}, \type{L} $ & $::=$ & $\tv{a} \mid \gtype{G}$ & Type placeholder or Type \\
    $\tv{a}$ & $::=$ & $\ntv{a} \mid \wtv{a}$ & Normal and wildcard type placeholder \\
    $\gtype{G}$ & $::=$ & $\type{X} \mid \ntype{N}$ & Wildcard, or Class Type \\
    $\ntype{N}, \ntype{S}$ & $::=$ & $\wctype{\triangle}{C}{\ol{T}} $ & Class Type \\
    $\triangle$ & $::=$ & $\overline{\wtype{W}}$ & Wildcard Environment \\
    $\wtype{W}$ & $::=$ & $\wildcard{X}{U}{L}$ & Wildcard \\
\end{tabular}

The $\wtv{a}$ type variables are flagged as wildcard type variables.
These type variables can be substituted by a wildcard or a type with free wildcard variables.
As long as a type variable is flagged with as $\wtv{a}$ it will only be used by the subst-wc rule in step 1.
In step 2 all of the wildcard flags are dismissed.
The output therefore never contains these flags.

\unify{} applies a capture conversion everywhere it is possible (see \rulename{Capture} rule).
Capture conversion removes a types bounding environment $\Delta$.
Type variables used in its type parameters are now bound to a global scope and not locally anymore.

With \texttt{C} being class names and \texttt{A} being wildcard names.
The wildcard type $\wildcard{X}{U}{L}$ consist of an upper bound $\type{U}$, a lower bound $\type{L}$
and a name $\mathtt{X}$.

The \rulename{Normalize} rule eliminates wildcards. % TODO
This is done by setting the upper and lower bound to the same value.
\unify{} generates wildcards with the \rulename{\generalizeRule} rule.
It is important to generate new wildcards in a standardized fashion.
When having two constraints $\type{T} \lessdot \tv{a}$ and $\type{T} \lessdot \tv{b}$,
then after applying the \rulename{\generalizeRule} rule the freshly generated constraints are
$\tv{a} \doteq \type{T'}, \tv{b} \doteq \type{T'}$.
Both type variables get assigned the same type.
This is necessary for the \rulename{Equals} rule to work properly.


\begin{figure}
  \begin{center}
    \leavevmode
    \fbox{
    \begin{tabular}[t]{l@{~}l}
      \rulename{Subst} &
                       $\begin{array}[c]{l}
  \wildcardEnv \vdash C \cup \set{\ntv{a} \doteq \type{T}}\\
                         \hline
  [\type{T}/\tv{a}]\wildcardEnv \vdash [\type{T}/\tv{a}]
  C \cup \set{\ntv{a} \doteq \type{T}}
                       \end{array}
                     \quad \begin{array}{c}
                      \ntv{a} \notin \type{T} \\
                      \text{fv}(\type{T}) \subseteq \Delta', \, \text{wtv}(\type{T}) = \emptyset
                     \end{array}$\\
  \\
  \rulename{Remove} &
                   $\begin{array}[c]{l}
\wildcardEnv \vdash C \cup \set{\ntv{a} \doteq \type{T}}\\
                     \hline
[\ntv{b}/\wtv{b}]\wildcardEnv \vdash [\ntv{b}/\wtv{b}]
C \cup \set{\ntv{a} \doteq [\ntv{b}/\wtv{b}]\type{T}}
                   \end{array}
                 \quad \begin{array}{c}
                  \wtv{b} \in \text{wtv}(\type{T})\\
                  \ntv{b} \ \text{fresh}
                 \end{array}$\\
\\
\rulename{Subst-WC} &$
                 \begin{array}[c]{l}
\wildcardEnv \vdash C \cup \set{\wtv{a} \doteq \rwildcard{T}}\\
                   \hline
[\type{T}/\wtv{a}]\wildcardEnv \vdash [\type{T}/\wtv{a}]C 
                 \end{array} \quad \wtv{a} \notin \type{T}
$
\end{tabular}}
\end{center}
\caption{Substitution rules}\label{fig:subst-rules}
\end{figure}


\begin{figure}
  \begin{center}
    \leavevmode
    \fbox{
    \begin{tabular}[t]{l@{~}l}
    % \rulename{normalize}
    % & $
    % \begin{array}[c]{l}
    % \wildcardEnv \cup \set{\wildcard{A}{\type{U}}{\type{L}}, \wildcard{B}{U'}{L'}} \vdash C \cup \, \set{ \rwildcard{A} \doteq \rwildcard{B}  } \\ 
    % \hline
    % \vspace*{-0.4cm}\\
    % \wildcardEnv \cup \set{\wildcard{A}{\type{U}}{\type{L}}, \wildcard{B}{U'}{L'}} \vdash C \cup \, \set{ \type{L} \doteq \type{U} , \type{U} \doteq \type{U'}, \type{L} \doteq \type{L'}   }
    % \end{array}
    % $
    % \\\\
    \rulename{Upper}
    & $
    \begin{array}[c]{l}
    \wildcardEnv \cup \set{\wildcard{A}{U}{L}} \vdash C \cup \, \set{ \type{A} \lessdot \type{G} } \\ 
    \hline
    \vspace*{-0.4cm}\\
    \wildcardEnv \cup \set{\wildcard{A}{U}{L}} \vdash C \cup \, \set{ \type{U} \lessdot \type{G}   }
    \end{array}
    \quad \quad
    \begin{array}[c]{l} %TODO: can the second part be removed by adding a X.C<X> <. C<a?> constraint at method invocation?
    \wildcardEnv \cup \set{\wildcard{A}{U}{L}} \vdash C \cup \, \set{ \type{A} \lessdotCC \type{G} } \\ 
    \hline
    \vspace*{-0.4cm}\\
    \wildcardEnv \cup \set{\wildcard{A}{U}{L}} \vdash C \cup \, \set{ \type{U} \lessdotCC \type{G}   }
    \end{array}
    $
    \\\\
    \rulename{Lower}
    & $
    \begin{array}[c]{l}
    \wildcardEnv \cup \set{\wildcard{A}{U}{L}} \vdash C \cup \set{ \type{G} \lessdot \type{A} } \\ 
    \hline
    \vspace*{-0.4cm}\\
    \wildcardEnv \cup \set{\wildcard{A}{U}{L}} \vdash C \cup  \set{ \type{G} \lessdot \type{L} }
    \end{array}
    $
    \\\\
    \rulename{Lower}
    & $
    \begin{array}[c]{l}
    \wildcardEnv \cup \set{\wildcard{A}{U}{L}} \vdash C \cup \set{ \ntv{a} \lessdot \type{A} } \\ 
    \hline
    \vspace*{-0.4cm}\\
    \wildcardEnv \cup \set{\wildcard{A}{U}{L}} \vdash C \cup  \set{ \ntv{a} \lessdot \type{L} }
    \end{array} \quad \type{A} \notin \Delta_{in}
    $ %TODO: a <. X with X in Delta_in => a =. X 
    % other possibliity: is it allowed to see X extends List<X> as class X extends List<X> {}
    % other way round: every class declaration comes in Delta_in
    \\\\
    \rulename{Bot}
    & $
    \begin{array}[c]{l}
    \wildcardEnv \vdash C \cup \set{ \bot \lessdot \type{T} } \\ 
    \hline
    \vspace*{-0.4cm}\\
    \wildcardEnv \vdash C 
    \end{array}
    $
    \\\\
    \rulename{Pit}
    & $
    \begin{array}[c]{l}
    \wildcardEnv \vdash C \cup \set{ \tv{a} \lessdot \bot } \\ 
    \hline
    \vspace*{-0.4cm}\\
    \wildcardEnv \vdash C \cup \set{ \tv{a} \doteq \bot }
    \end{array}
    $
    \\\\
\end{tabular}}
\end{center}
\caption{Wildcard reduce rules}\label{fig:wildcard-rules}
\end{figure}

\begin{figure}
  \begin{center}
    \leavevmode
    \fbox{
    \begin{tabular}[t]{l@{~}l}
% \rulename{normalize} %obsolete because of Tame
%     & $
%     \begin{array}[c]{l}
%     \wildcardEnv \cup \set{\wildcard{A}{\type{U}}{\type{L}}, \wildcard{B}{U'}{L'}} \vdash C \cup \, \set{ \rwildcard{A} \doteq \rwildcard{B}  } \\ 
%     \hline
%     \vspace*{-0.4cm}\\
%     \wildcardEnv \cup \set{\wildcard{A}{\type{U}}{\type{L}}, \wildcard{B}{U'}{L'}} \vdash C \cup \, \set{ \type{L} \doteq \type{U} , \type{U'} \doteq \type{L'}, \type{U} \doteq \type{U'}  }
%     \end{array}
%     % \quad \text{fv}(\type{U}, \type{U'}, \type{L}, \type{L'}) \subseteq \Delta_in
%     $
%     \\\\
\rulename{Tame}
    & $
    \begin{array}[c]{l}
    \wildcardEnv \cup \set{\wildcard{A}{\type{U}}{\type{L}}} \vdash C \cup \, \set{ \rwildcard{A} \doteq \type{T}  } \\ 
    \hline
    \vspace*{-0.4cm}\\
    \wildcardEnv \cup \set{\wildcard{A}{\type{U}}{\type{L}}} \vdash C \cup \, \set{ \type{L} \doteq \type{T}, \type{U} \doteq \type{T} }
    \end{array} %\quad \text{fv}(\type{U}, \type{L}) \subseteq \Delta_in
      \quad \type{T} \ \text{is no wildcard placeholder}
    $
    \\\\
% \rulename{Equals} %TODO
%     & $
%     \begin{array}[c]{l}
%         \wildcardEnv \vdash C \cup \, \set{ \type{N} \doteq \type{N'} } \\ 
%         \hline
%         \vspace*{-0.4cm}\\
%         \wildcardEnv \vdash C \cup \, 
%         \set{
%            \type{N} \lessdot \type{N'}, \type{N'} \lessdot \type{N}
%         }
%     \end{array} % \quad \text{fv}(\type{N}) = \text{fv}(\type{N'}) = \emptyset 
%     $
%      \\\\
 \rulename{Equals} %TODO
& $
\begin{array}[c]{l}
    \wildcardEnv \vdash C \cup \, \set{ \wctype{\Delta}{C}{\ol{T}} \doteq \wctype{\Delta}{C}{\ol{T'}} } \\ 
    \hline
    \vspace*{-0.4cm}\\
    \wildcardEnv \vdash C \cup \, 
    \set{
      \pi(\ol{T}) \doteq  \pi(\ol{T'} )
      %\ol{T} \doteq \ol{T'}
    }
\end{array}
\quad \begin{array}{l}
\text{given a permutation}\ \pi\ \text{with:}\\
\pi(\Delta) = \pi(\Delta')
\end{array}
   $
   \\\\
    \rulename{Erase}
    & $
    \begin{array}[c]{l}
        \wildcardEnv \vdash C \cup \, \set{ \type{T} \doteq \type{T} } \\ 
        \hline
        \vspace*{-0.4cm}\\
        \wildcardEnv \vdash C
    \end{array}
    $
    \\\\
    \rulename{Erase}
    & $
    \begin{array}[c]{l}
        \wildcardEnv \vdash C \cup \, \set{ \type{T} \lessdot \type{T} } \\ 
        \hline
        \vspace*{-0.4cm}\\
        \wildcardEnv \vdash C 
    \end{array}
    $
    \\\\ 
    \rulename{Swap} & $
        \begin{array}[c]{l}
        \wildcardEnv \vdash C \cup \set{\type{G} \doteq \tv{a}}\\
        \hline
        \wildcardEnv \vdash C \cup \set{\tv{a} \doteq \type{G}}
        \end{array}
 \quad
        \begin{array}[c]{l}
        \wildcardEnv \vdash C \cup \set{\type{T} \doteq \wtv{a}}\\
        \hline
        \wildcardEnv \vdash C \cup \set{\wtv{a} \doteq \type{T}}
        \end{array} \quad
        \begin{array}[c]{l}
        \wildcardEnv \vdash C \cup \set{\type{N} \doteq \rwildcard{A}}\\
        \hline
        \wildcardEnv \vdash C \cup \set{\rwildcard{A} \doteq \type{N}}
        \end{array}$
\end{tabular}}
\end{center}
\caption{Constraint normalize rules}\label{fig:normalizing-rules}
\end{figure}

The \rulename{match} rule generates fresh wildcards $\overline{\wildcard{A}{\tv{u}}{\tv{l}}}$.
Their upper and lower bounds are fresh type variables.


\begin{figure}
  \begin{center}
      \leavevmode
      \fbox{
      \begin{tabular}[t]{l@{~}l}
        \rulename{Circle} & $
        \begin{array}[c]{l}
          \wildcardEnv \vdash C \cup \, \set{\tv{a}_1 \lessdot
          \tv{a}_2, \tv{a}_2 \lessdot \tv{a}_3, \dots, \tv{a}_n \lessdot \tv{a}_1}\\
          \hline
          \wildcardEnv \vdash C \cup \, \set{\tv{a}_1 \doteq \tv{a}_2, \tv{a}_2 \doteq \tv{a}_3, \dots , \tv{a}_n \doteq \tv{a}_1} 
        \end{array} \quad n>0
              $
      \end{tabular}}
  \end{center}
    \caption{Rules for normal placeholders}\label{fig:reduce-rules}
\end{figure}

\begin{figure}
    \begin{center}
        \leavevmode
        \fbox{
        \begin{tabular}[t]{l@{~}l}
          \rulename{Match} 
          & $
          \begin{array}[c]{@{}ll}
          \begin{array}[c]{l}
             \wildcardEnv \vdash C \cup \, \set{
                \tv{a} \lessdot_1 \wctype{\Delta}{D}{\ol{T}}, \tv{a} \lessdot_2 \wctype{\Delta'}{D'}{\ol{T'}} }\\ 
            \hline
            \vspace*{-0.4cm}\\
\wildcardEnv \vdash C \cup \, \left\{ \begin{array}[c]{l}
                \tv{a} \lessdot \wctype{\overline{\wildcard{A}{\tv{u}}{\tv{l}}}}{C}{\overline{\rwildcard{A}}},
              \ol{\tv{l}} \lessdot \ol{\tv{u}}, \\
            \wctype{\overline{\wildcard{A}{\tv{u}}{\tv{l}}}}{C}{\overline{\rwildcard{A}}}
                     \lessdot_1 \wctype{\Delta}{D}{\ol{T}}, \\
            \wctype{\overline{\wildcard{A}{\tv{u}}{\tv{l}}}}{C}{\overline{\rwildcard{A}}}
                     \lessdot_2 \wctype{\Delta'}{D'}{\ol{T'}}
\end{array}
\right\}
          \end{array}
          &\begin{array}[c]{l}
            \text{fresh}\ \overline{\wildcard{A}{\tv{u}}{\tv{l}}} \\
            \type{C} \ll \type{D}\\
            \type{C} \ll \type{D'} % TODO: THe match rule has to pick the most general type for C
         \end{array}
          \end{array}
          $
        \\\\ 
        \ruleReduceWC{}
        & 
        $
        \begin{array}[c]{@{}ll}
        \begin{array}[c]{l}
            \wildcardEnv \vdash 
            C \cup \, \set{ \exptype{C}{\ol{S}} \lessdot
            \wctype{\overline{\wildcard{A}{\type{U}}{\type{L}}}}{C}{\ol{T}} } \\ 
          \hline
          \vspace*{-0.4cm}\\
          \wildcardEnv
           \vdash C \cup \, \set{ 
           \ol{\type{S}} \doteq [\ol{\wtv{a}}/\overline{\rwildcard{A}}]\ol{\type{T}},
          \ol{\wtv{a}} \lessdot [\ol{\wtv{a}}/\overline{\rwildcard{A}}]\ol{U}, [\ol{\wtv{a}}/\overline{\rwildcard{A}}]\ol{L} \lessdot \ol{\wtv{a}} }
        \end{array}
         %\quad \ol{Y} = \textit{fresh}(\ol{X})
         \quad \begin{array}[c]{l}
          \ol{\wtv{a}} \ \text{fresh}\\
          %\text{fv}(\exptype{C}{\ol{S}}) \subseteq \text{dom}(\overline{\wildcard{B}{\type{U'}}{\type{L'}}})
          %\text{dom}(\overline{\wildcard{A}{\type{U}}{\type{L}}}) \subseteq \text{fv}(\exptype{C}{\ol{T}}) \\
          %\text{fv}(\wctype{\overline{\wildcard{A}{\type{U}}{\type{L}}}}{C}{\ol{T}}) = \emptyset
          \end{array}
        \end{array}
        $
      \\\\
      \rulename{Capture}
      & 
      $
      \begin{array}[c]{@{}ll}
      \begin{array}[c]{l}
          \wildcardEnv \vdash 
          C \cup \, \set{ \wctype{\overline{\wildcard{B}{\type{U}}{\type{L}}}}{C}{\ol{S}} \lessdotCC \type{T} } \\ 
        \hline
        \vspace*{-0.4cm}\\
        \wildcardEnv \cup \overline{\wildcard{C}{\type{U}}{\type{L}}}
         \vdash C \cup \, \set{  
          [\ol{\rwildcard{C}}/\ol{\rwildcard{B}}] \exptype{C}{\ol{S}} \lessdot \type{T} }
      \end{array}
       %\quad \ol{Y} = \textit{fresh}(\ol{X})
       \quad \begin{array}[c]{l}
        \ol{\rwildcard{C}} \ \text{fresh}\\
        %\text{fv}(\type{T}) \neq \emptyset
        \end{array}
      \end{array}
      $
    \\\\
      \rulename{Prepare} %The lessdotCC constraint only ensures that the left side looses its wildcardEnvironment.
      %It does not ensure that the left side doesn't contain free variables. If you want to ensure that you have to give the left side a normal placeholder
      & 
      $
      \begin{array}[c]{@{}ll}
      \begin{array}[c]{l}
          \wildcardEnv \vdash 
          C \cup \, \set{ \wctype{\Delta}{C}{\ol{S}} \lessdot \wctype{\Delta'}{C}{\ol{T}} } \\ 
        \hline
        \vspace*{-0.4cm}\\
          \wildcardEnv \vdash 
          C \cup \, \set{ \wctype{\Delta}{C}{\ol{S}} \lessdotCC \wctype{\Delta'}{C}{\ol{T}} } \\ 
      \end{array}
       %\quad \ol{Y} = \textit{fresh}(\ol{X})
       \quad \begin{array}[c]{l}
        \text{fv}(\wctype{\Delta'}{C}{\ol{T}}) \subseteq \Delta_{in}
        \end{array}
      \end{array}
      $
    \\\\
    \rulename{Trim}
    & 
    $
    \begin{array}[c]{@{}ll}
    \begin{array}[c]{l}
        \wildcardEnv \vdash 
        C \cup \, \set{ \wctype{\Delta,\Delta'}{C}{\ol{S}} \lessdot \type{T} } \\ 
      \hline
      \vspace*{-0.4cm}\\
        \wildcardEnv \vdash 
        C \cup \, \set{ \wctype{\Delta}{C}{\ol{S}} \lessdot \type{T} } \\  
    \end{array}
     %\quad \ol{Y} = \textit{fresh}(\ol{X})
     \quad \begin{array}[c]{l}
      \text{fv}(\ol{S}) \cap \Delta' = \emptyset
      \end{array}
    \end{array}
    $
  \\\\
        \rulename{Adopt}
        & $
        \begin{array}[c]{@{}ll}
        \begin{array}[c]{l}
          \wildcardEnv \vdash C \cup \, \set{
           \tv{b} \lessdot \tv{a},
\tv{a} \lessdot \type{N}, \tv{b} \lessdot \type{N'}} \\ 
          \hline
          \vspace*{-0.4cm}\\
          \wildcardEnv \vdash C \cup \, \set{
 \tv{b} \lessdot \type{N},
           \tv{b} \lessdot \tv{a},
\tv{a} \lessdot \type{N} , \tv{b} \lessdot \type{N'}
           }
        \end{array}
        \end{array}
        $
      \\\\
  \rulename{Adapt}
  & 
  $
  \begin{array}[c]{@{}ll}
  \begin{array}[c]{l}
    \wildcardEnv \vdash C \cup \, \set{ \wctype{\Delta}{C}{\ol{T}} \lessdot
       \wctype{\Delta'}{D'}{\ol{T'}} } \\ 
  \hline
  \vspace*{-0.4cm}\\
  \wildcardEnv \vdash C \cup \, \set{ \wctype{\Delta}{D}{[\ol{\type{T}}/\ol{X}]\ol{S}} \lessdot \wctype{\Delta'}{D'}{\ol{T'}} }
  
  \end{array}
  & \begin{array}[c]{l}
  \type{C} \ll \type{D'} \\
   \texttt{class} \ \exptype{C}{\ol{X} \triangleleft \ol{N}} \triangleleft \exptype{D}{\ol{S}} 
  \end{array}
  \end{array}
  $
\\\\ 
\rulename{Crunch}
& $\begin{array}[c]{@{}ll}
\begin{array}[c]{l}
\wildcardEnv \vdash C \cup \, \set{ \tv{a} \doteq \wctype{\Delta', \set{\overline{\wildcard{X}{\type{U}}{\type{L}}}}}{C}{\ol{S}} } \\ 
\hline
\vspace*{-0.4cm}\\
\wildcardEnv \vdash
C \cup \set{ \tv{a} \doteq \wctype{\Delta'}{C}{[\ol{U}/\ol{X}]\ol{S}}} 
\end{array}
&\begin{array}[c]{l}
  \ol{U} = \ol{L}
\end{array}
\end{array}$
\\\\ 
\rulename{Crunch}
& $\begin{array}[c]{@{}ll}
\begin{array}[c]{l}
\wildcardEnv \vdash C \cup \, \set{ \tv{a} \lessdot \wctype{\Delta', \set{\overline{\wildcard{X}{\type{U}}{\type{L}}}}}{C}{\ol{S}} } \\ 
\hline
\vspace*{-0.4cm}\\
\wildcardEnv \vdash
C \cup \set{ \tv{a} \lessdot \wctype{\Delta'}{C}{[\ol{U}/\ol{X}]\ol{S}}} 
\end{array}
&\begin{array}[c]{l}
  \ol{U} = \ol{L}
\end{array}
\end{array}$
    \end{tabular}}
  \end{center}
\caption{Constraint reduce rules}\label{fig:reduce-rules}
\end{figure}

The new constraint generated by the adopt rule may be eliminated by the match rule.
The adopt rule still needs to be applied only once per constraint.

Wildcards consist out of three parts.
A name, a scope and a upper and lower bound.

% The \unify{} algorithm from \cite{plue09_1} substitutes type variables with wildcards.
% A constraint $\wctype{\wildcard{X}{\type{Object}}{\bot}}{C}{\rwildcard{X}} \lessdot \exptype{C}{\tv{a}}$
% has no solution.
% Replacing the type variable $\tv{a}$ with the wildcard $\rwildcard{X}$ is not correct!
% The wildcard $\rwildcard{X}$ cannot leave its scope and the type $\exptype{C}{\rwildcard{X}}$
% is considered invalid.

Wildcards are not reflexive. A box of type $\wctype{\rwildcard{X}}{Box}{\rwildcard{X}}$
is able to hold a value of any type. It could be a $\exptype{Box}{String}$ or a $\exptype{Box}{Integer}$ etc.
Also two of those boxes do not necessarily contain the same type.
But there are situations where it is possible to assume that.
For example the type $\wctype{\rwildcard{X}}{Pair}{\exptype{Box}{\rwildcard{X}}, \exptype{Box}{\rwildcard{X}}}$
is a pair of two boxes, which always contain the same type.
Inside the scope of the \texttt{Pair} type, the wildcard $\rwildcard{X}$ stays the same.

The algorithm starts with an empty wildcard environment $\wildcardEnv{}$.
Only the reduce rule adds wildcards to that environment.
And every added wildcard gets a fresh unique name.
This ensures the wildcard environment $\wildcardEnv{}$ never
gets the same wildcard twice.

When a new type is generated by the \unify{} algorithm it always has the form
$\wctype{\ol{\rwildcard{A}}}{C}{\ol{\rwildcard{A}}}$.

\textbf{Step 1:}
Apply the rules depicted in the figures \ref{fig:normalizing-rules}, \ref{fig:reduce-rules} and \ref{fig:wildcard-rules} exhaustively.
Starting with the \rulename{circle} rule. Afterwards the other rules in figure \ref{fig:normalizing-rules}.

\begin{figure}
If we find an illicit constraint assigning a type containing free variables to a type placeholder not flagged as a wildcard placeholder the algorithm fails. 

$\set{\tv{a} \doteq \type{N}} \in C$ with $\text{fv}(\type{N}) \cap \Delta_{in} \neq \emptyset$ $\implies$ fail! 

% if T <. S with not T << S
% T <. S with fv(T) cup fv(S) not empty (free variables in a non capture conversion constraint)

\caption{Fail conditions}
\end{figure}

The first step of the algorithm is able to remove wildcards.
Removing a wildcard works by setting its lower and upper bound to be equal.
(Def: $\type{Object} = \wildcard{A}{Object}{Object}$).
The \rulename{Equals} rule is responsible for this.

\textbf{Example:}
\begin{displaymath}
  \begin{array}[c]{@{}ll}
    \begin{array}[c]{l}
        \wildcardEnv \cup \set{ \wildcard{X}{\tv{u}}{\tv{l}} } \vdash
        C \cup \, \set{ \type{Object} \doteq \type{X}, \tv{l} \lessdot \tv{u} } \\ 
        \hline
        \vspace*{-0.4cm}\\
        \wildcardEnv \cup \set{ \wildcard{X}{\tv{u}}{\tv{l}} } \vdash C \cup \, 
        \set{\type{Object} \lessdot \type{X}, \type{X} \lessdot \type{Object}, \tv{l} \lessdot \tv{u}
        }\\ 
        \hline
        \vspace*{-0.4cm}\\
        \wildcardEnv \cup \set{ \wildcard{X}{\tv{u}}{\tv{l}} } \vdash C \cup \, 
        \set{\type{Object} \lessdot \tv{l}, \tv{u} \lessdot \type{Object}, \tv{l} \lessdot \tv{u}
        }\\ 
        \hline
        \vspace*{-0.4cm}\\
        \ldots\\ 
        \hline
        \vspace*{-0.4cm}\\
        \wildcardEnv \cup \set{ \wildcard{X}{\type{Object}}{\type{Object}} } \vdash C \\ 
    \end{array} 
    \end{array}
\end{displaymath}

\textbf{Helper functions:}
\begin{description}
\item[$\tph{}$] returns all type placeholders inside a given type.

\textit{Example:} $\tph(\wctype{\wildcard{X}{\tv{a}}{\bot}}{Pair}{\wtv{b},\rwildcard{X}}) = \set{\tv{a}, \wtv{b}}$
\item [$\ll$ relation:]
The $\ll$ relation is the reflexive and transitive closure of the \texttt{extends} relations:
\begin{displaymath}
  \begin{array}[c]{c}
\exptype{C}{\ol{X} \triangleleft \ol{N}} \triangleleft \exptype{D}{\ol{N}} \\ 
\hline
\vspace*{-0.4cm}\\
\texttt{C} \ll \texttt{D}
\end{array}
\quad
\begin{array}[c]{l}
  \\
\hline
\vspace*{-0.4cm}\\
\texttt{C} \ll \texttt{C}
\end{array}
\quad
\begin{array}[c]{l}
\texttt{C} \ll \texttt{D}, \texttt{D} \ll \texttt{E} \\ 
\hline
\vspace*{-0.4cm}\\
\texttt{C} \ll \texttt{E}
\end{array}
\end{displaymath}
The algorithm uses it to determine if two types are possible subtypes of one another.
This is needed in the \rulename{adapt} and \rulename{match} rules.

%\textbf{Wildcard renaming}\\
\item[Wildcard renaming:]
The \rulename{reduce} rule separates wildcards from their environment.
At this point each wildcard gets a new and unique name.
To only rename the respective wildcards the reduce rule renames wildcards up to alpha conversion:
($[\ol{C}/\ol{B}]$ in the \rulename{reduce} rule)
\begin{align*}
  [\type{A}/\type{B}]\type{B} &= \type{A} \\
  [\type{A}/\type{B}]\type{C} &= \type{C} & \text{if}\ \type{B} \neq \type{C}\\
  [\type{A}/\type{B}]\wcNtype{\Delta}{N} &= \wcNtype{\Delta}{[\type{A}/\type{B}]N} & \text{if}\ \type{B} \notin \Delta \\
  [\type{A}/\type{B}]\wcNtype{\Delta}{N} &= \wcNtype{\Delta}{N} & \text{if}\ \type{B} \in \Delta \\
\end{align*}

\item[Free Variables:]
The $\text{fv}$ function assumes every wildcard type variable to be a free variable aswell.

%\textbf{Fresh Wildcards}\\
\item[Fresh Wildcards:]
$\text{fresh}\ \overline{\wildcard{A}{\tv{u}}{\tv{l}}}$ generates fresh wildcards.
The new names $\ol{A}$ are fresh, aswell as the type variables $\ol{\tv{u}}$ and $\ol{\tv{l}}$,
which are used for the upper and lower bounds.
\end{description}
% \noindent
% \textbf{Example: (reduce-rule)}
% %The \ruleReduceWC{} resembles the \texttt{S-Exists} subtyping rule.
% %It converts wildcard types to fresh type variables.
% %For example take the input constraint $\exptype{Pair}{\ntype{Object},\tv{b}} \lessdot \wctype{\wildcard{A}{\tv{c}}{\tv{d}}}{Pair}{\wildcard{A}{\tv{c}}{\tv{d}},\wildcard{A}{\tv{c}}{\tv{d}}}$.
% %First we apply the \ruleReduceWC{} rule, which replaces $\wildcard{A}{\tv{c}}{\tv{d}}$ with a fresh type variable $\tv{a}$:
% We assume the input constraints $C = \exptype{Pair}{\ntype{Object},\tv{b}} \lessdot \wctype{\wildcard{A}{\tv{c}}{\tv{d}}}{Pair}{\wildcard{A}{\tv{c}}{\tv{d}},\wildcard{A}{\tv{c}}{\tv{d}}}$.
% The type on the right side $\wctype{\wildcard{A}{\tv{c}}{\tv{d}}}{Pair}{\wildcard{A}{\tv{c}}{\tv{d}},\wildcard{A}{\tv{c}}{\tv{d}}}$
% \begin{align*}
%   \ddfrac{
%       \exptype{Pair}{\ntype{Object},\tv{b}} \lessdot \wctype{\wildcard{A}{\tv{c}}{\tv{d}}}{Pair}{\wildcard{A}{\tv{c}}{\tv{d}},\wildcard{A}{\tv{c}}{\tv{d}}}
%   }{
%       \ntype{Object} \doteq \tv{a}, \tv{b} \doteq \tv{a}, \tv{a} \lessdot \tv{c}, \tv{d} \lessdot \tv{a}
%   } \ruleReduceWC{}
% \end{align*}

% By substition we get the result: % $\tv{a} \doteq \type{Object}$, $\tv{a} \doteq \type{Object}$, $\ldots$.

% \begin{align*}
%   \ddfrac{
%       \ntype{Object} \doteq \tv{a}, \tv{b} \doteq \tv{a}, \tv{a} \lessdot \tv{c}, \tv{d} \lessdot \tv{a}
%   }{
%         \tv{a} \doteq \ntype{Object} , \tv{b} \doteq \ntype{Object}, \ntype{Object} \lessdot \tv{c}, \tv{d} \lessdot \ntype{Object}
%   } \rulename{Subst}
% \end{align*}
% \\[1em]

\noindent
\textbf{Step 2:}
%If there are no $(\type{T} \lessdot \tv{a})$ constraints remaining in the constraint set $C$
%resume with step 4.

The rules in figure \ref{fig:step2-rules} offer multiple possibilities to deal with constraints of the form $\type{N} \lessdot \tv{a}$.
This builds a search tree over multiple possible solutions.
\unify{} has to try each branch and accumulate the resulting solutions into a solution set.
\def\boxit#1#2{%
    \smash{\color{red}\fboxrule=1pt\relax\fboxsep=2pt\relax%
    \llap{\rlap{\fbox{\phantom{\rule{#1}{#2}}}}~}}\ignorespaces
}
\begin{figure}
  \begin{center}
          \fbox{
          \begin{tabular}[t]{l@{~}l}
          \rulename{Same}
          & $
          \begin{array}[c]{l}
            \wildcardEnv \vdash
            C \cup \type{G} \lessdot \ntv{a}\\
            \hline
            \wildcardEnv \vdash
            C \cup \set{
              \ntv{a} \doteq \type{G}
          }
          \end{array} \quad \begin{array}[c]{l}
            \text{fv}(\type{G}) \in \Delta_{in}
          \end{array}
            $
        \\\\
        \cdashline{1-2} \\
            \rulename{\generalizeRule}
            & $
            \begin{array}[c]{l}
              \wildcardEnv \vdash C \cup \wctype{\Delta}{C}{\ol{T}} \lessdot \ntv{a}\\
              \hline
              \wildcardEnv \vdash C \cup \set{\wctype{\Delta}{C}{\ol{T}} \lessdot \ntv{a},
            \ntv{a} \doteq \wctype{\overline{\wildcard{X}{\tv{u}}{\tv{l}}}}{C}{\overline{\rwildcard{X}}},
            %\overline{\tv{l} \lessdot \tv{u}}, % not needed, due to subst and reduce rule which are used afterwards
            \overline{\tv{u} \lessdot \type{S}}
            }
            \end{array} \quad \begin{array}[c]{l}
              \texttt{class} \ \exptype{C}{\ol{X \triangleleft \type{S}}} \triangleleft \exptype{D}{\ol{N}} \\
              \text{fresh}\ \overline{\wildcard{X}{\tv{u}}{\tv{l}}}
            \end{array}
              $ 
              \\\\
              \cdashline{1-2} \\
          \rulename{Super}
          & $
          \begin{array}[c]{l}
            \wildcardEnv \vdash C \cup \wctype{\Delta}{C}{\ol{T}} \lessdot \tv{a}\\
            \hline
            \wildcardEnv \vdash C \cup \set{ \wctype{\Delta'}{D}{[\ol{T}/\ol{X}]\ol{N}} \lessdot \tv{a}   }
          %\set{\wctype{\ol{\wtype{W}}}{D}{[\ol{X}/\ol{Y}]\ol{Z}} \lessdot \tv{a}}
          \end{array} \quad
          \begin{array}{l}
            \texttt{class} \ \exptype{C}{\ol{X}} \triangleleft \exptype{D}{\ol{N}} \\
            \ol{X} \notin \wildcardEnv \cup \Delta,\, \Delta' = \Delta \cap \text{fv}([\ol{T}/\ol{X}]\ol{N})
          \end{array}
          $
              \\\\
              \hline \\
              \rulename{SameW}
              & $
              \begin{array}[c]{l}
                \wildcardEnv \vdash
                C \cup \type{G} \lessdot \wtv{a}\\
                \hline
                \wildcardEnv \vdash
                C \cup \set{
                  \wtv{a} \doteq \type{G}
              }
              \end{array}
                $
            \\\\
            \cdashline{1-2} \\
                \rulename{\generalizeRule{}W}
                & $
                \begin{array}[c]{l}
                  \wildcardEnv \vdash C \cup \wctype{\Delta}{C}{\ol{T}} \lessdot \wtv{a}\\
                  \hline
                  \wildcardEnv \vdash C \cup \set{\wctype{\Delta}{C}{\ol{T}} \lessdot \wtv{a},
                \wtv{a} \doteq \wctype{\overline{\wildcard{X}{\wtv{u}}{\wtv{l}}}}{C}{\overline{\rwildcard{X}}},
                %\overline{\tv{l} \lessdot \tv{u}}, % not needed, due to subst and reduce rule which are used afterwards
                \overline{\wtv{u} \lessdot \type{S}}
                }
                \end{array} \quad \begin{array}[c]{l}
                  \texttt{class} \ \exptype{C}{\ol{X \triangleleft \type{S}}} \triangleleft \exptype{D}{\ol{N}} \\
                  \text{fresh}\ \overline{\wildcard{X}{\wtv{u}}{\wtv{l}}}
                \end{array}
                  $
      \end{tabular}
      }
          \end{center}
        \caption{Step 2 branching: Multiple rules can be applied to the same constraint}
        \label{fig:step2-rules}
        \end{figure}

        \begin{figure}
          \begin{center}
\fbox{
      \begin{tabular}[t]{l@{~}l}
        \rulename{Subst-X}
        & $
        \begin{array}[c]{l}
          \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}} \vdash
          C \cup \rwildcard{X} \lessdot \tv{a}\\
          \hline
          \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}} \vdash
          C \cup \set{
            \tv{a} \doteq \rwildcard{X}
        }
        \end{array} \quad \begin{array}[c]{l}
          \rwildcard{X} \in \Delta_{in}
        \end{array}
          $
          \\\\
          \cdashline{1-2} \\
      \rulename{Gen-X}
      & $
      \begin{array}[c]{l}
        \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}} \vdash
        C \cup \rwildcard{X} \lessdot \tv{a}\\
        \hline
        \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}} \vdash
        C \cup \set{
          \type{U} \lessdot \tv{a}
      }
      \end{array}
        $
    \end{tabular}
    }
        \end{center}
      \caption{Step 2 branching: Multiple rules can be applied to the same constraint}
      \label{fig:step2-rules}
      \end{figure}

      \begin{figure}
        \begin{center}
\fbox{
      \begin{tabular}[t]{l@{~}l}
        \rulename{Settle}
        & $
        \begin{array}[c]{l}
          \wildcardEnv \vdash C \cup \set{ \tv{a} \lessdot \type{N},
          \tv{a} \lessdot \tv{b}}
          \\
          \hline
          \wildcardEnv \vdash C \cup \set{  \tv{a} \lessdot \tv{b}, \tv{b} \lessdot \type{N}  }
        \end{array}
        $
        \\\\
        \cdashline{1-2} \\
      \rulename{Raise}
      & $
      \begin{array}[c]{l}
        \wildcardEnv \vdash C \cup \set{ \tv{a} \lessdot \type{N},
        \tv{a} \lessdot \tv{b}}
        \\
        \hline
        \wildcardEnv \vdash C \cup \set{\tv{a} \lessdot \type{N}, \type{N} \lessdot \tv{b}  }
      \end{array}
      $
    \end{tabular}
}
    \end{center}
  \caption{Step 2 branching: Multiple rules can be applied to the same constraint}
  \label{fig:step2-rules}
  \end{figure}
  
\begin{figure}
\begin{center}
        \fbox{
        \begin{tabular}[t]{l@{~}l}
        \rulename{Same}
        & $
        \begin{array}[c]{l}
          \wildcardEnv \vdash
          C \cup \type{G} \lessdot \tv{a}\\
          \hline
          \wildcardEnv \vdash
          C \cup \set{
            \tv{a} \doteq \type{G}
        }
        \end{array} \quad \begin{array}[c]{l}
          \text{fv}(\type{G}) \in \Delta_{in}
        \end{array}
          $
      \\\\ 
          \rulename{\generalizeRule}
          & $
          \begin{array}[c]{l}
            \wildcardEnv \vdash C \cup \wctype{\Delta}{C}{\ol{T}} \lessdot \tv{a}\\
            \hline
            \wildcardEnv \vdash C \cup \set{\wctype{\Delta}{C}{\ol{T}} \lessdot \tv{a},
          \tv{a} \doteq \wctype{\overline{\wildcard{X}{\tv{u}}{\tv{l}}}}{C}{\overline{\rwildcard{X}}},
          %\overline{\tv{l} \lessdot \tv{u}}, % not needed, due to subst and reduce rule which are used afterwards
          \overline{\tv{u} \lessdot \type{S}}
          }
          \end{array} \quad \begin{array}[c]{l}
            \texttt{class} \ \exptype{C}{\ol{X \triangleleft \type{S}}} \triangleleft \exptype{D}{\ol{N}} \\
            \text{fresh}\ \overline{\wildcard{X}{\tv{u}}{\tv{l}}}
          \end{array}
            $
        \\\\ 
        \rulename{Subst-X}
        & $
        \begin{array}[c]{l}
          \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}} \vdash
          C \cup \rwildcard{X} \lessdot \tv{a}\\
          \hline
          \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}} \vdash
          C \cup \set{
            \tv{a} \doteq \rwildcard{X}
        }
        \end{array} \quad \begin{array}[c]{l}
          \rwildcard{X} \in \Delta_{in}
        \end{array}
          $
      \\\\ 
      \rulename{Gen-X}
      & $
      \begin{array}[c]{l}
        \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}} \vdash
        C \cup \rwildcard{X} \lessdot \tv{a}\\
        \hline
        \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}} \vdash
        C \cup \set{
          \type{U} \lessdot \tv{a}
      }
      \end{array}
        $
    \\\\ 
        \rulename{Super}
        & $
        \begin{array}[c]{l}
          \wildcardEnv \vdash C \cup \wctype{\Delta}{C}{\ol{T}} \lessdot \tv{a}\\
          \hline
          \wildcardEnv \vdash C \cup \set{ \wctype{\Delta'}{D}{[\ol{T}/\ol{X}]\ol{N}} \lessdot \tv{a}   }
        %\set{\wctype{\ol{\wtype{W}}}{D}{[\ol{X}/\ol{Y}]\ol{Z}} \lessdot \tv{a}}
        \end{array} \quad
        \begin{array}{l}
          \texttt{class} \ \exptype{C}{\ol{X}} \triangleleft \exptype{D}{\ol{N}} \\
          \ol{X} \notin \wildcardEnv \cup \Delta,\, \Delta' = \Delta \cap \text{fv}([\ol{T}/\ol{X}]\ol{N})
        \end{array}
        $
      \\\\ 
      \rulename{Settle}
      & $
      \begin{array}[c]{l}
        \wildcardEnv \vdash C \cup \set{ \tv{a} \lessdot \type{N},
        \tv{a} \lessdot \tv{b}}
        \\
        \hline
        \wildcardEnv \vdash C \cup \set{  \tv{a} \lessdot \tv{b}, \tv{b} \lessdot \type{N}  }
      \end{array}
      $
    \\\\ 
    \rulename{Raise}
    & $
    \begin{array}[c]{l}
      \wildcardEnv \vdash C \cup \set{ \tv{a} \lessdot \type{N},
      \tv{a} \lessdot \tv{b}}
      \\
      \hline
      \wildcardEnv \vdash C \cup \set{\tv{a} \lessdot \type{N}, \type{N} \lessdot \tv{b}  }
    \end{array}
    $
  \\\\ 
    \end{tabular}}
  \end{center}
\caption{Step 2 branching: Multiple rules can be applied to the same constraint}
\label{fig:step2-rules}
\end{figure}


%For every $\type{T} \lessdot \tv{a}$ constraint, the unify algorithm has to consider every possible supertype of $\type{T}$.
%For every $\type{N}$ with $\type{T} \leq \type{N}$: ($\texttt{class} \ \exptype{T}{\ol{Y} \triangleleft \ol{N}} \triangleleft \type{N}$) 
%There are two different ways of handling a $\type{T} \lessdot \tv{a}$ constraint:
%TODO: why the \generalizeRule is basically the Same rule for regular type placeholders

%where is the mistake in the old unify algorithm? 
%when working with equality the problems arise! Free variables should not escape their scope
% Replacing regular type placeholders causes problems related to method calls and capture conversion.

% <X> List<X> same(List<X> a, List<X> b){}

% This program has no correct type. the same method requires 
% \begin{lstlisting}
% List<?> f;
% List<?> problem(){
%   return same(problem(), problem()) ?: f;
% }
% \end{lstlisting}
% \begin{constraints}
% r <. List<x?>
% r <. List<x?>
% X.List<X> <. r
% \end{constraints}
% %TODO

\unify{} generates wildcard types for constraints of the form $\type{N} \lessdot \tv{a}$ with the \rulename{\generalizeRule} rule.
Otherwise only the wildcards already defined in the input constraints will be included in the result.
\rulename{\generalizeRule} attempts to give $\tv{a}$ a more general type by replacing only the type parameters with fresh wildcards.
The second variation sets $\tv{a}$ to the direct supertype of type \texttt{C}.
For the constraint $\texttt{Object} \lessdot \tv{a}$ the algorithm can only apply $\tv{a} \doteq \texttt{Object}$,
because \texttt{Object} has no other supertype than itself.

Constraints of the form $\set{ \tv{a} \lessdot \type{N}, \tv{a} \lessdot^* \tv{b}}$
need to be handled in a similiar fashion.
The type variable $\tv{b}$ could either be a sub or a supertype of the type $\type{N}$.
We have to consider both possibilities.
\\[1em]
% The specification of the \unify{} algorithm has only two rules generating $\doteq$-Constraints
% , \rulename{Reduce} and \rulename{Ground}.
% $\doteq$-Constraints and the accompaning substitutions are dangerous respective to the soundness of the algorithm.
% For the soundness proof of the \unify{} algorithm we have to show every generation of equals constraints
% and the subsequent application of the \rulename{subst} rule is correct.
% We try to use them as sparsely as possible to simplify the soundness proof.
% You can notice this at \rulename{Equals} or \rulename{Force}:
% Instead of setting $\type{U} \doteq \type{L}$, we say
% $\type{U} \lessdot \type{L}, \type{L} \lessdot \type{U}$.

\noindent
\textbf{Step 3} 
\textbf{(Eliminate Wildcard Variables):}
If no more rules in step 2 are applicable \unify{} has to eliminate all wildcard variables and $\lessdotCC$ constraints by applying the \rulename{Remove} rule
and start over at step 1.
If $C$ does not contain any wildcard variables the algorithm proceeds with step 4.
\begin{center}
  \fbox{
  \begin{tabular}[t]{l@{~}l}
%     \rulename{Remove} % kann beim Subst step gemacht werden und ist nur nötig wenn ein a =. T constraint mit wtv(T) > 1 entsteht
%     & $
%     \begin{array}[c]{@{}ll}
%     \begin{array}[c]{l}
%        \wildcardEnv \vdash C \\
%         % \cup \, \set{ \wtv{a} \lessdot \type{T} }\\ 
%       \hline
%       \vspace*{-0.4cm}\\
%       \subst{\tv{a}}{\wtv{a}}\wildcardEnv \vdash [\tv{a}/\wtv{a}]C 
%     \end{array}
%     &\begin{array}[c]{l}
%       \wtv{a} \in C \\
%       \tv{a} \ \text{fresh}
%    \end{array}
%     \end{array}
% $
% \\\\
\rulename{Remove-Cons} & $
    \begin{array}[c]{l}
       \wildcardEnv \vdash C \cup \set{\type{S} \lessdotCC \type{T} } \\
      \hline
      \vspace*{-0.4cm}\\
      \wildcardEnv \vdash C \cup \set{\type{S} \lessdot \type{T} }
    \end{array}
    $
\end{tabular}}
\end{center}

% \textbf{Step 4:}
% If there are constraints of the form $(\tv{a} \lessdot \tv{b})$ remaining in the constraint set then
% apply the \rulename{Sub-Elim} rule and start over with step 1.
% Otherwise continue to step 5.
% \begin{center}
%   \fbox{
%   \begin{tabular}[t]{l@{~}l}
%     \rulename{SubElim} 
%     & $\begin{array}[c]{l}
%       \wildcardEnv \vdash C \cup \set{\tv{a} \lessdot \tv{b}}\\
%       \hline
%       [\tv{a}/\tv{b}]\wildcardEnv \vdash [\tv{a}/\tv{b}]C \cup \set{ \tv{b} \doteq \tv{a} }
%     \end{array}
%     $
% \end{tabular}}
% \end{center}

\noindent
\textbf{Step 4:}
We apply the rules in figure \ref{fig:cleanup-rules} exhaustively and proceed with step 6.

\begin{figure}
  \begin{center}
      \leavevmode
      \fbox{
      \begin{tabular}[t]{l@{~}l}
\rulename{SubElim} 
& $\begin{array}[c]{l}
  \wildcardEnv \vdash C \cup \set{\tv{a} \lessdot \tv{b}}\\
  \hline
  [\tv{a}/\tv{b}]\wildcardEnv \vdash [\tv{a}/\tv{b}]C \cup \set{ \tv{b} \doteq \tv{a} }
\end{array}
$
\\\\
\rulename{Ground}
& $\begin{array}[c]{@{}ll}
\begin{array}[c]{l}
 \wildcardEnv \cup \overline{\set{\wildcard{X}{\type{U}}{\tv{a}}}} \vdash C \cup \, \set{
    \overline{\tv{a} \lessdot \type{T}} } \\ 
\hline
\vspace*{-0.4cm}\\
\wildcardEnv \cup \overline{\set{\wildcard{X}{\type{U}}{\bot}}} \vdash
C \cup \set{ \tv{a} \doteq \bot }
\end{array}
&\begin{array}[c]{l}
%\forall \wctype{\Delta}{C}{\ol{T}} \in C: \tv{a} \notin \ol{T} \\
\tv{a} \notin C, \, \rwildcard{X} \notin C, \, \tv{a} \notin \overline{T} %\\
%\text{length}( \overline{\tv{a} \lessdot \type{T}} ) > 1
\end{array}
\end{array}$
% \\\\  % The force rule is unnecessary because every type placeholder has an upper bound Object (a <. Object) The match rule eliminates those wildcards
% \rulename{Force} &$
%   \begin{array}[c]{@{}ll}
%   \begin{array}[c]{l}
%      \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}}
% \vdash C \cup \, \set{
%         \tv{a} \lessdot \type{N} } \\ 
%     \hline
%     \vspace*{-0.4cm}\\
%     \wildcardEnv 
% \vdash
%     C \cup \, \set{ \tv{a} \lessdot [\type{U}/\rwildcard{X}]\type{N}, 
%      \type{U} \doteq \type{L} }
%   \end{array}
%   &\begin{array}[c]{l}
%     \type{X} \in \text{fv}(\type{N}) \\
%     %\Delta' = \Delta \cup \set{\wildcard{X}{\type{U}}{\type{L}}}
%  \end{array}
%   \end{array}$
% \\\\
% \rulename{FlatOut} &$
%   \begin{array}[c]{@{}ll}
%   \begin{array}[c]{l}
%      \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}}
% \vdash C \cup \, \set{
%         \tv{a} \lessdot \wcNtype{\Delta}{N} } \\ 
%     \hline
%     \vspace*{-0.4cm}\\
%     \wildcardEnv \cup \set{\wildcard{X}{\type{U}}{\type{L}}}
% \vdash
%     C
%   \end{array}
%   &\begin{array}[c]{l}
%     \type{X} \in \text{fv}(\wcNtype{\Delta}{N}) \\
%     \tv{a} \notin C , \, \tv{a} \notin \wildcardEnv, \tv{a} \notin \sigma
%  \end{array}
%   \end{array}$
  \end{tabular}}
\end{center}
\caption{Cleanup rules}\label{fig:cleanup-rules}
\end{figure}

The cleanup step prepares the constraint set for the last step by applying the following concepts:
%Two transformations are done which also help to remove unnecessary types from the solution set.
\begin{description}
\item[Bottom type]
The bottom type $\bot$ is used to generate \texttt{? extends} wildcard definitions.
This is the only possible solution when dealing with multiple upper bounds:
$\tv{a} \lessdot \type{T}, \tv{a} \lessdot \type{S}$ is usually not a correct solution (given $\type{S}$ and $\type{T}$ are no subtypes of eachother).
But if $\tv{a}$ is a lower bound of a wildcard it can be set to $\bot$.
Those constraints only stay in the constraint set after the first step if $\type{S}$ and $\type{T}$ do not have a common subtype.
The \rulename{Ground} rule uses this concept to generate \texttt{extends} Wildcards.

\item[Eliminating Wildcards]
Wildcards that have the same upper and lower bounds can be removed.
This is done by the \rulename{Crunch} rule.

\textit{Example:} The type $\wctype{\wildcard{X}{\type{String}}{\type{String}}}{List}{\rwildcard{X}}$
becomes $\exptype{List}{\type{String}}$.


%TODO: The a =. T (with T containing free variables) could be removed here.
% Not needed for the soundness of the algorithm, but handy for the implementation (check this when implementing the algorithm)
\end{description}

\noindent
\textbf{Step 6 (Generating Result):}
Apply the rules in figure \ref{fig:generation-rules} until $\wildcardEnv = \emptyset$ and $C = \emptyset$.
The resulting $\Delta, \sigma$ is a correct solution.

For this step to succeed there should only be four kinds of constraints left.
\begin{enumerate}
%\item\label{item:3} $\tv{a} \lessdot \tv{b}$ %, with $a$ and $b$ both isolated type variables
\item $\tv{a} \doteq \tv{b}$
%\item $\wtv{a} \doteq \type{G}$
\item\label{item:1} $\tv{a} \lessdot \wctype{\ol{\wtype{W}}}{C}{\ol{\type{T}}}$, with $\text{fv}(\wctype{\ol{\wtype{W}}}{C}{\ol{\type{T}}}) \subseteq \Delta_in$
\item\label{item:2} $\tv{a} \doteq \wctype{\ol{\wtype{W}}}{C}{\ol{\type{T}}}$, with $\tv{a} \notin \ol{\type{T}}$ % and $\text{fv}(\wctype{\ol{\wtype{W}}}{C}{\ol{\type{T}}}) = \emptyset$
\item\label{item:3} $\tv{a} \doteq \rwildcard{X}$
\end{enumerate}
% Constraints of the form $\tv{a} \doteq \rwildcard{X}$ are also possible.
% should we add those to the \Delta environment?
% How about removing them completely from the result set? Check with soundness condition

%Each type placeholder $\tv{a}$ must solely appear on the left side of a constraint.
\unify{} fails if there is any $\tv{a} \doteq \type{T}$ such that $\tv{a}$ occurs in $\type{T}$.
For the cases \ref{item:1}, \ref{item:2}, and \ref{item:3} the placeholder $\tv{a}$
cannot appear anywhere else in the constraint set.
Otherwise the generation rules \rulename{GenSigma} and \rulename{GenDelta} will not be able to process every constraint.

% After applying the GenDelta and GenSigma rules unifiers $\sigma$ do not contain
% a unifier of the form $\tv{a} \to \tv{b}$.
% Otherwise the found solution is incorrect.
% This only happens if the input constraints contain type variables with no upper bound constraint like $\tv{a} \lessdot \type{N}$.

% \begin{displaymath}
% \deduction{
% \wildcardEnv \cup \set{\wildcard{B}{\type{G}}{\type{G'}}} \vdash C \implies \Delta, \sigma
% }{
% \wildcardEnv \vdash C \implies \Delta \cup \set{\wildcard{B}{\type{G}}{\type{G'}}}, \sigma
% }\quad \text{tph}(\type{G}) = \emptyset, \text{tph}(\type{G'}) = \emptyset,
% \rwildcard{B} \notin \text{dom}(\Delta)
% \quad \rulename{AddDelta}
% \end{displaymath}

\begin{figure}
\begin{center}
        \fbox{
        \begin{tabular}[t]{l@{~}l}
          \rulename{GenDelta}
          & $
          \deduction{
            \wildcardEnv \vdash C \cup \set{\ntv{b} \lessdot \type{T} } \implies \Delta, \sigma
            }{
            \wildcardEnv \vdash [\type{B}/\ntv{b}]C \implies \Delta \cup \set{\wildcard{B}{\type{T}}{\bot}}, \sigma \cup \set{\ntv{b} \to \type{B}}
            } \quad
            \begin{array}{l}
            \tph(\type{T}) = \emptyset, \text{fv}(\type{T}) \subseteq \Delta \cup \Delta_{in} \\
            \rwildcard{B} \ \text{fresh}, \ntv{b} \notin \text{dom}(\sigma), \Delta, \Delta_{in} \vdash \type{T} \ \ok
            \end{array}
          $
        \\\\ 
      \rulename{GenSigma}
      & $
      \deduction{
      \wildcardEnv \vdash C \cup
      \set{\ntv{a} \doteq \type{T} }  \implies \Delta, \sigma
      }{
      \wildcardEnv \vdash C   \implies \Delta,  \sigma \cup
      \set{\ntv{a} \to \type{T} }
      } \quad 
      \begin{array}{l}
      \tph(\type{T}) = \emptyset \\ %,\, \text{fv}(\type{T}) \subseteq \Delta \\ % T ok implies that
      \ntv{a} \notin \text{dom}(\sigma),\, \Delta, \Delta_{in} \vdash \type{T} \ \ok
      \end{array}
      $
    \\\\ 
    \end{tabular}}
  \end{center}
\caption{Generate result}
\label{fig:generation-rules}
\end{figure}

\subsection{Capture Conversion during Unification}
The \unify{} algorithm applies a capture conversion when needed.
A constraint of the form $\wcNtype{\Delta'}{N} \lessdot \type{T}$,
where $\text{fv}(\type{T}) \neq \emptyset$ is not solvable without capture conversion.
\unify{} converts those constraints to $\type{N} \lessdot \type{T}$.
This is only possible for subtype constraints which originated from a method call.

Capture conversion only works with constraints containing free variables.
It also introduces fresh free variables into the constraint set.
Both have to be regulated.
It is not allowed to substitute free type variables freely.
The algorithm introduces a new type of variables: $\wtv{a}$.
\unify{} treats those as free type variables.
This makes it possible to replace a $\wtv{a}$ with a captured wildcard variable
without having to worry about introducing free type variables at unwanted places.

The challenge for a type inference algorithm is to apply capture conversion during type inference.
Given a program 
\begin{verbatim}
class TypeInferenceExample{
	m(l){
		return swap(make(l));
	}
}
\end{verbatim}

During the time of the type inference algorithm the type of the parameter \texttt{l} is not known.
Due to the call to the method \texttt{make} it is clear that it has to be a subtype of
\texttt{List}.
These subtype relations are expressed with constraints.
$\tv{l} \lessdot \exptype{List}{\tv{a}}$ in this case.
$\tv{l}$ and $\tv{a}$ are type placeholders.
$\tv{l}$ is a type placeholder for the method parameter \texttt{l}.

One correct solution for this constraint is the substitution $\tv{l} \doteq \exptype{List}{\type{Object}}$,
which leads to the program:
\begin{verbatim}
	class TypeInferenceExample{
		Pair<Object, Object> m(List<Object> l){
			return swap(make(l));
		}
	}	
\end{verbatim}

But $\tv{l} \doteq \wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ is also a possible solution.
Eventhough the constraint $\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \lessdot \exptype{List}{\tv{a}}$
is not solvable.
But when we apply capture conversion to create $\exptype{List}{\rwildcard{Y}} \lessdot \exptype{List}{\tv{a}}$
we can substitute $\tv{a} \doteq \rwildcard{Y}$.

The \unify{} algorithm has to apply capture conversions during the unification of type constraints.

But this renders additional problems:
\begin{itemize}
	\item Capture conversion is not allowed for every constraint.
	\item Capture Converted variables are not allowed to leave their scope
	\item \unify{} generates type substitution which cannot be translated to Java types.
\end{itemize}
