diff --git a/CAS/Dumb/LaTeX/Symbols.hs b/CAS/Dumb/LaTeX/Symbols.hs
new file mode 100644
--- /dev/null
+++ b/CAS/Dumb/LaTeX/Symbols.hs
@@ -0,0 +1,191 @@
+-- |
+-- Module      : CAS.Dumb.LaTeX.Symbols
+-- Copyright   : (c) Justus Sagemüller 2017
+-- License     : GPL v3
+-- 
+-- Maintainer  : (@) jsagemue $ uni-koeln.de
+-- Stability   : experimental
+-- Portability : portable
+-- 
+-- Orphan instances, allowing to construct CAS syntax trees
+-- with LaTeX symbols.
+
+{-# LANGUAGE OverloadedStrings    #-}
+{-# LANGUAGE ScopedTypeVariables  #-}
+{-# LANGUAGE UnicodeSyntax        #-}
+{-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE CPP                  #-}
+
+module CAS.Dumb.LaTeX.Symbols () where
+
+import CAS.Dumb.Tree
+import CAS.Dumb.Symbols
+
+import Text.LaTeX
+import Text.LaTeX.Base.Class
+import Text.LaTeX.Base.Syntax
+import Text.LaTeX.Packages.AMSMath
+import Text.LaTeX.Packages.AMSFonts
+
+import qualified Data.Text as Txt
+import Data.String (IsString(..))
+import Data.Char (isAlpha, isUpper, isLower)
+import Data.Tuple (swap)
+
+import Data.Ratio (denominator, numerator)
+import Numeric.Literals.Decimal
+
+import qualified Data.HashMap.Strict as Map
+import Data.Hashable
+
+import Control.Monad
+
+import qualified Language.Haskell.TH as Hs
+
+
+instance ASCIISymbols LaTeX where
+  fromASCIISymbol c
+   | isAlpha c  = fromString [c]
+  toASCIISymbols (TeXRaw s) = Txt.unpack s
+
+instance UnicodeSymbols LaTeX where
+  fromUnicodeSymbol c
+   | Just lc <- Map.lookup c mappingFromUnicode  = lc
+   | otherwise  = error $ "Unicode symbol '"++[c]++"' not supported in LaTeX expressions."
+  toUnicodeSymbols lc
+   | Just c <- Map.lookup lc mappingToUnicode    = [c]
+   | lc==mempty  = ""
+   | otherwise   = "《"++Txt.unpack(render lc)++"》"
+  
+mappingFromUnicode :: Map.HashMap Char LaTeX
+mappingToUnicode :: Map.HashMap LaTeX Char
+InvertibleMap mappingFromUnicode mappingToUnicode
+   = mapToLaTeXWith id     "𝑎𝑏𝑐𝑑𝑒𝑓𝑔ℎ𝑖𝑗𝑘𝑙𝑚𝑛𝑜𝑝𝑞𝑟𝑠𝑡𝑢𝑣𝑤𝑥𝑦𝑧"
+                           "abcdefghijklmnopqrstuvwxyz"
+ <|> mapToLaTeXWith mathbf ['𝐚'..'𝐳']
+                           ['a'..'z']
+#if __GLASGOW_HASKELL__ > 802
+ <|> mapToLaTeXWith id     ['𝐴'..'𝑍']
+                           ['A'..'Z']
+ <|> mapToLaTeXWith mathbf ['𝐀'..'𝐙']
+                           ['A'..'Z']
+ <|> mapToLaTeXWith mathbb "ℂℍℚℝℤ"
+                           "CHQRZ"
+ <|> mapToLaTeXWith mathcal ['𝓐'..'𝓩']
+                            ['A'..'Z']
+ <|> mapToLaTeXWith mathfrak "𝔄𝔅ℭ𝔇𝔈𝔉𝔊ℌℑ𝔍𝔎𝔏𝔐𝔑𝔒𝔓𝔔ℜ𝔖𝔗𝔘𝔙𝔚𝔛𝔜"
+                             "ABCDEFGHIJKLMNOPQRSTUVWXY"
+#endif
+ <|> fromAssocList (zip
+           ['α',  'β', 'γ',  'δ',  'ε',       'ζ', 'η','θ',  'ϑ',     'ι', 'κ',  'λ'   ]
+           [alpha,beta,gamma,delta,varepsilon,zeta,eta,theta,vartheta,iota,kappa,lambda])
+ <|> fromAssocList (zip
+           ['μ','ν','ξ','π','ρ','ϱ',   'σ',  'ς',     'τ','υ',    'ϕ','φ',   'χ','ψ', 'ω' ]
+           [mu, nu, xi, pi, rho,varrho,sigma,varsigma,tau,upsilon,phi,varphi,chi,psi,omega])
+#if __GLASGOW_HASKELL__ > 802
+ <|> fromAssocList (zip
+           ['Γ',   'Δ',   'Θ',   'Λ',    'Ξ','Π','Σ',   'Υ',     'Φ', 'Ψ', 'Ω'   ]
+           [gammau,deltau,thetau,lambdau,xiu,piu,sigmau,upsilonu,phiu,psiu,omegau])
+#endif
+ <|> fromAssocList (zip
+           ['+', '-', '*',           '±',         '∓'        ]
+           ["+", "-", raw"{\\cdot}", raw"{\\pm}", raw"{\\mp}"])
+
+remapWith :: (a->b) -> [a] -> [a] -> [(a, b)]
+remapWith f = zipWith (\lc rc -> (lc, f rc))
+
+mapToLaTeXWith :: (LaTeX->LaTeX) -> [Char] -> [Char] -> InvertibleMap Char LaTeX
+mapToLaTeXWith f l r = fromAssocList $ remapWith (f . fromString . pure) l r
+
+
+
+data InvertibleMap a b = InvertibleMap {
+      fwdMapping :: Map.HashMap a b
+    , revMapping :: Map.HashMap b a
+    }
+
+fromAssocList :: (Hashable a, Hashable b, Eq a, Eq b)
+                 => [(a,b)] -> InvertibleMap a b
+fromAssocList assocs = InvertibleMap (Map.fromList assocs) (Map.fromList $ map swap assocs)
+
+infixl 3 <|>
+(<|>) :: (Hashable a, Hashable b, Eq a, Eq b)
+                 => InvertibleMap a b -> InvertibleMap a b -> InvertibleMap a b
+InvertibleMap af ar<|>InvertibleMap bf br
+   = InvertibleMap (Map.union af bf) (Map.union ar br)
+
+encapsulation :: l -> l
+              -> (CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l))
+              -> (CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l))
+encapsulation l r = Function $ Encapsulation False True l r
+
+latexFunction :: LaTeXC l
+              => Text
+              -> (CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l))
+              -> (CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l))
+latexFunction f = Function $ Encapsulation True False (raw $ f<>"{") (raw "}")
+
+instance ∀ σ γ . (SymbolClass σ, SCConstraint σ LaTeX)
+          => Num (CAS' γ (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)) where
+  fromInteger n
+   | n<0        = negate . fromInteger $ -n
+   | otherwise  = Symbol $ NatSymbol n
+  (+) = chainableInfixL (==plusOp) plusOp
+   where fcs = fromCharSymbol ([]::[σ])
+         plusOp = Infix (Hs.Fixity 6 Hs.InfixL) $ fcs '+'
+  (*) = chainableInfixL (==mulOp) mulOp
+   where fcs = fromCharSymbol ([]::[σ])
+         mulOp = Infix (Hs.Fixity 7 Hs.InfixL) $ fcs '*'
+  (-) = symbolInfix (Infix (Hs.Fixity 6 Hs.InfixL) $ fcs '-')
+   where fcs = fromCharSymbol ([]::[σ])
+  abs = encapsulation (raw "\\left|") (raw "\\right|")
+  signum = latexFunction "\\signum"
+  negate = Operator (Infix (Hs.Fixity 6 Hs.InfixL) $ fcs '-')
+             . Symbol $ StringSymbol mempty
+   where fcs = fromCharSymbol ([]::[σ])
+
+instance ∀ σ γ . (SymbolClass σ, SCConstraint σ LaTeX)
+     => Fractional (CAS' γ (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)) where
+  fromRational n = case fromRational n of
+     n:%d -> fromIntegral n / fromIntegral d
+     Scientific pc acs e -> let m = Symbol (StringSymbol . fromString
+                                     $ show pc++
+                                       if null acs then ""
+                                                   else "."++(show=<<acs))
+                            in if e==0 then m
+                                       else m * 10**fromIntegral e
+  a / b = Operator (Infix (Hs.Fixity 8 Hs.InfixL) mempty)
+             (encapsulation (raw "\\frac{") (raw "}") a)
+             (encapsulation (raw       "{") (raw "}") b)
+
+
+instance ∀ σ γ . (SymbolClass σ, SCConstraint σ LaTeX)
+     => Floating (CAS' γ (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)) where
+  pi = Symbol $ StringSymbol pi_
+  sqrt = encapsulation (raw "\\sqrt{") (raw "}")
+  a ** b = Operator (Infix (Hs.Fixity 8 Hs.InfixR) mempty)
+             a (encapsulation (raw "^{") (raw "}") b)
+  logBase b a = Operator (Infix (Hs.Fixity 10 Hs.InfixL) mempty)
+                  (encapsulation (raw "\\log_{") (raw "}") b) a
+  exp = latexFunction "\\exp"
+  log = latexFunction "\\log"
+  sin = latexFunction "\\sin"
+  cos = latexFunction "\\cos"
+  tan = latexFunction "\\tan"
+  asin = latexFunction "\\asin"
+  acos = latexFunction "\\acos"
+  atan = latexFunction "\\atan"
+  sinh = latexFunction "\\sinh"
+  cosh = latexFunction "\\cosh"
+  tanh = latexFunction "\\tanh"
+  asinh = latexFunction "\\asinh"
+  acosh = latexFunction "\\acosh"
+  atanh = latexFunction "\\atanh"
+
+
+
+instance Eq (Encapsulation LaTeX) where
+  Encapsulation _ _ l r == Encapsulation _ _ l' r'
+         = l==l' && r==r'
+
diff --git a/COPYING b/COPYING
new file mode 100644
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/Math/LaTeX/Internal/Display.hs b/Math/LaTeX/Internal/Display.hs
new file mode 100644
--- /dev/null
+++ b/Math/LaTeX/Internal/Display.hs
@@ -0,0 +1,131 @@
+-- |
+-- Module      : Math.LaTeX.Internal.Display
+-- Copyright   : (c) Justus Sagemüller 2017
+-- License     : GPL v3
+-- 
+-- Maintainer  : (@) jsagemue $ uni-koeln.de
+-- Stability   : experimental
+-- Portability : requires GHC>7 extensions
+-- 
+
+{-# LANGUAGE OverloadedStrings   #-}
+{-# LANGUAGE RankNTypes          #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE UnicodeSyntax       #-}
+{-# LANGUAGE TemplateHaskell     #-}
+{-# LANGUAGE CPP                 #-}
+
+module Math.LaTeX.Internal.Display where
+
+import qualified Text.LaTeX as LaTeX
+import Text.LaTeX (raw)
+import Text.LaTeX.Base.Class (LaTeXC, fromLaTeX)
+import qualified Text.LaTeX.Base.Class as LaTeX
+import qualified Text.LaTeX.Base.Types as LaTeX
+import qualified Text.LaTeX.Base.Commands as LaTeX
+import Text.LaTeX.Base.Syntax (LaTeX(TeXEnv))
+import qualified Text.LaTeX.Packages.AMSMath as LaTeX
+import qualified Text.LaTeX.Packages.AMSFonts as LaTeX
+
+import CAS.Dumb
+import CAS.Dumb.Tree
+import CAS.Dumb.Symbols
+import CAS.Dumb.LaTeX.Symbols
+import Math.LaTeX.Internal.MathExpr
+
+import Data.Foldable (fold)
+import Data.Monoid ((<>))
+import Control.Arrow
+import Data.String (fromString)
+
+
+infixl 1 >$
+(>$) :: (LaTeXC r, SymbolClass σ, SCConstraint σ LaTeX)
+        => r -> CAS (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX) -> r
+s >$ m = s <> " " <> LaTeX.math (toMathLaTeX' m)
+
+-- | Include a formula / equation system as a LaTeX display. If it's a single
+--   equation, automatic line breaks are inserted (requires the
+--   <https://www.ctan.org/pkg/breqn?lang=en breqn LaTeX package>).
+dmaths :: (LaTeXC r, SymbolClass σ, SCConstraint σ LaTeX)
+   => [[CAS (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)]]
+               -- ^ Equations to show.
+    -> String  -- ^ “Terminator” – this can include punctuation (when an equation
+               --   is at the end of a sentence in the preceding text).
+    -> r
+dmaths [[e]] garnish = case eqnum of
+    Nothing -> fromLaTeX . TeXEnv "dmath*" [] $ toMathLaTeX e <> terminator
+    Just n  -> fromLaTeX . TeXEnv "equation" [] $ n <> toMathLaTeX e <> terminator
+ where (eqnum, terminator) = parseEqnum garnish
+dmaths eqLines garnish = fromLaTeX . TeXEnv
+           (case eqnum of{Nothing->"align*";Just _->"align"}) [] $ stack eqLines
+ where stack [singline] = fold eqnum <> aliLine singline <> terminator
+       stack (line : lines) = aliLine line <> LaTeX.lnbk <> stack lines
+       aliLine [] = mempty
+       aliLine [q] = contentsWithAlignAnchor q
+       aliLine (q : cols)
+             = contentsWithAlignAnchor q LaTeX.& aliLine cols
+       (eqnum, terminator) = parseEqnum garnish
+
+-- | Include a formula / equation system as a LaTeX display.
+maths :: (LaTeXC r, SymbolClass σ, SCConstraint σ LaTeX)
+  => [[CAS (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)]]
+              -- ^ Equations to show.
+   -> String  -- ^ “Terminator” – this can include punctuation (when an equation
+              --   is at the end of a sentence in the preceding text).
+   -> r
+maths [[e]] garnish = case eqnum of
+   Nothing -> fromLaTeX . TeXEnv "equation*" [] $ toMathLaTeX e <> terminator
+   Just n  -> fromLaTeX . TeXEnv "equation" [] $ n <> toMathLaTeX e <> terminator
+ where (eqnum, terminator) = parseEqnum garnish
+maths eqLines garnish = fromLaTeX . TeXEnv
+           (case eqnum of{Nothing->"align*";Just _->"align"}) [] $ stack eqLines
+ where stack [singline] = fold eqnum <> aliLine singline <> terminator
+       stack (line : lines) = aliLine line <> LaTeX.lnbk <> stack lines
+       aliLine [] = mempty
+       aliLine [q] = contentsWithAlignAnchor q
+       aliLine (q : cols)
+             = contentsWithAlignAnchor q LaTeX.& aliLine cols
+       (eqnum, terminator) = parseEqnum garnish
+
+-- | Display an equation and also extract the final result. As with 'dmaths', automatic
+--   line breaks are inserted by <https://www.ctan.org/pkg/breqn?lang=en breqn>.
+dcalculation :: (LaTeXC (m ()), SymbolClass σ, SCConstraint σ LaTeX, Functor m)
+  => CAS (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)
+              -- ^ Computation chain to display.
+   -> String  -- ^ “Terminator” – this can include punctuation (when an equation
+              --   is at the end of a sentence in the preceding text).
+   -> m (CAS (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX))
+              -- ^ Yield the rightmost expression in the displayed computation
+              --   (i.e. usually the final result in a chain of algebraic equalities).
+dcalculation ch garnish = fmap (\() -> result) $ case eqnum of
+    Nothing -> fromLaTeX . TeXEnv "dmath*" [] $ toMathLaTeX ch <> terminator
+    Just n  -> fromLaTeX . TeXEnv "equation" [] $ n <> toMathLaTeX ch <> terminator
+ where (eqnum, terminator) = parseEqnum garnish
+       result = case ch of
+        OperatorChain _ ((_,r):_) -> r
+        r -> r
+
+parseEqnum :: LaTeXC r => String -> (Maybe r, r)
+parseEqnum [] = (Nothing, mempty)
+parseEqnum ('.':n) = second ("."<>) $ parseEqnum n
+parseEqnum (',':n) = second (","<>) $ parseEqnum n
+parseEqnum ('!':n) = second ("!"<>) $ parseEqnum n
+parseEqnum ('?':n) = second ("?"<>) $ parseEqnum n
+parseEqnum (';':n) = second (";"<>) $ parseEqnum n
+parseEqnum (':':n) = second (raw"{:}"<>) $ parseEqnum n
+parseEqnum ('(':n) = ( Just $ raw"\\tag{"<>fromString num<>raw"}"
+                     , snd $ parseEqnum r )
+ where (num,')':r) = break (==')') n
+parseEqnum (c:n) = parseEqnum n
+
+
+contentsWithAlignAnchor :: (LaTeXC c, SymbolClass σ, SCConstraint σ LaTeX)
+      => CAS (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX) -> c
+contentsWithAlignAnchor (OperatorChain lc rcs@(_:_))
+    = toMathLaTeX' lc <> fromLaTeX op
+         <> raw"\\:"LaTeX.&toMathLaTeX' (OperatorChain rc₀ $ init rcs)
+ where (Infix _ op, rc₀) = last rcs
+contentsWithAlignAnchor (Operator (Infix _ op) lc rc)
+    = toMathLaTeX' lc <> fromLaTeX op <> raw"\\:"LaTeX.&toMathLaTeX' rc
+contentsWithAlignAnchor q = raw"\\:" LaTeX.& toMathLaTeX' q
diff --git a/Math/LaTeX/Internal/MathExpr.hs b/Math/LaTeX/Internal/MathExpr.hs
new file mode 100644
--- /dev/null
+++ b/Math/LaTeX/Internal/MathExpr.hs
@@ -0,0 +1,363 @@
+-- |
+-- Module      : Math.LaTeX.Internal.MathExpr
+-- Copyright   : (c) Justus Sagemüller 2017
+-- License     : GPL v3
+-- 
+-- Maintainer  : (@) jsagemue $ uni-koeln.de
+-- Stability   : experimental
+-- Portability : requires GHC>7 extensions
+-- 
+
+{-# LANGUAGE OverloadedStrings   #-}
+{-# LANGUAGE RankNTypes          #-}
+{-# LANGUAGE FlexibleContexts    #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE UnicodeSyntax       #-}
+{-# LANGUAGE TemplateHaskell     #-}
+{-# LANGUAGE TupleSections       #-}
+{-# LANGUAGE CPP                 #-}
+
+module Math.LaTeX.Internal.MathExpr where
+
+import qualified Text.LaTeX as LaTeX
+import Text.LaTeX (raw)
+import Text.LaTeX.Base.Class (LaTeXC, fromLaTeX)
+import qualified Text.LaTeX.Base.Class as LaTeX
+import qualified Text.LaTeX.Base.Types as LaTeX
+import qualified Text.LaTeX.Base.Commands as LaTeX
+import Text.LaTeX.Base.Syntax (LaTeX(TeXEnv))
+import qualified Text.LaTeX.Packages.AMSMath as LaTeX
+import qualified Text.LaTeX.Packages.AMSFonts as LaTeX
+
+import CAS.Dumb
+import CAS.Dumb.Tree
+import CAS.Dumb.Symbols
+import CAS.Dumb.LaTeX.Symbols
+import Math.LaTeX.Internal.OperatorGenerator
+
+import Data.Foldable (fold)
+import Data.Monoid ((<>))
+
+import qualified Language.Haskell.TH.Syntax as Hs
+import Language.Haskell.TH.Syntax (Fixity(..), FixityDirection(..))
+
+
+type MathsInfix = ∀ γ σ .
+      CAS' γ (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)
+       -> CAS' γ (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)
+              -> CAS' γ (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)
+
+atom :: l -> CAS' γ s² s¹ (SymbolD σ l)
+atom = Symbol . StringSymbol
+
+encapsulation :: l -> l
+              -> (CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l))
+              -> (CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l))
+encapsulation l r = Function $ Encapsulation False True l r
+
+opL, opR, opN :: LaTeXC l => Int -> l
+    -> CAS' γ (Infix l) (Encapsulation l) s⁰ -> CAS' γ (Infix l) (Encapsulation l) s⁰
+              -> CAS' γ (Infix l) (Encapsulation l) s⁰
+opL fxty iop = symbolInfix (Infix (Hs.Fixity fxty Hs.InfixL) iop)
+opR fxty iop = symbolInfix (Infix (Hs.Fixity fxty Hs.InfixR) iop)
+opN fxty iop = symbolInfix (Infix (Hs.Fixity fxty Hs.InfixN) iop)
+
+opL', opR', opN' :: LaTeXC l => Int -> (l->l->l)
+    -> CAS' γ (Infix l) (Encapsulation l) s⁰ -> CAS' γ (Infix l) (Encapsulation l) s⁰
+              -> CAS' γ (Infix l) (Encapsulation l) s⁰
+opL' fxty iop = symbolInfix (Infix (Hs.Fixity fxty Hs.InfixL) $ iop mempty mempty)
+opR' fxty iop = symbolInfix (Infix (Hs.Fixity fxty Hs.InfixR) $ iop mempty mempty)
+opN' fxty iop = symbolInfix (Infix (Hs.Fixity fxty Hs.InfixN) $ iop mempty mempty)
+
+infixl 6 ±, ∓, ⊕, +..+
+(±), (∓), (⊕), (+..+) :: MathsInfix
+(±) = opL 6 LaTeX.pm
+(∓) = opL 6 LaTeX.mp
+(⊕) = opL' 6 LaTeX.oplus
+(+..+) = opL 6 $ raw"+\\ldots+"
+
+infixl 7 ×, ∘, ⊗, *..*
+(×), (⊗), (∘), (*..*) :: MathsInfix
+(×) = opL' 7 LaTeX.times
+(⊗) = opL' 7 LaTeX.otimes
+(∘) = opL' 7 LaTeX.circ
+(*..*) = opL 7 $ raw"{\\cdot\\ldots\\cdot}"
+
+factorial :: LaTeXC l
+         => CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+          -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+factorial n = Operator (Infix (Hs.Fixity 8 Hs.InfixR) $ raw"!")
+                 n (Symbol $ StringSymbol mempty)
+
+
+infixr 3 ∧, ∨
+(∧), (∨) :: MathsInfix
+(∧) = opR 3 $ raw"\\wedge{}"
+(∨) = opR 3 $ raw"\\vee{}"
+
+(∩), (∪), (-\-) :: MathsInfix
+infixr 3 ∩
+(∩) = opR' 3 LaTeX.cap
+infixr 2 ∪
+(∪) = opR' 2 LaTeX.cup
+infixl 2 -\-
+(-\-) = opL' 2 LaTeX.setminus
+
+infixr 5 ⸪, -→, ↪
+(⸪), (-→), (↪) :: MathsInfix
+(⸪) = opR 5 ":"
+(-→) = opR 5 LaTeX.to
+(↪) = opR 5 $ raw"\\hookrightarrow{}"
+
+infix 2 ∀:, ∃:
+(∀:), (∃:) :: MathsInfix
+(∀:) = opN 2 $ raw"\\ \\:\\forall{}"
+(∃:) = opN 2 $ raw"\\ \\:\\exists{}"
+
+infixl 7 °
+infixr 9 ◝, ⁀, ◝⁀
+infixr 9 ◞
+infixl 8 |◞, |◝, |◞◝
+infixl 8 ◞◝, ₌₌
+(°), (⁀), (◝), (◝⁀), (◞), (|◞), (₌₌) :: MathsInfix
+f°x = opL 7 mempty f (encapsulation (raw"\\left(") (raw"\\right)") x)
+(⁀) = opR 9 mempty
+l◝⁀s = opR 9 mempty l $ encapsulation (raw"\\left(") (raw"\\right)^") s
+l◝s = Operator (Infix (Hs.Fixity 9 Hs.InfixR) mempty)
+             l (encapsulation (raw "^{") (raw "}") s)
+l◞s = Operator (Infix (Hs.Fixity 9 Hs.InfixR) mempty)
+             l (encapsulation (raw "_{") (raw "}") s)
+l₌₌s = Operator (Infix (Hs.Fixity 8 Hs.InfixR) mempty)
+             (encapsulation (raw "\\underbrace{") (raw "}") l)
+             (encapsulation (raw "_{") (raw "}") s)
+l◞◝(s,p) = Operator (Infix (Hs.Fixity 9 Hs.InfixR) mempty)
+             l
+           $ Operator (Infix (Hs.Fixity 9 Hs.InfixR) mempty)
+                   (encapsulation (raw "_{") (raw "}") s)
+                   (encapsulation (raw "^{") (raw "}") p)
+l|◝s = Operator (Infix (Hs.Fixity 8 Hs.InfixR) mempty)
+             (encapsulation (raw "left.") (raw "right|") l)
+             (encapsulation (raw "^{") (raw "}") s)
+l|◞s = Operator (Infix (Hs.Fixity 8 Hs.InfixR) mempty)
+             (encapsulation (raw "left.") (raw "right|") l)
+             (encapsulation (raw "_{") (raw "}") s)
+l|◞◝(s,p) = Operator (Infix (Hs.Fixity 8 Hs.InfixR) mempty)
+             (encapsulation (raw "left.") (raw "right|") l)
+           $ Operator (Infix (Hs.Fixity 8 Hs.InfixR) mempty)
+                   (encapsulation (raw "_{") (raw "}") s)
+                   (encapsulation (raw "^{") (raw "}") p)
+
+
+makeOperatorCaste "implicationOperators"
+                  (''MathsInfix, ''LaTeX)
+                  (Fixity 1 InfixL)
+                  True
+                  [ ("==>", [e|raw"\\Longrightarrow "|])
+                  , ("<==", [e|raw"\\Longleftarrow "|])
+                  , ("<=>", [e|raw"\\Longleftrightarrow "|])
+                  ]
+
+makeOperatorCaste "relationOperators"
+                  (''MathsInfix, ''LaTeX)
+                  (Fixity 4 InfixL)
+                  True
+                  [ ("⩵", [e|""LaTeX.=:""|])
+#if __GLASGOW_HASKELL__ > 802
+                  , ("⸪=", [e|raw"{:=}"|])
+                  , ("=⸪", [e|raw"{=:}"|])
+#endif
+                  , ("≡", [e|raw" \\equiv "|])
+                  , ("⩵!", [e|raw" \\overset{!}{=} "|])
+                  , ("≠", [e|""LaTeX./=:""|])
+                  , ("≈", [e|raw" \\approx "|])
+                  , ("∼", [e|raw" \\sim "|])
+                  , ("⪡", [e|""LaTeX.<:""|])
+                  , ("⪢", [e|""LaTeX.>:""|])
+                  , ("≤", [e|""LaTeX.<=:""|])
+                  , ("≥", [e|""LaTeX.>=:""|])
+                  , ("≪", [e|LaTeX.ll""""|])
+                  , ("≫", [e|LaTeX.gg""""|])
+                  , ("⊂", [e|LaTeX.subset""""|])
+                  , ("/⊂", [e|raw" \\not\\subset "|])
+                  , ("⊃", [e|LaTeX.supset""""|])
+                  , ("⊆", [e|raw"\\subseteq{}"|])
+                  , ("⊇", [e|raw"\\supseteq{}"|])
+                  , ("∋", [e|LaTeX.ni""""|])
+                  , ("∌", [e|raw"\\not\\ni{}"|])
+                  , ("=→", [e|LaTeX.to|])
+                  , ("∈", [e|LaTeX.in_""""|])
+                  , ("∉", [e|raw"\\not\\in{}"|])
+                  , ("↦", [e|LaTeX.mapsto|])
+                  ]
+
+del, nabla, infty :: (SymbolClass σ, SCConstraint σ LaTeX)
+          => CAS' γ s² s¹ (SymbolD σ LaTeX)
+del = atom LaTeX.partial
+nabla = atom $ raw "\\nabla{}\\!"
+infty = atom LaTeX.infty
+
+
+
+newtype Integrand γ s² s¹ s⁰ = Integrand { getIntgrand :: CAS' γ s² s¹ s⁰ }
+
+d :: LaTeXC l => CAS' γ (Infix l) (Encapsulation l) s⁰
+              -> CAS' γ (Infix l) (Encapsulation l) s⁰
+              -> Integrand γ (Infix l) (Encapsulation l) s⁰
+d x f = Integrand $ opR 7 (raw "\\ ") x f
+
+infixr 8 ∫, ◞∫, ◞∮, ∑, ◞∑, ∏, ◞∏
+
+(∫) :: LaTeXC l
+  => ( CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+     , CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l) )
+              -> Integrand γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+(l,r)∫Integrand i
+    = Operator (Infix (Hs.Fixity 7 Hs.InfixR) $ LaTeX.mathrm "d")
+             (Operator (Infix (Hs.Fixity 9 Hs.InfixN) $ raw "^")
+                (encapsulation (raw "\\int\\limits_{") (raw "}") l)
+                (encapsulation (raw "{") (raw "}") r) )
+             i
+
+(◞∫) :: LaTeXC l
+  => CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> Integrand γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+ω◞∫Integrand i
+    = Operator (Infix (Hs.Fixity 7 Hs.InfixR) $ LaTeX.mathrm "d")
+             (encapsulation (raw "\\int_{") (raw "}\\!\\!\\!") ω)
+             i
+
+(◞∮) :: LaTeXC l
+  => CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> Integrand γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+ω◞∮Integrand i
+    = Operator (Infix (Hs.Fixity 7 Hs.InfixR) $ LaTeX.mathrm "d")
+             (encapsulation (raw "\\oint_{") (raw "}\\!\\!\\!") ω)
+             i
+
+(∑) :: LaTeXC l
+  => ( CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+     , CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l) )
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+(l,r)∑m
+    = Operator (Infix (Hs.Fixity 7 Hs.InfixR) $ raw" ")
+             (Operator (Infix (Hs.Fixity 9 Hs.InfixN) $ raw "^")
+                (encapsulation (raw "\\sum_{") (raw "}") l)
+                (encapsulation (raw "{") (raw "}") r) )
+             m
+
+(◞∑) :: LaTeXC l
+  => CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+ω◞∑m
+    = Operator (Infix (Hs.Fixity 7 Hs.InfixR) $ raw " ")
+             (encapsulation (raw "\\sum_{") (raw "}") ω)
+             m
+
+(∏) :: LaTeXC l
+  => ( CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+     , CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l) )
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+(l,r)∏m
+    = Operator (Infix (Hs.Fixity 7 Hs.InfixR) $ raw" ")
+             (Operator (Infix (Hs.Fixity 9 Hs.InfixN) $ raw "^")
+                (encapsulation (raw "\\prod_{") (raw "}") l)
+                (encapsulation (raw "{") (raw "}") r) )
+             m
+
+(◞∏) :: LaTeXC l
+  => CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+              -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+ω◞∏m
+    = Operator (Infix (Hs.Fixity 7 Hs.InfixR) $ raw " ")
+             (encapsulation (raw "\\prod_{") (raw "}") ω)
+             m
+
+norm :: LaTeXC l => CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+            -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+norm = encapsulation (raw "\\left\\|") (raw "\\right\\|")
+    
+
+
+makeOperatorCaste "juxtapositionOperators"
+                  (''MathsInfix, ''LaTeX)
+                  (Fixity 0 InfixR)
+                  True
+                  [ ("␣", [e|raw"\\ "|])
+                  , ("...", [e|raw"{\\ldots}"|])
+#if __GLASGOW_HASKELL__ > 802
+                  , ("،", [e|raw","|])
+                  , ("،..،", [e|raw",\\ldots,"|])
+#endif
+                  ]
+
+
+matrix :: LaTeXC l =>
+        [[CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)]]
+          -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+matrix [] = set (Symbol $ StringSymbol mempty)
+matrix mlines = encapsulation (raw"\\begin{pmatrix}")
+                                   (raw"\\end{pmatrix}")
+     . OperatorChain le₀ . reverse
+                $ (Infix (Hs.Fixity 0 Hs.InfixL) LaTeX.lnbk, ) <$> les
+ where (le₀:les) = map (\(c₀:cs) -> OperatorChain c₀ . reverse
+                          $ (Infix (Hs.Fixity 1 Hs.InfixL) $ raw"&", ) <$> cs) mlines
+
+cases :: LaTeXC l
+     => [(CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l), LaTeX)]
+         -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+cases clauses = encapsulation (raw"\\begin{cases}") (raw"\\end{cases}")
+           . OperatorChain cl₀ . reverse
+                    $ (Infix (Hs.Fixity 0 Hs.InfixL) LaTeX.lnbk, ) <$> cls
+ where (cl₀:cls) = map (\(r,co) -> Operator (Infix (Hs.Fixity 1 Hs.InfixL) $ raw"&")
+                                     r $ Symbol (StringSymbol . LaTeX.comm1 "text"
+                                                     $ fromLaTeX co)
+                       ) clauses
+
+
+set, tup, intv, nobreaks :: LaTeXC l
+  => CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+    -> CAS' γ (Infix l) (Encapsulation l) (SymbolD σ l)
+set = encapsulation (raw"\\left\\{") (raw"\\right\\}")
+tup = encapsulation (raw"\\left(") (raw"\\right)")
+intv = encapsulation (raw"\\left[") (raw"\\right]")
+nobreaks = encapsulation (raw"{") (raw"}")
+
+
+infix 5 <.<, ≤.<, <.≤, ≤.≤
+(<.<), (≤.<), (<.≤), (≤.≤) :: MathsInfix
+l <.< r = encapsulation (raw"\\left]") (raw"\\right[") $ opN 0 (raw",") l r
+l ≤.< r = encapsulation (raw"\\left[") (raw"\\right[") $ opN 0 (raw",") l r
+l <.≤ r = encapsulation (raw"\\left]") (raw"\\right]") $ opN 0 (raw",") l r
+l ≤.≤ r = encapsulation (raw"\\left[") (raw"\\right]") $ opN 0 (raw",") l r
+
+
+
+
+toMathLaTeX' :: ∀ σ l . (LaTeXC l, SymbolClass σ, SCConstraint σ LaTeX)
+     => CAS (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX) -> l
+toMathLaTeX' = fromLaTeX . toMathLaTeX
+
+toMathLaTeX :: ∀ σ l . (LaTeXC l, Num l, SymbolClass σ, SCConstraint σ l)
+                => CAS (Infix l) (Encapsulation l) (SymbolD σ l) -> l
+toMathLaTeX = renderSymbolExpression (AtLHS $ Hs.Fixity 0 Hs.InfixL) ρ
+ where ρ dop lctxt (StringSymbol sym) rctxt
+           = showLParen dop $ flip (foldr (<>)) lctxt $ foldl (<>) sym rctxt
+       ρ dop lctxt (NatSymbol n) rctxt
+           = showLParen dop $ flip (foldr (<>)) lctxt $ foldl (<>) (fromInteger n) rctxt
+       ρ dop lctxt (PrimitiveSymbol c) rctxt
+           = case fromCharSymbol ([]::[σ]) of
+              fcs -> showLParen dop $ flip (foldr (<>)) lctxt $ foldl (<>) (fcs c) rctxt
+
+showLParen :: LaTeXC l => Bool -> l -> l
+showLParen True  = LaTeX.autoParens
+showLParen False = id
+
+
+
diff --git a/Math/LaTeX/Internal/OperatorGenerator.hs b/Math/LaTeX/Internal/OperatorGenerator.hs
new file mode 100644
--- /dev/null
+++ b/Math/LaTeX/Internal/OperatorGenerator.hs
@@ -0,0 +1,79 @@
+-- |
+-- Module      : Math.LaTeX.Internal.OperatorGenerator
+-- Copyright   : (c) Justus Sagemüller 2017
+-- License     : GPL v3
+-- 
+-- Maintainer  : (@) jsagemue $ uni-koeln.de
+-- Stability   : experimental
+-- Portability : portable
+-- 
+
+{-# LANGUAGE TemplateHaskell     #-}
+{-# LANGUAGE PatternSynonyms     #-}
+{-# LANGUAGE QuasiQuotes         #-}
+{-# LANGUAGE CPP                 #-}
+
+module Math.LaTeX.Internal.OperatorGenerator where
+
+import CAS.Dumb.Tree
+import CAS.Dumb.Symbols
+
+import Language.Haskell.TH
+import Language.Haskell.Meta.Parse
+import Data.Char
+
+import qualified Data.HashSet as HS
+import qualified Data.Hashable as HS
+
+operatorExpression :: Fixity -> s² -> CAS' γ (Infix s²) s¹ s⁰
+                -> CAS' γ (Infix s²) s¹ s⁰ -> CAS' γ (Infix s²) s¹ s⁰
+operatorExpression fxty iop = symbolInfix (Infix fxty iop)
+
+chainOperatorExpression :: (Eq s², HS.Hashable s²)
+          => Fixity -> HS.HashSet s² -> s² -> CAS' γ (Infix s²) s¹ s⁰
+                -> CAS' γ (Infix s²) s¹ s⁰ -> CAS' γ (Infix s²) s¹ s⁰
+chainOperatorExpression fxty caste iop = chainableInfix isInCaste (Infix fxty iop)
+ where isInCaste (Infix _ iop') = iop' `HS.member` caste
+
+makeOperatorCaste :: String   -- ^ What to call the collection of operators
+                  -> (Name, Name)
+                              -- ^ Haskell type of the final operators
+                              --   and of the infix primitives therein
+                  -> Fixity
+                  -> Bool     -- ^ Should the ops in this caste be chainable?
+                  -> [(String, ExpQ)]
+                              -- ^ The operator symbols with corresponding implementation
+                  -> DecsQ
+makeOperatorCaste caste (typeSig, opType) fxty isChainable ops
+                = fmap concat $ (:) <$> mkCollection
+                                    <*> mapM mkOp ops
+ where mkCollection
+        | isChainable  = do
+           opRenditions <- mapM snd ops
+           return
+            [ SigD casteName $ ConT ''HS.HashSet `AppT` ConT opType
+            , ValD (VarP casteName)
+                   (NormalB
+                     $ VarE 'HS.fromList
+                        `AppE` ListE opRenditions )
+                   []
+            ]
+        | otherwise    = return []
+       mkOp (op, implementation) = do
+        impExp <- implementation
+        return
+         [ InfixD fxty opName
+         , SigD opName $ ConT typeSig
+         , ValD (VarP opName)
+                (NormalB
+                   $ if isChainable
+                      then VarE 'chainOperatorExpression
+                             `AppE` fxtyE `AppE` VarE casteName `AppE` impExp
+                      else VarE 'operatorExpression `AppE` fxtyE `AppE` impExp)
+                [] ]
+        where opName = mkName op
+              fxtyE = case parseExp $ show fxty of
+                 Right fe -> fe
+                 Left err -> error err
+       casteName = mkName caste
+
diff --git a/Math/LaTeX/Prelude.hs b/Math/LaTeX/Prelude.hs
new file mode 100644
--- /dev/null
+++ b/Math/LaTeX/Prelude.hs
@@ -0,0 +1,63 @@
+-- |
+-- Module      : Math.LaTeX.Prelude
+-- Copyright   : (c) Justus Sagemüller 2017
+-- License     : GPL v3
+-- 
+-- Maintainer  : (@) jsagemue $ uni-koeln.de
+-- Stability   : experimental
+-- Portability : requires GHC>7 extensions
+-- 
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE CPP               #-}
+
+module Math.LaTeX.Prelude (
+   -- * Use in documents
+     toMathLaTeX, (>$), dmaths, maths, dcalculation
+   -- * Primitive symbols
+   , module CAS.Dumb.Symbols.Unicode.MathLatin_RomanGreek__BopomofoGaps
+   -- ** Modifiers
+   , (%$>), prime, LaTeX.bar, LaTeX.hat, LaTeX.vec, LaTeX.underline, LaTeX.tilde
+   -- * Operators
+   , (°), (⁀), (...)
+#if __GLASGOW_HASKELL__ > 802
+   , (،..،), (،), (⸪=), (=⸪)
+#endif
+   , (␣), (+..+), (*..*), (×), (⊗), (∘), factorial
+   , (◝), (◝⁀), (◞), (◞◝), (|◞), (|◝), (|◞◝)
+   , (⩵), (≡), (⩵!), (≠), (⪡), (⪢), (≤), (≥), (≪), (≫), (₌₌)
+   , (=→), (≈), (∼)
+   , (⊂), (/⊂), (⊆), (⊃), (⊇), (∋), (∌), (∈), (∉), (∩), (∪), (-\-), (⸪), (⊕)
+   , (∀:), (∃:)
+   , (-→), (↦), (↪), (==>), (<==), (<=>), (∧), (∨)
+   , (∫), (◞∫), (◞∮), d, (∑), (◞∑), (∏), (◞∏), del, nabla
+   , (<.<), (≤.<), (<.≤), (≤.≤), (±), (∓), set, tup, intv
+   , infty, norm
+   , nobreaks, matrix, cases
+   -- * Algebraic manipulation
+   , (&~~!), (&~~:), continueExpr, (&)
+   , (&~:), (&~?), (&~!), (|->)
+   ) where
+
+import CAS.Dumb.Symbols.Unicode.MathLatin_RomanGreek__BopomofoGaps hiding ((%$>))
+import CAS.Dumb.Symbols
+import Math.LaTeX.Internal.MathExpr
+import Math.LaTeX.Internal.Display
+
+import Text.LaTeX.Base.Class (LaTeXC)
+import Text.LaTeX.Base (raw)
+import qualified Text.LaTeX.Packages.AMSMath as LaTeX
+import qualified Text.LaTeX.Base.Commands as LaTeX
+
+import Data.Monoid
+import Data.Function ((&))
+
+import CAS.Dumb.Tree
+
+
+
+prime :: LaTeXC l => l -> l
+prime = (<>raw"'")
+
+infix 2 |->
+(|->) :: CAS' γ s² s¹ s⁰ -> CAS' γ s² s¹ s⁰ -> Equality' γ s² s¹ s⁰
+(|->) = (:=:)
diff --git a/Math/LaTeX/StringLiterals.hs b/Math/LaTeX/StringLiterals.hs
new file mode 100644
--- /dev/null
+++ b/Math/LaTeX/StringLiterals.hs
@@ -0,0 +1,32 @@
+-- |
+-- Module      : Math.LaTeX.StringLiterals
+-- Copyright   : (c) Justus Sagemüller 2017
+-- License     : GPL v3
+-- 
+-- Maintainer  : (@) jsagemue $ uni-koeln.de
+-- Stability   : experimental
+-- Portability : requires GHC>7 extensions
+-- 
+-- An orphan instance to the 'FromString' class, which allows maths expressions
+-- to include literal strings. These will be rendered in roman font.
+
+{-# LANGUAGE OverloadedStrings    #-}
+{-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+module Math.LaTeX.StringLiterals where
+
+import qualified Text.LaTeX as LaTeX
+import Text.LaTeX.Base.Syntax (LaTeX)
+import qualified Text.LaTeX.Packages.AMSMath as LaTeX
+
+import CAS.Dumb
+import CAS.Dumb.Tree
+import CAS.Dumb.Symbols
+
+import Data.String
+
+
+instance (SymbolClass σ, SCConstraint σ LaTeX)
+     => IsString (CAS' γ (Infix LaTeX) (Encapsulation LaTeX) (SymbolD σ LaTeX)) where
+  fromString = Symbol . StringSymbol . LaTeX.mathrm . fromString
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/TeX-my-math.cabal b/TeX-my-math.cabal
new file mode 100644
--- /dev/null
+++ b/TeX-my-math.cabal
@@ -0,0 +1,81 @@
+Name:                TeX-my-math
+Version:             0.201.0.0
+Category:            math
+Synopsis:            Render general Haskell math to LaTeX. Or: math typesetting with high signal-to-noise–ratio.
+Description:         For tl;dr: look at <https://github.com/leftaroundabout/Symbolic-math-HaTeX/blob/master/EXAMPLES.md>.
+                     .
+                     This is an attempt to get convenient math syntax in HaTeX (i.e., in data structures
+                     compatible \/ convertable to those from <http://hackage.haskell.org/package/HaTeX>).
+                     .
+                     The idea is to combine these features:
+                     .
+                     * Full access to the math-typesetting power of LaTeX. It should be possible to express
+                         any formula that might be found in a typical mathematics or physics journal article.
+                         This should also include expression which are not quite well-defined from a programming
+                         point of view, but are clear to the intended audience.
+                     .
+                     * Idiomatic Haskell syntax. Who wants to bother with unreadable expressions involving
+                         either hundreds of double-backslashes or extra syntax overhead in wrapping them
+                         explicitly into HaTeX?
+                     .
+                     Ideally, one would write expressions as if only meaning Haskell to /calculate/ them,
+                     but get the result back as a full pretty-printing LaTeX math string. /And the actual
+                     calculated result as well/, if possible!
+                     .
+                     To this end, we use a minimal symbolic-manipulation EDSL, namely
+                     <http://hackage.haskell.org/package/dumb-cas dumb-cas>, set up in a way so the
+                     leaves of the syntax tree, i.e. the individual symbols, are represented by LaTeX
+                     expressions in memory and by single-letter variables in the Haskell code.
+                     These can then be combined with operators corresponding to LaTeX's maths operators,
+                     to obtain a very compact and almost WYSIWYG-like code appearance, while retaining
+                     the ability to apply any LaTeX-specific tweaks whenever necessary. At the same
+                     time, because the AST is fully precedence-aware, it is safely possible to transform
+                     the expressions via e.g. Template Haskell, to actually compute concrete numerical
+                     results, or apply exact symbolic-manipulation techniques.
+License:             GPL-3
+License-file:        COPYING
+Author:              Justus Sagemüller
+Maintainer:          (@) jsagemue $ uni-koeln.de
+Homepage:            http://github.com/leftaroundabout/Symbolic-math-HaTeX
+Build-Type:          Simple
+Cabal-Version:       >=1.10
+
+Library
+  Build-Depends:     base>=4.8 && <4.11
+                     , HaTeX>3.4
+                     , vector-space
+                     , dumb-cas >= 0.1 && < 0.2
+                     , decimal-literals
+                     , text
+                     , void
+                     , hashable, unordered-containers
+                     , template-haskell, haskell-src-meta
+  Exposed-modules:   Math.LaTeX.Prelude
+                     Math.LaTeX.StringLiterals
+                     Math.LaTeX.Internal.MathExpr
+                     Math.LaTeX.Internal.Display
+  Other-modules:     CAS.Dumb.LaTeX.Symbols
+                     Math.LaTeX.Internal.OperatorGenerator
+  Default-Language:    Haskell2010
+
+test-suite makeSnippets
+  default-language:
+    Haskell2010
+  type:
+    exitcode-stdio-1.0
+  hs-source-dirs:
+    test/PdfSnippets
+  main-is:
+    MkSnippets.hs
+  Other-modules:
+    LaTeXComparer
+  build-depends:
+      base >= 4 && < 5
+    , template-haskell, haskell-src-meta
+    , dumb-cas
+    , HaTeX
+    , TeX-my-math
+    , text
+    , directory, filepath, process
+  Default-Language:    Haskell2010
+
diff --git a/test/PdfSnippets/LaTeXComparer.hs b/test/PdfSnippets/LaTeXComparer.hs
new file mode 100644
--- /dev/null
+++ b/test/PdfSnippets/LaTeXComparer.hs
@@ -0,0 +1,37 @@
+-- |
+-- Module      : Main
+-- Copyright   : (c) Justus Sagemüller 2017
+-- License     : GPL v3
+-- 
+-- Maintainer  : (@) sagemueller $ geo.uni-koeln.de
+-- Stability   : experimental
+-- Portability : portable
+-- 
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TemplateHaskell   #-}
+
+module LaTeXComparer where
+
+
+import Math.LaTeX.Internal.MathExpr
+import CAS.Dumb
+
+import Language.Haskell.TH
+import Language.Haskell.TH.Quote
+import Language.Haskell.Meta.Parse
+
+import Text.LaTeX (LaTeX, Text)
+
+
+type Expr = Expression LaTeX
+type SLaTeX = Text
+
+data TestTree = TestGroup String [TestTree]
+              | TestCase Expr String SLaTeX
+
+
+mkLaTeXSnip :: QuasiQuoter
+mkLaTeXSnip = QuasiQuoter procExpr undefined undefined undefined
+ where procExpr e = return $ case parseExp e of
+           Right exp -> ConE 'TestCase `AppE` exp `AppE` LitE (StringL e)
+           Left perr -> error perr
diff --git a/test/PdfSnippets/MkSnippets.hs b/test/PdfSnippets/MkSnippets.hs
new file mode 100644
--- /dev/null
+++ b/test/PdfSnippets/MkSnippets.hs
@@ -0,0 +1,213 @@
+-- |
+-- Module      : Main
+-- Copyright   : (c) Justus Sagemüller 2017
+-- License     : GPL v3
+-- 
+-- Maintainer  : (@) sagemueller $ geo.uni-koeln.de
+-- Stability   : experimental
+-- Portability : portable
+-- 
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE CPP               #-}
+
+module Main where
+
+import LaTeXComparer
+
+import Math.LaTeX.Prelude
+import Math.LaTeX.StringLiterals
+
+import Text.LaTeX (LaTeX, raw, Text)
+import qualified Text.LaTeX as LaTeX
+import qualified Data.Text as Txt
+import qualified Data.Text.IO as Txt
+import Data.Char
+
+import CAS.Dumb
+
+import System.FilePath
+import System.Directory
+import System.Process
+
+import Data.Monoid
+import Data.Function ((&))
+import Control.Monad
+
+
+main :: IO ()
+main = do
+   examples <- evalTests tests
+   Txt.writeFile "EXAMPLES.md"
+      $ "_This file was generated automatically from [MkSnippets.hs](test/PdfSnippets/MkSnippets.hs). Run `cabal test` to refresh it._\n"
+       <> examples
+   
+
+
+tests :: TestTree
+tests = testGroup "Tests"
+  [ testGroup "Simple expressions"
+     [ [mkLaTeXSnip|        𝑎 + 𝑏 * 𝑐 |] "a+b{\\cdot}c"
+#if __GLASGOW_HASKELL__ > 802
+     , [mkLaTeXSnip|        𝐴 * 𝐵 + 𝐶 |] "A{\\cdot}B+C"
+#endif
+     , [mkLaTeXSnip|      (𝑎 + 𝑏) * 𝑐 |] "\\left(a+b\\right){\\cdot}c"
+     , [mkLaTeXSnip|(𝑎 + 𝑏) / (𝑥 - 𝑦) |] "\\frac{a+b}{x-y}"
+     , [mkLaTeXSnip| (𝑎 + 𝑏)**(𝑥 - 𝑦) |] "\\left(a+b\\right)^{x-y}"
+     , [mkLaTeXSnip|         (𝑝/𝑞)**γ |] "\\left(\\frac{p}{q}\\right)^{\\gamma{}}"
+     , [mkLaTeXSnip|      abs(𝑝/𝑞)**ξ |] "\\left|\\frac{p}{q}\\right|^{\\xi{}}"
+     , [mkLaTeXSnip|          𝑎**𝑏**𝑐 |] "a^{b^{c}}"
+     , [mkLaTeXSnip|        (𝑎**𝑏)**𝑐 |] "\\left(a^{b}\\right)^{c}"
+     , [mkLaTeXSnip|      sin (sin 𝑥) |] "\\sin{\\left(\\sin{x}\\right)}"
+     , [mkLaTeXSnip|       (𝑖⩵0,3)∑ 𝑖 |] "\\sum_{i=0}^{3} i"
+     , [mkLaTeXSnip|   matrix[[ 0,1]
+                             ,[-1,0]] |] "\\begin{pmatrix}0&1\\\\-1&0\\end{pmatrix}"
+     ]
+  , testGroup "Number literals"
+     [ [mkLaTeXSnip| 25697325 |] "25697325"
+     , [mkLaTeXSnip|    4.718 |] "4.718"
+     , [mkLaTeXSnip|     1e-3 |] "1{\\cdot}10^{-3}"
+     , [mkLaTeXSnip| 257.35e9 |] "2.5735{\\cdot}10^{11}"
+     , [mkLaTeXSnip|  -5.1e-8 |] "-5.1{\\cdot}10^{-8}"
+     , [mkLaTeXSnip|     7/13 |] "\\frac{7}{13}"
+     , [mkLaTeXSnip|   -(1/2) |] "-\\frac{1}{2}"
+     ]
+  , testGroup "Operators"
+     [ testGroup "Arithmetic"
+        [ [mkLaTeXSnip| 𝑎 + 𝑏 |] "a+b"
+        , [mkLaTeXSnip| 𝑎 - 𝑏 |] "a-b"
+        , [mkLaTeXSnip| 𝑎 * 𝑏 |] "a{\\cdot}b"
+        , [mkLaTeXSnip| 𝑎 × 𝑏 |] "a\\times{}b"
+        , [mkLaTeXSnip| 𝑎 ± 𝑏 |] "a\\pm{}b"
+        , [mkLaTeXSnip| 𝑎 ∓ 𝑏 |] "a\\mp{}b"
+        , [mkLaTeXSnip| 𝑎 ⊕ 𝑏 |] "a\\oplus{}b"
+        , [mkLaTeXSnip| 𝑎 ⊗ 𝑏 |] "a\\otimes{}b"
+        ]
+     , testGroup "Sub/superscripts"
+        [ [mkLaTeXSnip|         𝑎◞𝑏 |] "a_{b}"
+        , [mkLaTeXSnip|    𝑎◞◝(𝑏,𝑐) |] "a_{b}^{c}"
+        , [mkLaTeXSnip|     ψ◞"Foo" |] "\\psi{}_{\\mathrm{Foo}}"
+#if __GLASGOW_HASKELL__ > 802
+        , [mkLaTeXSnip|     ψ◞𝐹⁀𝑜⁀𝑜 |] "\\psi{}_{Foo}"
+#endif
+        ]
+     , testGroup "Function application"
+        [ [mkLaTeXSnip|         𝑓°𝑥 |] "f\\left(x\\right)"
+#if __GLASGOW_HASKELL__ > 802
+        , [mkLaTeXSnip|     𝑓°(𝑥،𝑦) |] "f\\left(x,y\\right)"
+#endif
+        ]
+     , testGroup "Logical"
+        [ [mkLaTeXSnip| 𝑝 ∨ 𝑞 |] "p\\vee{}q"
+        , [mkLaTeXSnip| 𝑝 ∧ 𝑞 |] "p\\wedge{}q"
+        , [mkLaTeXSnip| 𝑝==>𝑞 |] "p\\Longrightarrow q"
+        , [mkLaTeXSnip| 𝑝<==𝑞 |] "p\\Longleftarrow q"
+        , [mkLaTeXSnip| 𝑝<=>𝑞 |] "p\\Longleftrightarrow q"
+        , [mkLaTeXSnip| 𝑝==>𝑞==>𝑟 |] "p\\Longrightarrow q\\Longrightarrow r"
+        , [mkLaTeXSnip| cases[(1, "Today"), (2, "Else")] |]
+                           "\\begin{cases}1&\\text{Today}\\\\2&\\text{Else}\\end{cases}"
+        ]
+     , testGroup "Relations"
+        [ [mkLaTeXSnip| 𝑎 ⩵ 𝑏 |] "a=b"
+        , [mkLaTeXSnip| 𝑎 ≥ 𝑐 |] "a\\geq{}c"
+        , [mkLaTeXSnip| 𝑎 ⪡ ρ |] "a<\\rho{}"
+        , [mkLaTeXSnip| 𝑥 ⩵ 𝑦 ⩵ 𝑧 |] "x=y=z"
+        , [mkLaTeXSnip| 𝑠 ⊂ 𝑡 ⊆ 𝑢 |] "s\\subset{}t\\subseteq{}u"
+#if __GLASGOW_HASKELL__ > 802
+        , [mkLaTeXSnip| 𝑝 ∈ ℚ ⊂ ℝ |] "p\\in{}\\mathbb{Q}\\subset{}\\mathbb{R}"
+#endif
+        ]
+     ]
+  , testGroup "Calculus"
+     [ testGroup "Integration"
+        [ [mkLaTeXSnip| (-1,1)∫d 𝑥 (𝑥**2) |] "\\int\\limits_{-1}^{1}\\mathrm{d}x\\ x^{2}"
+        , [mkLaTeXSnip| ω◞∫d 𝑥 (exp $ -(𝑥**2)) |]
+              "\\int_{\\omega{}}\\!\\!\\!\\mathrm{d}x\\ \\exp{\\left(-x^{2}\\right)}"
+        , [mkLaTeXSnip| (0,1)∫d 𝑥 ((0,1)∫d 𝑦 (𝑥*𝑦)) |]
+              "\\int\\limits_{0}^{1}\\mathrm{d}x\\ \\int\\limits_{0}^{1}\\mathrm{d}y\\ \\left(x{\\cdot}y\\right)"
+        ]
+     ]
+  , testGroup "Algebraic manipulation"
+     [ [mkLaTeXSnip| 𝑎 + 𝑏 + 𝑐 &~~! [𝑏 ⩵ 𝑦] |]
+         "a+b+c=a+y+c"
+     , [mkLaTeXSnip| 𝑎 + 𝑏 + 𝑐 &~~! [𝑏+𝑐 ⩵ 𝑐+𝑏, 𝑎+𝑐 ⩵ ξ] |]
+         "a+b+c=\\xi{}+b"
+     , [mkLaTeXSnip| 𝑎 - 𝑏 &~~! [𝑏 ⩵ 𝑦] &~~! [𝑎 ⩵ 𝑧] |]
+         "a-b=a-y=z-y"
+     , [mkLaTeXSnip| 𝑥 + 𝑦
+                  & continueExpr (⩵) (&~: 𝑦 :=: 𝑥*(1+𝑥))
+                  & continueExpr (⩵) (&~: 𝑥 :=: 2◝𝑝) |]
+         "x+y=x+x{\\cdot}\\left(1+x\\right)=2^{p}+2^{p}{\\cdot}\\left(1+2^{p}\\right)"
+     ]
+  ]
+
+
+testGroup :: String -> [TestTree] -> TestTree
+testGroup = TestGroup
+
+evalTests :: TestTree -> IO Text
+evalTests = go False 1
+ where go hasHeader _ (TestCase e ec s)
+        | s==s'    = do
+         let snipName = "test/PdfSnippets"</>encode (Txt.unpack s)
+         doesFileExist (snipName<.>".png") >>= flip
+            (when . not)`id` do
+                Txt.writeFile ("expression.tex") $ Txt.unlines
+                   [ "\\documentclass[border=2pt]{standalone}"
+                   , "\\usepackage[utf8x]{inputenc}"
+                   , "\\usepackage{amsmath}"
+                   , "\\usepackage{amssymb}"
+                   , "\\pagestyle{empty}"
+                   , "\\begin{document}"
+                   , "$"<>s<>"$"
+                   , "\\end{document}"
+                   ]
+                readProcess "pdflatex" ["expression.tex"] ""
+                callProcess "convert" [ "-density","300"
+                                      , "-background","grey", "-alpha","remove"
+                                      , "expression.pdf", snipName<.>"png" ]
+         return . (if hasHeader then id
+                                else (("| Haskell | LaTeX | pdf |"
+                                   <>"\n| ---: | --- | :--- |\n")<>)) $
+           "| "<>mconcat["`"<>Txt.pack (dropWhile (==' ') ecl)<>"` " | ecl<-lines ec]
+           <>"| `"<>mkGithubtablesaveCode s
+           <>"` | ![pdflatex-rendered version of `"<>mkGithubtablesaveCode s
+                            <>"`]("<>Txt.pack(snipName<.>"png")<>") |\n"
+        | otherwise    = error $ "Got "<>show s'<>"; expected "
+                                  <> show s<>", when rendering "<>ec
+        where s' = LaTeX.render (toMathLaTeX e)
+       go _ i (TestGroup g (s₀:s))
+              = (Txt.pack (replicate i '#' <> " " <> g <> "\n") <>)
+               . Txt.concat <$> ((:) <$> go False (i+1) s₀
+                                     <*> mapM (go True $ i+1) s)
+
+
+
+encode :: String -> String
+encode = concatMap enc
+ where enc c
+        | isAlphaNum c = [c]
+       enc '+' = "⼦"
+       enc '-' = "⼀"
+       enc '\\' = "ᓭ"
+       enc '{' = "ⶈ"
+       enc '}' = "ⶉ"
+       enc '(' = "ᑕ"
+       enc ')' = "ᑐ"
+       enc '^' = "ᐞ"
+       enc '_' = "⣀"
+       enc '|' = "ᛁ"
+       enc '!' = "⢘"
+       enc '&' = "ತ"
+       enc '=' = "〧"
+       enc '<' = "ᐸ"
+       enc '>' = "ᐳ"
+       enc ',' = "،"
+       enc '.' = "៰"
+       enc ' ' = "ᐧ"
+       enc c = error $ "Unencodable character '"++[c]++"'"
+
+mkGithubtablesaveCode :: Text -> Text
+mkGithubtablesaveCode = Txt.concatMap esc
+ where esc '|' = "\\|"
+       esc c = Txt.singleton c