Commits

Yoav Artzi committed 7e556b7

Initial commit

Comments (0)

Files changed (456)

+.DS_Store
+*.pyc
+run.*
+
+bin/
+dist/
+build/
+build.src/
+
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  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
+this service 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 make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  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.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the 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 a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE 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.
+
+                     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
+convey 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 2 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision 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, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This 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.
+[_**UW SPF 1.0**_](http://yoavartzi.com/spf) - The University of Washington Semantic Parsing Framework v1.0
+
+**Developed and maintained by** [Yoav Artzi](http://yoavartzi.com)
+
+**Contributors:** [Luke Zettlemoyer](http://homes.cs.washington.edu/~lsz/), Tom Kwiatkowski
+
+# Documentations
+
+Coming soon … 
+
+# Attribution
+
+When using UWSPF, please acknowledge it by citing:
+
+Artzi, Yoav and Zettlemoyer, Luke. "UW SPF: The University of Washington Semantic Parsing Framework." http://yoavartzi.com/spf. 2013.
+
+**Bibtex:**
+
+@article{artzi2013uwspf,
+	title={UW SPF: The University of Washington Semantic Parsing Framework},
+	author={Artzi, Yoav and Zettlemoyer, Luke},
+	year={2013}
+}
+
+When using specific algorithms please cite the appropriate work:
+
+## Validation based learning, joint inference and coarse-to-fine lexical generation
+(Classes: JointValidationSensitivePerceptron, JointModel, IJointFeatureSet, JointTemplatedAbstractLexiconGenerator, TemplatedAbstractLexiconGenerator)
+
+[Weakly Supervised Learning of Semantic Parsers for Mapping Instructions to Actions](http://yoavartzi.com/pub/az-tacl.2013.pdf)
+Yoav Artzi and Luke Zettlemoyer
+In Transactions of the Association for Computational Linguistics (TACL), 2013.
+
+## Loss sensitive learning
+(Classes: LossSensitivePerceptronCKY)
+
+[Bootstrapping Semantic Parsers from Conversations](http://yoavartzi.com/pub/2011.emnlp.az.pdf)
+Yoav Artzi and Luke Zettlemoyer
+In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2011.
+
+## Unification-based learning
+(Classes: UBLStocGradient, UBLPerceptron)
+
+[Inducing Probabilistic CCG Grammars from Logical Form with Higher-order Unification](http://homes.cs.washington.edu/~lsz/papers/kzgs-emnlp2010.pdf). Tom Kwiatkowski, Luke Zettlemoyer, Sharon Goldwater, and Mark Steedman. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2010.
+
+## Factored lexicons
+(Classes: FactoredLexicon, Lexeme, LexicalTemplate)
+
+[Lexical Generalization in CCG Grammar Induction for Semantic Parsing](http://homes.cs.washington.edu/~lsz/papers/kzgs-emnlp2011.pdf). Tom Kwiatkowski, Luke Zettlemoyer, Sharon Goldwater, and Mark Steedman. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2011.
+
+## Template-driven lexical induction
+(Classes: FactoredGENLEXPerceptron)
+
+[Online Learning of Relaxed CCG Grammars for Parsing to Logical Form](http://homes.cs.washington.edu/~lsz/papers/zc-emnlp07.pdf). Luke S. Zettlemoyer and Michael Collins. In Proceedings of the Joint Conference on Empirical Methods in Natural Language Processing and Computational Natural Language Learning (EMNLP-CoNLL), 2007.
+
+[Learning to Map Sentences to Logical Form: Structured Classification with Probabilistic Categorial Grammars](http://homes.cs.washington.edu/~lsz/papers/zc-uai05.pdf). Luke S. Zettlemoyer and Michael Collins. In Proceedings of the Twenty First Conference on Uncertainty in Artificial Intelligence (UAI), 2005.
+
+# License
+
+UW SPF - The University of Washington Semantic Parsing Framework. Copyright (C) 2013 Yoav Artzi
+
+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 2 of the License, or 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, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+src.tinyutils=tinyutils/src
+src.ccg=ccg/src
+src.data=data/src
+src.data.lexicalgen=data.lexicalgen/src
+src.data.lexicalgen.singlesentence=data.lexicalgen.singlesentence/src
+src.datasinglesentence=data.singlesentence/src
+src.explat=explat/src
+src.learn=learn/src
+src.learn.weakp=learn.weakp/src
+src.learn.ubl=learn.ubl/src
+src.mr.lambda=mr.lambda/src
+src.mr.lambda.ccg=mr.lambda.ccg/src
+src.mr.lambda.exec.naive=mr.lambda.exec.naive/src
+src.mr.lambda.exec.tabular=mr.lambda.exec.tabular/src
+src.parser.ccg=parser.ccg/src
+src.parser.ccg.cky=parser.ccg.cky/src
+src.parser.ccg.factoredlex=parser.ccg.factoredlex/src
+src.parser.ccg.features.basic=parser.ccg.features.basic/src
+src.parser.ccg.features.lambda=parser.ccg.features.lambda/src
+src.parser.ccg.genlex=parser.ccg.genlex/src
+src.parser.ccg.cky.genlex=parser.ccg.cky.genlex/src
+src.parser.ccg.rules=parser.ccg.rules/src
+src.parser.ccg.rules.lambda=parser.ccg.rules.lambda/src
+src.exec=exec/src
+src.test=test/src
+src.test.ccg.lambda=test.ccg.lambda/src
+src.test.exec=test.exec/src
+src.parser.ccg.joint=parser.ccg.joint/src
+src.parser.ccg.joint.genlex=parser.ccg.joint.genlex/src
+src.parser.ccg.joint.cky=parser.ccg.joint.cky/src
+src.parser.ccg.rules.coordination = parser.ccg.rules.coordination/src
+src.parser.ccg.rules.coordination.lambda = parser.ccg.rules.coordination.lambda/src
+src.learn.simple = learn.simple/src
+src.learn.simple.genlex = learn.simple.genlex/src
+mainclass=edu.uw.cs.lil.tiny.geoquery.Geo880Dev
+<project name="spf" default="dist" basedir=".">
+	<description>
+        UW SPF build file
+    </description>
+	<!-- set global properties for this build -->
+	<property file="build.properties" />
+	<property name="version" value="1.0" />
+	<property name="build" location="build" />
+	<property name="build.src" location="build.src" />
+	<property name="dist" location="dist" />
+	<property name="lib" location="lib" />
+
+	<path id="classpath">
+		<fileset dir="${lib}">
+			<include name="**/*.jar" />
+		</fileset>
+	</path>
+
+	<target name="init">
+		<!-- Create the time stamp -->
+		<tstamp />
+		<!-- Create the build directory structure used by compile -->
+		<mkdir dir="${build}" />
+		<mkdir dir="${build.src}" />
+		<copy todir="${build.src}" >
+			<fileset dir="${src.tinyutils}" includes="**/*.java" />
+			<fileset dir="${src.ccg}" includes="**/*.java" />
+			<fileset dir="${src.data}" includes="**/*.java" />
+			<fileset dir="${src.exec}" includes="**/*.java" />
+			<fileset dir="${src.data.lexicalgen}" includes="**/*.java" />
+			<fileset dir="${src.data.lexicalgen.singlesentence}" includes="**/*.java" />
+			<fileset dir="${src.datasinglesentence}" includes="**/*.java" />
+			<fileset dir="${src.explat}" includes="**/*.java" />
+			<fileset dir="${src.learn}" includes="**/*.java" />
+			<fileset dir="${src.learn.weakp}" includes="**/*.java" />
+			<fileset dir="${src.learn.ubl}" includes="**/*.java" />
+			<fileset dir="${src.learn.simple}" includes="**/*.java" />
+			<fileset dir="${src.learn.simple.genlex}" includes="**/*.java" />
+			<fileset dir="${src.mr.lambda}" includes="**/*.java" />
+			<fileset dir="${src.mr.lambda.ccg}" includes="**/*.java" />
+			<fileset dir="${src.mr.lambda.exec.naive}" includes="**/*.java" />
+			<fileset dir="${src.mr.lambda.exec.tabular}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.cky}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.factoredlex}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.features.basic}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.features.lambda}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.genlex}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.cky.genlex}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.rules}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.rules.lambda}" includes="**/*.java" />
+			<fileset dir="${src.test}" includes="**/*.java" />
+			<fileset dir="${src.test.ccg.lambda}" includes="**/*.java" />
+			<fileset dir="${src.test.exec}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.joint}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.joint.genlex}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.joint.cky}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.rules.coordination}" includes="**/*.java" />
+			<fileset dir="${src.parser.ccg.rules.coordination.lambda}" includes="**/*.java" />
+		</copy>
+	</target>
+
+	<target name="compile" depends="init" description="compile the source ">
+		<!-- Compile the java code from ${src} into ${build} -->
+		<javac debug="true" srcdir="${build.src}" destdir="${build}" includeantruntime="false">
+			<classpath refid="classpath" />
+			<compilerarg value="-Xlint"/>
+		</javac>
+	</target>
+
+	<target name="dist" depends="compile" description="generate the distribution">
+		<!-- Create the distribution directory -->
+		<mkdir dir="${dist}" />
+		<delete file="MANIFEST.MF" />
+		<manifest file="MANIFEST.MF">
+			<attribute name="Main-Class" value="${mainclass}" />
+		</manifest>
+
+		<jar jarfile="${dist}/${ant.project.name}-${version}.jar" manifest="MANIFEST.MF">
+			<fileset dir="${build}" />
+			<fileset dir="${build.src}" />
+			<zipgroupfileset dir="${lib}" includes="*.jar" />
+		</jar>
+		
+		<delete file="MANIFEST.MF" />
+	</target>
+
+	<target name="clean" description="clean up">
+		<!-- Delete the ${build} and ${dist} directory trees -->
+		<delete dir="${build}" />
+		<delete dir="${build.src}" />
+		<delete dir="${dist}" />
+	</target>
+</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/tinyutils"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ccg</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

ccg/src/edu/uw/cs/lil/tiny/ccg/categories/AbstractCategoryServices.java

+/*******************************************************************************
+ * UW SPF - The University of Washington Semantic Parsing Framework. Copyright (C) 2013 Yoav Artzi
+ * <p>
+ * 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 2 of the License, or any later version.
+ * <p>
+ * 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.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ ******************************************************************************/
+package edu.uw.cs.lil.tiny.ccg.categories;
+
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.ComplexSyntax;
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.Slash;
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.Syntax;
+
+/**
+ * Abstract generic category services class to supply a base to LF-specific
+ * category services classes.
+ * 
+ * @author Yoav Artzi
+ * @param <Y>
+ */
+public abstract class AbstractCategoryServices<Y> implements
+		ICategoryServices<Y> {
+	
+	// Syntax constants
+	private static final char	CLOSE_PAREN		= ')';
+	private static final String	CLOSE_PAREN_STR	= String.valueOf(CLOSE_PAREN);
+	private static final char	OPEN_PAREN		= '(';
+	private static final String	OPEN_PAREN_STR	= String.valueOf(OPEN_PAREN);
+	
+	@Override
+	public final Category<Y> apply(ComplexCategory<Y> function,
+			Category<Y> argument) {
+		if (argument == null || argument.getSem() == null
+				|| function.getSem() == null) {
+			return null;
+		}
+		if (function.getSlash() == Slash.VERTICAL) {
+			return null;
+		}
+		if (function.getSyntax().getRight().equals(argument.getSyntax())) {
+			final Y newSemantics = doSemanticApplication(function.getSem(),
+					argument.getSem());
+			if (newSemantics != null) {
+				return Category.create(function.getSyntax().getLeft(),
+						newSemantics);
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public final Category<Y> compose(ComplexCategory<Y> fCategory,
+			ComplexCategory<Y> gCategory) {
+		if (gCategory == null) {
+			return null;
+		}
+		
+		if (fCategory.getSlash() == Slash.VERTICAL
+				|| gCategory.getSlash() == Slash.VERTICAL) {
+			return null;
+		}
+		
+		if (gCategory.getSem() == null || fCategory.getSem() == null) {
+			return null;
+		}
+		
+		if (fCategory.getSyntax().getRight()
+				.equals(gCategory.getSyntax().getLeft())) {
+			final Y newSemantics = doSemanticComposition(fCategory.getSem(),
+					gCategory.getSem());
+			if (newSemantics != null) {
+				
+				// Put composition direction on cell to enable Eisner normal
+				// form later on
+				final boolean newCategoryFromRightComp;
+				final boolean newCategoryFromLeftComp;
+				if (fCategory.getSlash() == Slash.FORWARD) {
+					newCategoryFromRightComp = true;
+					newCategoryFromLeftComp = false;
+				} else {
+					newCategoryFromLeftComp = true;
+					newCategoryFromRightComp = false;
+				}
+				
+				final ComplexCategory<Y> newcat = new ComplexCategory<Y>(
+						new ComplexSyntax(fCategory.getSyntax().getLeft(),
+								gCategory.getSyntax().getRight(),
+								fCategory.getSlash()), newSemantics,
+						newCategoryFromLeftComp, newCategoryFromRightComp);
+				return newcat;
+			}
+		}
+		return null;
+	}
+	
+	public ComplexCategory<Y> createComplexCategory(String syntaxString,
+			Y semantics) {
+		// find the outermost slash
+		// assumes that one exists
+		int depth = 0;
+		char c;
+		syntaxString = syntaxString.trim();
+		if (syntaxString.startsWith(OPEN_PAREN_STR)
+				&& syntaxString.endsWith(CLOSE_PAREN_STR)) {
+			// check if we need to strip them
+			boolean trim = true;
+			depth = 0;
+			for (int i = 0; i < syntaxString.length() - 1; i++) {
+				c = syntaxString.charAt(i);
+				if (c == OPEN_PAREN) {
+					depth++;
+				} else if (c == CLOSE_PAREN) {
+					depth--;
+				}
+				if (depth == 0) {
+					trim = false;
+				}
+			}
+			if (trim) {
+				syntaxString = syntaxString.substring(1,
+						syntaxString.length() - 1);
+			}
+			
+		}
+		depth = 0;
+		Slash latestSlash = null;
+		int latestSlashPosition = -1;
+		for (int i = 0; i < syntaxString.length(); i++) {
+			c = syntaxString.charAt(i);
+			if (c == OPEN_PAREN) {
+				depth++;
+			}
+			if (c == CLOSE_PAREN) {
+				depth--;
+			}
+			if (depth == 0 && Slash.getSlash(c) != null) {
+				latestSlashPosition = i;
+				latestSlash = Slash.getSlash(c);
+			}
+		}
+		if (latestSlash == null) {
+			throw new IllegalArgumentException("No outer slash found in "
+					+ syntaxString);
+		}
+		
+		return new ComplexCategory<Y>(new ComplexSyntax(parse(
+				syntaxString.substring(0, latestSlashPosition)).getSyntax(),
+				parse(
+						syntaxString.substring(latestSlashPosition + 1,
+								syntaxString.length())).getSyntax(),
+				latestSlash), semantics, false, false);
+	}
+	
+	@Override
+	public final Category<Y> parse(String string) {
+		String trimmed = string.trim();
+		
+		final int colon = trimmed.indexOf(':');
+		
+		// Everything after the colon is semantics
+		final Y semantics;
+		if (colon != -1) {
+			semantics = parseSemantics(trimmed.substring(colon + 1,
+					trimmed.length()).trim());
+			trimmed = trimmed.substring(0, colon);
+		} else {
+			semantics = null;
+		}
+		
+		// ComplexCategories have slashes, SimpleCategories don't
+		if (trimmed.indexOf('\\') != -1 || trimmed.indexOf('/') != -1
+				|| trimmed.indexOf('|') != -1) {
+			return createComplexCategory(trimmed, semantics);
+		} else {
+			return new SimpleCategory<Y>(Syntax.valueOf(trimmed.trim()),
+					semantics);
+		}
+	}
+	
+	/**
+	 * Parse the semantics from the given string. Checks that new expression is
+	 * well typed after loading.
+	 * 
+	 * @param string
+	 * @return
+	 */
+	@Override
+	public Y parseSemantics(String string) {
+		return parseSemantics(string, true);
+	}
+	
+	/**
+	 * Parse the semantics from the given string.
+	 * 
+	 * @param string
+	 * @return
+	 */
+	public abstract Y parseSemantics(String string, boolean checkType);
+	
+	/**
+	 * Do the application of the semantics.
+	 * 
+	 * @param function
+	 * @param argument
+	 * @return
+	 */
+	protected abstract Y doSemanticApplication(Y function, Y argument);
+	
+	/**
+	 * Do the composition of the semantics.
+	 * 
+	 * @param f
+	 * @param g
+	 * @return
+	 */
+	protected abstract Y doSemanticComposition(Y f, Y g);
+	
+}

ccg/src/edu/uw/cs/lil/tiny/ccg/categories/Category.java

+/*******************************************************************************
+ * UW SPF - The University of Washington Semantic Parsing Framework. Copyright (C) 2013 Yoav Artzi
+ * <p>
+ * 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 2 of the License, or any later version.
+ * <p>
+ * 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.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ ******************************************************************************/
+package edu.uw.cs.lil.tiny.ccg.categories;
+
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.ComplexSyntax;
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.Syntax;
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.Syntax.SimpleSyntax;
+
+/**
+ * A CCG Category has both a syntactic and semantic component. Each instance of
+ * this class stores both.
+ * 
+ * @author Yoav Artzi
+ */
+public abstract class Category<Y> {
+	
+	/**
+	 * Mutable cache for the hashing code. This field is for internal use only!
+	 * It mustn't be used when copying/comparing/storing/etc. the object.
+	 */
+	private int		hashCodeCache;
+	
+	/**
+	 * Mutable flag to indicate if the hash code cache is populated. This field
+	 * is for internal use only! It mustn't be used when
+	 * copying/comparing/storing/etc. the object.
+	 */
+	private boolean	hashCodeCalculated	= false;
+	
+	/**
+	 * Category semantics
+	 */
+	private final Y	semantics;
+	
+	public Category(Y semantics) {
+		this.semantics = semantics;
+	}
+	
+	public static <Y> Category<Y> create(Syntax syntax) {
+		return create(syntax, null);
+	}
+	
+	public static <Y> Category<Y> create(Syntax syntax, Y semantics) {
+		if (syntax instanceof SimpleSyntax) {
+			return new SimpleCategory<Y>((SimpleSyntax) syntax, semantics);
+		} else if (syntax instanceof ComplexSyntax) {
+			return new ComplexCategory<Y>((ComplexSyntax) syntax, semantics);
+		} else {
+			throw new IllegalStateException("unsupported syntax type");
+		}
+	}
+	
+	/**
+	 * Clones the category, but replaces the semantics of current with the given
+	 * one.
+	 * 
+	 * @param newSemantics
+	 * @return
+	 */
+	abstract public Category<Y> cloneWithNewSemantics(Y newSemantics);
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (obj == null) {
+			return false;
+		}
+		if (getClass() != obj.getClass()) {
+			return false;
+		}
+		@SuppressWarnings("rawtypes")
+		final Category other = (Category) obj;
+		if (semantics == null) {
+			if (other.semantics != null) {
+				return false;
+			}
+		} else if (!semantics.equals(other.semantics)) {
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * tests for equality of syntax without checking if the lambda expressions
+	 * are equals used primarily during parsing
+	 */
+	abstract public boolean equalsNoSem(Object o);
+	
+	public Y getSem() {
+		return semantics;
+	}
+	
+	abstract public Syntax getSyntax();
+	
+	@Override
+	final public int hashCode() {
+		if (!hashCodeCalculated) {
+			hashCodeCache = calcHashCode();
+			hashCodeCalculated = true;
+		}
+		return hashCodeCache;
+	}
+	
+	// does the full thing match?
+	abstract public boolean matches(Category<Y> c);
+	
+	// does just the syntactic component match?
+	abstract public boolean matchesNoSem(Category<Y> c);
+	
+	abstract public int numSlashes();
+	
+	private int calcHashCode() {
+		if (semantics == null) {
+			return 0;
+		}
+		return syntaxHash() + semantics.hashCode();
+	}
+	
+	abstract protected int syntaxHash();
+}

ccg/src/edu/uw/cs/lil/tiny/ccg/categories/ComplexCategory.java

+/*******************************************************************************
+ * UW SPF - The University of Washington Semantic Parsing Framework. Copyright (C) 2013 Yoav Artzi
+ * <p>
+ * 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 2 of the License, or any later version.
+ * <p>
+ * 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.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ ******************************************************************************/
+package edu.uw.cs.lil.tiny.ccg.categories;
+
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.ComplexSyntax;
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.Slash;
+
+/**
+ * Complex syntactic category.
+ */
+public class ComplexCategory<Y> extends Category<Y> {
+	private final boolean		fromLeftComp;
+	private final boolean		fromRightComp;
+	
+	private final ComplexSyntax	syntax;
+	
+	public ComplexCategory(ComplexSyntax syntax, Y semantics) {
+		this(syntax, semantics, false, false);
+	}
+	
+	public ComplexCategory(ComplexSyntax syntax, Y semantics,
+			boolean fromLeftComp, boolean fromRightComp) {
+		super(semantics);
+		this.syntax = syntax;
+		this.fromLeftComp = fromLeftComp;
+		this.fromRightComp = fromRightComp;
+	}
+	
+	@Override
+	public Category<Y> cloneWithNewSemantics(Y newSemantics) {
+		return new ComplexCategory<Y>(syntax, newSemantics);
+	}
+	
+	@Override
+	public boolean equals(Object other) {
+		if (!(other instanceof ComplexCategory)) {
+			return false;
+		}
+		@SuppressWarnings("rawtypes")
+		final ComplexCategory cc = (ComplexCategory) other;
+		if (!equalsNoSem(other)) {
+			return false;
+		}
+		if (getSem() != null && cc.getSem() != null
+				&& !getSem().equals(cc.getSem())) {
+			return false;
+		}
+		return true;
+	}
+	
+	@Override
+	public boolean equalsNoSem(Object other) {
+		if (!(other instanceof ComplexCategory)) {
+			return false;
+		}
+		@SuppressWarnings("rawtypes")
+		final ComplexCategory cc = (ComplexCategory) other;
+		if (!syntax.equals(cc.syntax)) {
+			return false;
+		}
+		
+		return true;
+	}
+	
+	public Slash getSlash() {
+		return syntax.getSlash();
+	}
+	
+	@Override
+	public ComplexSyntax getSyntax() {
+		return syntax;
+	}
+	
+	/**
+	 * 'true' iff the slash is semantically equal to the given one.
+	 */
+	public boolean hasSlash(Slash s) {
+		return syntax.getSlash() == Slash.VERTICAL || s == syntax.getSlash()
+				|| s == Slash.VERTICAL;
+	}
+	
+	public boolean isFromLeftComp() {
+		return fromLeftComp;
+	}
+	
+	public boolean isFromRightComp() {
+		return fromRightComp;
+	}
+	
+	@Override
+	public boolean matches(Category<Y> other) {
+		if (!(other instanceof ComplexCategory)) {
+			return false;
+		}
+		final ComplexCategory<Y> cc = (ComplexCategory<Y>) other;
+		if (cc.syntax.getSlash() != syntax.getSlash()
+				&& syntax.getSlash() != Slash.VERTICAL
+				&& cc.syntax.getSlash() != Slash.VERTICAL) {
+			return false;
+		}
+		if (!matchesNoSem(other)) {
+			return false;
+		}
+		if (getSem() != null && other.getSem() != null
+				&& !getSem().equals(other.getSem())) {
+			return false;
+		}
+		return true;
+	}
+	
+	@Override
+	public boolean matchesNoSem(Category<Y> other) {
+		if (!(other instanceof ComplexCategory)) {
+			return false;
+		}
+		return syntax.equals(other.getSyntax());
+	}
+	
+	@Override
+	public int numSlashes() {
+		return syntax.numSlashes();
+	}
+	
+	@Override
+	public String toString() {
+		final StringBuilder result = new StringBuilder(syntax.toString());
+		if (getSem() != null) {
+			result.append(" : ").append(getSem().toString());
+		}
+		return result.toString();
+	}
+	
+	@Override
+	protected int syntaxHash() {
+		return syntax.hashCode();
+	}
+}

ccg/src/edu/uw/cs/lil/tiny/ccg/categories/ICategoryFixedTemplateGenerator.java

+/*******************************************************************************
+ * UW SPF - The University of Washington Semantic Parsing Framework. Copyright (C) 2013 Yoav Artzi
+ * <p>
+ * 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 2 of the License, or any later version.
+ * <p>
+ * 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.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ ******************************************************************************/
+package edu.uw.cs.lil.tiny.ccg.categories;
+
+import java.util.Set;
+
+/**
+ * Template to generate categories without input.
+ * 
+ * @author Yoav Artzi
+ * @param <Y>
+ *            Type of semantics
+ */
+public interface ICategoryFixedTemplateGenerator<Y> {
+	Set<Category<Y>> generateCategories();
+}

ccg/src/edu/uw/cs/lil/tiny/ccg/categories/ICategoryPredicateTemplateGenerator.java

+/*******************************************************************************
+ * UW SPF - The University of Washington Semantic Parsing Framework. Copyright (C) 2013 Yoav Artzi
+ * <p>
+ * 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 2 of the License, or any later version.
+ * <p>
+ * 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.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ ******************************************************************************/
+package edu.uw.cs.lil.tiny.ccg.categories;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Template to generate categories based on seeds.
+ * 
+ * @author Yoav Artzi
+ * @param <Y>
+ *            Type of semantics
+ * @param <S>
+ *            The type of the element used to instantiate the template.
+ */
+public interface ICategoryPredicateTemplateGenerator<Y, S> {
+	List<Set<Category<Y>>> generateCategories(Set<S> seeds);
+}

ccg/src/edu/uw/cs/lil/tiny/ccg/categories/ICategoryServices.java

+/*******************************************************************************
+ * UW SPF - The University of Washington Semantic Parsing Framework. Copyright (C) 2013 Yoav Artzi
+ * <p>
+ * 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 2 of the License, or any later version.
+ * <p>
+ * 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.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ ******************************************************************************/
+package edu.uw.cs.lil.tiny.ccg.categories;
+
+/**
+ * Category services, such as composition and application.
+ * 
+ * @author Yoav Artzi
+ * @param <Y>
+ */
+public interface ICategoryServices<Y> {
+	
+	/**
+	 * Apply the function category to the argument category.
+	 * 
+	 * @param function
+	 * @param argument
+	 * @return null if the application fails.
+	 */
+	Category<Y> apply(ComplexCategory<Y> function, Category<Y> argument);
+	
+	/**
+	 * Compose the given categories, so the logical forms will compose to f(g).
+	 * 
+	 * @param fCategory
+	 * @param gCategory
+	 * @return null if the composition fails.
+	 */
+	Category<Y> compose(ComplexCategory<Y> fCategory,
+			ComplexCategory<Y> gCategory);
+	
+	@Override
+	boolean equals(Object obj);
+	
+	/**
+	 * Returns an empty category.
+	 */
+	Category<Y> getEmptyCategory();
+	
+	/**
+	 * Returns a NP category with no semantics.
+	 */
+	Category<Y> getNounPhraseCategory();
+	
+	/**
+	 * Returns a S category with no semantics.
+	 */
+	Category<Y> getSentenceCategory();
+	
+	@Override
+	int hashCode();
+	
+	/**
+	 * Given a string representation (single line) parse it into a category.
+	 * 
+	 * @param string
+	 * @return
+	 */
+	Category<Y> parse(String string);
+	
+	/**
+	 * Parse the semantics from the given string.
+	 * 
+	 * @param string
+	 * @return
+	 */
+	Y parseSemantics(String string);
+}

ccg/src/edu/uw/cs/lil/tiny/ccg/categories/SimpleCategory.java

+/*******************************************************************************
+ * UW SPF - The University of Washington Semantic Parsing Framework. Copyright (C) 2013 Yoav Artzi
+ * <p>
+ * 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 2 of the License, or any later version.
+ * <p>
+ * 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.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ ******************************************************************************/
+package edu.uw.cs.lil.tiny.ccg.categories;
+
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.Syntax;
+import edu.uw.cs.lil.tiny.ccg.categories.syntax.Syntax.SimpleSyntax;
+import edu.uw.cs.utils.assertion.Assert;
+
+public class SimpleCategory<Y> extends Category<Y> {
+	
+	/** The name of this atomic category */
+	private final SimpleSyntax	syntax;
+	
+	public SimpleCategory(SimpleSyntax syntax, Y semantics) {
+		super(semantics);
+		Assert.ifNull(syntax);
+		this.syntax = syntax;
+	}
+	
+	@Override
+	public Category<Y> cloneWithNewSemantics(Y newSemantics) {
+		return new SimpleCategory<Y>(syntax, newSemantics);
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (!super.equals(obj)) {
+			return false;
+		}