2024-03-05  Steven Eker  <eker@pup>

	* CUI_Term.cc (CUI_Term::arguments): made const

	* CUI_Term.hh (class CUI_Term): made arguments() const

===================================Maude158===========================================

2024-01-16  Steven Eker  <eker@pup>

	* CUI_Symbol.cc (CUI_Symbol::stackArguments): handle
	respectUnstackable argument

	* CUI_Symbol.hh (class CUI_Symbol): updated decl for stackArguments()

===================================Maude156===========================================

2023-07-24  Steven Eker  <eker@pup>

	* CUI_Symbol.cc (CUI_Symbol::determineGround): added

	* CUI_Symbol.hh (class CUI_Symbol): added decl for determineGround()

===================================Maude151===========================================

2020-12-11  Steven Eker  <eker2@eker10>

	* CUI_DagNode.cc (CUI_DagNode::instantiate2): take and pass
	maintainInvariants flag; only normalize and compute sort for
	ground dag if maintainInvariants == true
	(CUI_DagNode::instantiateWithReplacement): pass maintainInvariants
	= false to instantiate()
	(CUI_DagNode::instantiateWithCopies2): pass maintainInvariants =
	false to instantiate()

	* CUI_DagNode.hh (class CUI_DagNode): updated decl for
	instantiate2()

===================================Maude132===========================================

2020-09-28  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem.cc
	(CUI_UnificationSubproblem::markReachableNodes): use range-based
	for loop

	* CUI_UnificationSubproblem2.cc
	(CUI_UnificationSubproblem2::markReachableNodes): use range-based
	for loop

2020-09-25  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem2.cc
	(CUI_UnificationSubproblem2::addUnification): optimize f(...) =?
	f(...) case where there are equal arguments

	* CUI_UnificationSubproblem2.hh (class
	CUI_UnificationSubproblem2): added decl for equivalent()

	* CUI_UnificationSubproblem2.cc
	(CUI_UnificationSubproblem2::addUnification): use
	equivalentToGroundDag(), leftCollapse(), rightCollapse() to
	optimize degenerate cases
	(CUI_UnificationSubproblem2::equivalent): added

	* CUI_UnificationSubproblem2.hh
	(CUI_UnificationSubproblem2::equivalentToGroundDag): added

	* CUI_UnificationSubproblem2.cc (CUI_UnificationSubproblem2::leftCollapse)
	(CUI_UnificationSubproblem2::rightCollapse): added Asserts() that
	we don't see an identity as a argument

2020-09-24  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem2.hh (class
	CUI_UnificationSubproblem2): added decls for leftCollapse(),
	rightCollapse()

	* CUI_UnificationSubproblem2.cc (CUI_UnificationSubproblem2::leftCollapse)
	(CUI_UnificationSubproblem2::rightCollapse): added

2020-09-23  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem2.cc
	(CUI_UnificationSubproblem2::Problem::tryAlternative): use
	indirectOccursCheck() in RHS_VARIABLE_TAKES_ALL case - this fixes
	some nontermination bugs
	(CUI_UnificationSubproblem2::Problem::tryAlternative): added
	explanation for why we need indirectOccursCheck() here

	* CUI_DagNode.hh (class CUI_DagNode): added decl for
	indirectOccursCheck()

	* CUI_DagNode.cc (CUI_DagNode::indirectOccursCheck): added

===================================Maude131===========================================

2020-09-22  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem2.cc
	(CUI_UnificationSubproblem2::addUnification)
	(CUI_UnificationSubproblem2::Problem::tryAlternative): #ifdef out
	debugging code

2020-09-21  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem2.cc
	(CUI_UnificationSubproblem2::addUnification): rearrange if
	statement for better efficiency and to make the intent clear

	* CUI_DagNode.cc (CUI_DagNode::makePurifiedVersion): fixed bug:
	only compare arguments and switch them if symbol is actually
	commutative

===================================Maude130===========================================

2020-05-20  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem.hh: symmetric changes

	* CUI_UnificationSubproblem2.hh: deleted default ctor now
	that we have a default ctor for Vector<> that doesn't require
	a default ctor for the element type; add comment to copy ctor
	to explain why it does what it does

2020-05-19  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem2.cc
	(CUI_UnificationSubproblem2::Problem::tryAlternative): fix bug
	where we were using r (the original variable) rather than r2 (the
	representative variable) in 3 places; fix comment: occur checks
	aren't strictly necessary here

2020-05-18  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem2.cc
	(CUI_UnificationSubproblem2::Problem::tryAlternative): don't do
	sort computation for identity element here
	(CUI_UnificationSubproblem2::Problem::tryAlternative): deleted
	commented out return false
	(CUI_UnificationSubproblem2::Problem::tryAlternative): replace
	can't happen comment with CantHappen()
	(CUI_UnificationSubproblem2::solve): replaced commented out cout
	with DebugInfo()

	* CUI_Symbol.cc (CUI_Symbol::makeUnificationSubproblem): do sort
	computation for identity element here

	* CUI_UnificationSubproblem2.cc
	(CUI_UnificationSubproblem2::addUnification): replace commented
	out cout with DebugEnter()

2020-05-14  Steven Eker  <eker2@eker10>

	* CUI_UnificationSubproblem.cc
	(CUI_UnificationSubproblem::addUnification): updated Assert();
	turned commented out cerr into DebugEnter()
	(CUI_UnificationSubproblem::solve): turned commented out couts
	into DebugInfo()s

	* CUI_DagNode.cc (CUI_DagNode::computeSolvedFormCommutativeCase):
	code cleaning and fix out-of-date comments

2020-05-13  Steven Eker  <eker2@eker10>

	* CUI_DagNode.cc (CUI_DagNode::computeSolvedForm2): use
	DebugEnter()
	(CUI_DagNode::computeSolvedForm2): updated comments
	(CUI_DagNode::computeSolvedForm2): rearranged inner if statement
	(CUI_DagNode::computeSolvedForm2): deleted large amount of
	commented out code
	(CUI_DagNode::makePurifiedVersion): cleaned up and expanded
	comments

===================================Maude128a===========================================

2019-11-11  Steven Eker  <eker@mu>

	* CUI_DagNode.cc (computeBaseSortForGroundSubterms): no early termination
	in UNIMPLEMENTED case

	* CUI_UnificationSubproblem2.cc (tryAlternative): pass false to
	warnAboutUnimplemented arg (4 places)

	* CUI_DagNode.cc (computeBaseSortForGroundSubterms): take and pass
	warnAboutUnimplemented

	* CUI_DagNode.hh (DagNode): updated decl for
	computeBaseSortForGroundSubterms()

===================================Maude125===========================================

2017-02-23  Steven Eker  <eker@install.csl.sri.com>

	* CUI_DagNode.cc (instantiateWithCopies2): ifdef'd out ground flag and
	sort computation code

2017-02-21  Steven Eker  <eker@install.csl.sri.com>

	* CUI_DagNode.hh (DagNode): updated decl for instantiateWithReplacement()

	* CUI_DagNode.cc (instantiateWithReplacement): support lazy contexts

2017-02-17  Steven Eker  <eker@install.csl.sri.com>

	* CUI_DagNode.hh (DagNode): deleted decl for stackArguments()

	* CUI_DagNode.cc (stackArguments): deleted

	* CUI_Symbol.hh (BinarySymbol): updated decl for stackArguments()

	* CUI_Symbol.cc (stackArguments): support respectFrozen and eagerContext
	arguments

===================================Maude111b===========================================

2016-11-10  Steven Eker  <eker@install.csl.sri.com>

	* CUI_DagNode.hh (DagNode): added decl for copyAll2()

	* CUI_DagNode.cc (copyAll2): added

===================================Maude111===========================================

2016-03-24  Steven Eker  <eker@install.csl.sri.com>

	* CUI_Symbol.hh (BinarySymbol): added decl for computeGeneralizedSort2()

	* CUI_Symbol.cc (computeGeneralizedSort2): added

===================================Maude110===========================================

2015-08-05  Steven Eker  <eker@ape.csl.sri.com>

	* CUI_Symbol.hh (BinarySymbol): added declaration for
	unificationPriority()

	* CUI_Symbol.cc (unificationPriority): added

2015-07-30  Steven Eker  <eker@ape.csl.sri.com>

	* CUI_DagNode.cc (computeBaseSortForGroundSubterms): call
	setGround() in ground case

===================================Maude108===========================================

2013-03-01  Steven Eker  <eker@ape.csl.sri.com>

	* CUI_DagNode.cc (makePurifiedVersion): code cleaning
	(computeSolvedForm2): use makePurifiedVersion() rather that using
	in line code

2012-12-21  Steven Eker  <eker@ape.csl.sri.com>

	* CUI_UnificationSubproblem2.cc (tryAlternative): added occur checks

	* CUI_DagNode.cc (computeBaseSortForGroundSubterms): handle left
	and right identities
	(computeSolvedFormCommutativeCase): don't try to deal with the
	identity case because there is the possibility that a collapse to
	a lower sort will require non-minimal unsorted unifiers
	(computeSolvedForm2): handle identity case

	* CUI_Symbol.cc (canResolveTheoryClash): added

	* CUI_Symbol.hh (BinarySymbol): added decl for
	canResolveTheoryClash()

	* CUI_Symbol.cc (makeUnificationSubproblem): make
	CUI_UnificationSubproblem2() in identity case

	* CUI_UnificationSubproblem2.hh: created

	* CUI_UnificationSubproblem2.cc: created

	* CUI_DagNode.hh (DagNode): added decl for makePurifiedVersion()

	* CUI_DagNode.cc (makePurifiedVersion): added

2012-12-19  Steven Eker  <eker@ape.csl.sri.com>

	* CUI_DagNode.cc (computeSolvedFormCommutativeCase): added
	(computeSolvedForm2): use computeSolvedFormCommutativeCase()

	* CUI_DagNode.hh (DagNode): added decl for
	computeSolvedFormCommutativeCase()

===================================Maude96c===========================================

2012-04-13  Steven Eker  <eker@ape.csl.sri.com>

	* CUI_DagNode.hh (DagNode): updated decl for
	instantiateWithReplacement(); added decl for instantiateWithCopies2()

	* CUI_DagNode.cc (instantiateWithReplacement): rewritten to use
	instantiateWithCopies() on eager positions
	(instantiateWithCopies2): added

2012-03-29  Steven Eker  <eker@ape.csl.sri.com>

	* CUI_Symbol.hh (BinarySymbol): added declaration for termify

	* CUI_Symbol.cc (termify): added

===================================Maude96===========================================

2011-11-22  Steven Eker  <eker@rho>

	* CUI_UnificationSubproblem.cc (CUI_UnificationSubproblem::solve): use restoreFromClone()
	to make sure sort and dagnode information for fresh variables created on the path we
	just backtrack from are properly cleared from our UnificationContext (2 places)

2010-12-09  Steven Eker  <eker@rho>

	* CUI_Symbol.cc (CUI_Symbol::postOpDeclarationPass): don't call
	rightIdentitySortCheck() if we are commutative

===================================Maude95b===========================================

2010-10-19  Steven Eker  <eker@rho>

	* CUI_Symbol.cc (CUI_Symbol::makeCanonicalCopyEagerUptoReduced):
	becomes makeCanonicalCopy() with a change of semantics

	* CUI_Symbol.hh (class CUI_Symbol):
	makeCanonicalCopyEagerUptoReduced() -> makeCanonicalCopy()

===================================Maude95a===========================================

2010-09-29  Steven Eker  <eker@rho>

	* CUI_Symbol.cc (CUI_Symbol::makeCanonicalCopyEagerUptoReduced):
	simplify now that we are only passed unreduced nodes; use
	getCanonicalCopyEagerUptoReduced()

	* CUI_Symbol.hh (class CUI_Symbol): added decl for
	makeCanonicalCopyEagerUptoReduced()

	* CUI_Symbol.cc: added

2010-08-18  Steven Eker  <eker@rho>

	* CUI_DagNode.cc (CUI_DagNode::nonVariableSize): deleted

	* CUI_DagNode.hh (class CUI_DagNode): deleted decl for
	nonVariableSize()

===================================Maude95===========================================

2010-08-12  Steven Eker  <eker@rho>

	* CUI_DagNode.cc (CUI_DagNode::computeSolvedForm2): use
	computeSolvedForm() rather than unificationBind() to ensure we
	don't bind the abstraction variable to an impure term
	(CUI_DagNode::computeSolvedForm2): use equalt() rather than == for
	comparing arguments during purification

2010-08-10  Steven Eker  <eker@rho>

	* CUI_DagNode.cc (CUI_DagNode::computeSolvedForm2): handle binding
	of variables, purification and local occurs check

2010-08-03  Steven Eker  <eker@rho>

	* CUI_UnificationSubproblem.hh (class CUI_UnificationSubproblem):
	updated decl for addUnification()

	* CUI_UnificationSubproblem.cc
	(CUI_UnificationSubproblem::addUnification): take marked arg

2010-07-29  Steven Eker  <eker@rho>

	* CUI_UnificationSubproblem.cc
	(CUI_UnificationSubproblem::addUnification): take solution argument

	* CUI_UnificationSubproblem.hh (class CUI_UnificationSubproblem):
	updated decl for addUnification()

===================================Maude94a===========================================

2010-06-30  Steven Eker  <eker@rho>

	* CUI_DagNode.cc (CUI_DagNode::computeSolvedForm2): use
	resolveTheoryClash()

2009-12-22  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (stackArguments): fixed nasty bug where we were
	checking the first argument unstackable flag when deciding whether
	we should stack the second argument

2009-12-02  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.hh (class CUI_Symbol): added decl for makeCanonical()

	* CUI_Symbol.cc (makeCanonical): added

===================================Maude92b===========================================

2009-07-30  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Matcher.cc (freeMatch): fix critical bug where pointer to
	subproblem returned via sp0 was being lost without the subproblem
	being deleted if the second Subpattern::match() called failed
	(id0CollapseMatch, id1CollapseMatch, idemCollapseMatch): fix
	symmetric bugs

2008-12-22  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.cc (computeGeneralizedSort): new getSortFunction()
	convention

===================================Maude92===========================================

2008-03-23  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (computeSolvedForm2): deleted commented out old
	version

	* CUI_DagNode.hh (class CUI_DagNode): deleted commented out old
	decl for computeSolvedForm2()

===================================Maude90a===========================================

2008-02-12  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_UnificationSubproblem.cc (solve): implemented

	* CUI_UnificationSubproblem.hh (class CUI_UnificationSubproblem):
	problems becomes a Vector<Problem>; delete ProblemList
	(class CUI_UnificationSubproblem): lhs, rhs of Problem become
	CUI_DagNode*

2008-02-11  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_UnificationSubproblem.cc: created

	* CUI_UnificationSubproblem.hh: created

	* CUI_Symbol.cc (makeUnificationSubproblem): added

	* CUI_Symbol.hh (class CUI_Symbol): added decl for
	makeUnificationSubproblem()

	* CUI_DagNode.cc (computeSolvedForm2): implemented stub

2008-02-08  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (computeSolvedForm2): Substitution ->
	UnificationContext

	* CUI_DagNode.hh (class CUI_DagNode): updated decl for
	computeSolvedForm2()

2008-02-05  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (computeSolvedForm2): converted to stub

	* CUI_DagNode.hh (class CUI_DagNode): updated decl for
	computeSolvedForm2()

2008-01-17  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (computeSolvedForm2): don't pass nrBindings to
	SolvedFormSubproblemDisjunction

===================================Maude90===========================================

2008-01-11  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (computeSolvedForm2): add missing
	subproblems.add() in reverse order only case

===================================Maude89j===========================================

2007-11-12  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (instantiate2): check ground flags of arguments;
	set ground flag in new node if necessary
	(instantiate2): call normalizeAtTop() rather than just assuming we
	have a C symbol

2007-11-05  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (stackArguments): optimize by not stacking equal
	arguments in the comm case

2007-11-01  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (indexVariables2): added
	(instantiateWithReplacement): added

	* CUI_DagNode.hh (class CUI_DagNode): added decls for
	indexVariables2() and instantiateWithReplacement()

	* CUI_DagNode.cc (instantiate2): updated

	* CUI_DagNode.hh (class CUI_DagNode): updated decl for instantiate2()

===================================Maude89h===========================================

2007-08-24  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (computeBaseSortForGroundSubterms): reimplemented

	* CUI_DagNode.hh (class CUI_DagNode): updated decl for
	computeBaseSortForGroundSubterms()

2007-08-23  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (computeSolvedForm): becomes computeSolvedForm2()

	* CUI_DagNode.hh (class CUI_DagNode): computeSolvedForm() ->
	computeSolvedForm2()

===================================Maude89g===========================================

2007-08-07  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.hh (class CUI_DagNode): updated decl for
	computeSolvedForm()

	* CUI_DagNode.cc (computeSolvedForm): added extensionInfo argument

===================================Maude89f===========================================

2007-03-16  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (unify, occurs2): deleted

	* CUI_DagNode.hh (class CUI_DagNode): deleted decls for unify()
	and occurs2()

2007-03-15  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (computeSolvedForm): clear local substitutions

	* CUI_Symbol.cc (computeGeneralizedSort): pass realToBdd by ref

	* CUI_Symbol.hh (class CUI_Symbol): fix computeGeneralizedSort()
	decl

===================================Maude89a===========================================

2007-03-05  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (nonVariableSize): return mpz_class

	* CUI_DagNode.hh (class CUI_DagNode): nonVariableSize() now
	returns mpz_class

2007-03-02  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (computeSolvedForm): use merge(); don't copy
	parent substitution
	(computeSolvedForm): use class SolvedFormSubproblemDisjunction

2007-03-01  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (nonVariableSize, insertVariables2): added
	(computeSolvedForm): added

	* CUI_DagNode.hh (class CUI_DagNode): added decls for
	computeSolvedForm(), nonVariableSize() and insertVariables2()

===================================Maude89===========================================

2007-02-09  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (instantiate2): normalize wrt to comm
	(instantiate2): simplify

2007-02-07  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (unify): rewritten using
	UnificationSubproblemDisjunction and unificationDifference()
	(unify): check for symmetry; get unifications in the reverse
	order correct

2007-02-06  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (occurs2): added
	(instantiate2): added
	(computeBaseSortForGroundSubterms): added
	(unify): added

	* CUI_DagNode.hh (class CUI_DagNode): added decls for unify(),
	computeBaseSortForGroundSubterms(), instantiate2(), occurs2()

2007-02-05  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.cc (computeGeneralizedSort): added

	* CUI_Symbol.hh (class CUI_Symbol): added decl for
	computeGeneralizedSort()

===================================Maude88f===========================================

2005-07-28  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Term.cc (CUI_Term): force symbol arg to be a CUI_Symbol
	(deepCopy2): handle translation to non-CUI_Symbol

	* CUI_Term.hh (class CUI_Term): updated decl for SymbolMap* ctor

2005-06-24  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Term.hh (class CUI_Term): updated decls for SymbolMap* ctor
	and deepCopy2()

	* CUI_Term.cc (deepCopy2): rewritten
	(CUI_Term): SymbolMap* rewritten

===================================Maude86b===========================================

2003-08-29  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.cc (eqRewrite): use applyReplaceNoOwise()
	(memoStrategy): use applyReplaceNoOwise()

===================================Maude82===========================================

2003-05-01  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (overwriteWithClone): use copySetRewritingFlags()
	(makeClone): copySetRewritingFlags()

===================================Maude80===========================================

2003-02-25  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Term.cc: removed #pragma
	(CUI_Term): updated Assert()

	* CUI_Term.hh: removed #pragma

	* CUI_Symbol.cc: removed #pragma
	(eqRewrite): updated Assert()
	(computeBaseSort): updated Assert()s
	(normalizeAndComputeTrueSort): updated Assert()

	* CUI_Symbol.hh: removed #pragma

	* CUI_RhsAutomaton.cc: removed #pragma

	* CUI_RhsAutomaton.hh: removed #pragma

	* CUI_Matcher.cc (match): updated Assert()

	* CUI_LhsCompiler.cc (compileLhs2): updated Assert()

	* CUI_LhsAutomaton.cc: removed #pragma

	* CUI_LhsAutomaton.hh: removed #pragma

	* CUI_DagNode.cc: removed #pragma
	(copyWithReplacement): updated Assert() (both versions)

	* CUI_DagNode.hh: removed #pragma
	(getArgument): updated Assert()

	* CUI_DagArgumentIterator.cc: removed #pragma
	(argument): updated Assert()
	(next): updated Assert()

	* CUI_DagArgumentIterator.hh: removed #pragma

	* CUI_ArgumentIterator.cc: removed #pragma
	(argument): updated Assert()
	(next): updated Assert()

	* CUI_ArgumentIterator.hh: removed #pragma

===================================Maude79===========================================

2003-01-31  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Term.cc (analyseCollapses): becomes analyseCollapses2()

	* CUI_Term.hh (class CUI_Term): analyseCollapses() ->
	analyseCollapses2()

===================================Maude78===========================================

2002-10-16  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.cc (postOpDeclarationPass): becomes
	postOpDeclarationPass() since sort tables arem't computed at
	postInterSymbolPass time

	* CUI_Symbol.hh (class CUI_Symbol): postInterSymbolPass() ->
	postOpDeclarationPass()

2002-10-08  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.hh (class CUI_Symbol): added decl for setFrozen()

	* CUI_Symbol.cc (setFrozen): added

2002-10-04  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.hh (class CUI_DagNode): updated decl for complex
	version of copyWithReplacement()

	* CUI_DagNode.cc (copyWithReplacement): complex version: handle
	the case where we only want to replace one arg

	* CUI_Symbol.cc (stackArguments): only stack args that aren't
	frozen or unstackable

2002-10-03  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.hh (class CUI_DagNode): updated decl for stackArguments()

	* CUI_DagNode.cc (stackArguments): handle respectFrozen argument

===================================Maude76==================================================

2002-08-02  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Term.cc (compileRhs2): added code to flag the last use of
	each source

===================================Maude74==================================================

2002-04-24  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_RhsAutomaton.cc (dump): don't bother incrementing
	indentLevel (since we don't have subautomata to output)

===================================Maude72==================================================

2002-01-29  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): added friend decl
	for PatternType << function

===================================Maude70==================================================

2001-04-03  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.hh (class CUI_DagNode): added decl for
	Vector<RedexPosition> version of copyWithReplacement()

	* CUI_DagNode.cc (copyWithReplacement): added
	(Vector<RedexPosition> version)

===================================Engine66==================================================

2001-03-08  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.hh (class CUI_Symbol): added decl for stackArguments()

	* CUI_Symbol.cc (stackArguments): added

===================================Engine65==================================================

2001-01-26  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.hh (class CUI_DagNode): updated markArguments() decl
	and make it private

	* CUI_DagNode.cc (markArguments): rewritten with new semantics

===================================Engine64==================================================

2000-08-04  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.cc (eqRewrite): greatly simplified now that we
	no longer treat last strategy zero specially when term is in the
	error sort
	(memoStrategy): ditto

2000-07-31  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.cc (computeBaseSort): don't handle union sorts

===================================Engine60==================================================

2000-07-28  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_RhsAutomaton.hh (class CUI_RhsAutomaton): added decl for
	remapIndices()

	* CUI_RhsAutomaton.cc (remapIndices): added

2000-07-26  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_LhsCompiler.cc (compileLhs2): use getNrProtectedVariables()
	instead of nrVariables()

	* CUI_Term.cc (compileRhs2): use makeConstructionIndex() instead of
	allocateIndex()

2000-07-25  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Term.cc (findAvailableTerms): don't insert ground terms into
	availableTerms since we can't do left->right sharing on them

	* CUI_RhsAutomaton.cc (construct): don't call buildAliens()
	(replace): don't call buildAliens()
	(dump): don't call buildAliens()

	* CUI_Term.hh (class CUI_Term): deleted decls for compileRhs() and
	findIndex()

	* CUI_Term.cc (compileRhs): deleted
	(findIndex): deleted

===================================Engine60==================================================

2000-07-12  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Term.cc (findAvailableTerms): added
	(compileRhs2): added

	* CUI_Term.hh (class CUI_Term): added decls for
	findAvailableTerms() and compileRhs2()

===================================Engine59==================================================

2000-07-05  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_LhsCompiler.cc (compileLhs): becomes compileLhs2()

	* CUI_Term.hh: compileLhs() -> compileLhs2()

2000-06-26  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Term.cc (findIndex): modifiedIndex() -> getModifiedIndex()

	* CUI_LhsAutomaton.cc (addSubpattern): index() -> getIndex()
	(addSubpattern): lookupSort() -> getSort()

===================================Engine58==================================================

2000-03-30  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_LhsAutomaton.cc (addSubpattern): need to make topAutomaton
	for subpattern1 if matchAtTop and IDEM_COLLAPSE; previously we
	only did this for subpattern0 in the IDEM_COLLAPSE case unless
	ther was a ID0_COLLAPSE; non-existant topAutomaton cause seg fault

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): added added
	comments to clarify enum Flags

	* CUI_Term.hh (class CUI_Term): added comments to clarify flags

	* CUI_LhsAutomaton.hh (match): moved comment inside of "if (matchAtTop)"

2000-03-17  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Term.cc (dump): ifdef'd

	* CUI_Term.hh (class CUI_Term): use NO_COPYING() macro; ifdef'd
	dump() decls

	* CUI_RhsAutomaton.cc (dump): ifdef'd

	* CUI_RhsAutomaton.hh (class CUI_RhsAutomaton): use NO_COPYING()
	macro; ifdef'd dump() decls

	* CUI_LhsAutomaton.cc (dump): ifdef'd (both versions)

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): use NO_COPYING()
	macro; ifdef'd dump() decls

	* CUI_Symbol.cc (eqRewrite): AdvisoryCheck() -> IssueAdvisory()
	(memoStrategy): AdvisoryCheck() -> IssueAdvisory()

===================================Engine56==================================================

1999-11-03  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.hh (class CUI_Symbol): added decl for memoStrategy()

	* CUI_Symbol.cc (eqRewrite): set seenZero if we see a zero!
	(eqRewrite): use memoStrategy() in the memo case
	(memoStrategy): added

1999-10-29  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.cc (CUI_Symbol): use new BinarySymbol conventions

===================================Engine53==================================================

1999-10-26  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_LhsAutomaton.cc (addSubpattern): VariableTerm::dynamicCast()
	-> dynamic_cast<VariableTerm*>()

	* CUI_LhsCompiler.cc (compileLhs): VariableTerm::dynamicCast() ->
	dynamic_cast<VariableTerm*>() (*4)

	* CUI_Term.cc (findIndex): VariableTerm::dynamicCast() ->
	dynamic_cast<VariableTerm*>()

	* CUI_Symbol.cc (CUI_Symbol): added memoFlag arg

	* CUI_Symbol.hh (class CUI_Symbol): added memoFlag arg to ctor
	decl

1999-10-19  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_DagNode.cc (getHashValue): added

	* CUI_DagNode.hh (class CUI_DagNode): added data member hashCache
	(class CUI_DagNode): added decl for getHashValue()

===================================Engine52==================================================

1999-05-12  Steven Eker  <eker@goo.csl.sri.com>

	* CUI_Symbol.hh (class CUI_Symbol): computeTrueSort() ->
	normalizeAndComputeTrueSort()

	* CUI_Symbol.cc (computeTrueSort): become
	normalizeAndComputeTrueSort()
	(normalizeAndComputeTrueSort): use fastComputeTrueSort()

===================================Engine49==================================================

Fri Nov  6 16:24:35 1998  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Term.cc (deepCopy): -> deepCopy2()

	* CUI_Term.hh: deepCopy() -> deepCopy2()

===================================Engine43==================================================

Thu Oct  8 14:24:30 1998  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Term.cc (compareArguments): inserted const

===================================Engine41==================================================

Fri Sep 18 15:04:48 1998  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Symbol.cc (computeBaseSort): rewritten using setSortIndex(),
	traverse(), lookupSortIndex()

	* CUI_DagNode.cc (overwriteWithClone): use setSortIndex()
	(makeClone): use setSortIndex()

Wed Sep  9 11:49:29 1998  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Symbol.cc (compileOpDeclarations): do
	commutativeSortCompletion() before Symbol::compileOpDeclarations()
	due to new implementation

===================================Engine40==================================================

Tue Jul 21 10:29:54 1998  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Term.hh (class CUI_Term): added decl for new ctor

	* CUI_Term.cc: added new ctor
	(deepCopy): added

	* CUI_Term.hh (class CUI_Term): added decl for deepCopy()

===================================Engine39==================================================

Wed Jun 10 14:39:56 1998  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Symbol.hh (class CUI_Symbol): added decl for postInterSymbolPass()

	* CUI_Symbol.cc (compileOpDeclarations): no longer do identity
	stuff here
	(postInterSymbolPass): added to do identity stuff

	* CUI_Term.hh (class CUI_Term): updated normalize() decl

	* CUI_Term.cc (normalize): don't use earlyGetIdentity()
	(normalize): compute changed flag

	* CUI_LhsAutomaton.cc: IntSet -> NatSet

	* CUI_Term.cc: IntSet -> NatSet

	* CUI_LhsCompiler.cc: IntSet -> NatSet

	* CUI_Term.hh: IntSet -> NatSet

===================================Engine38==================================================

Wed Jun  3 16:37:10 1998  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Term.cc (normalize): use earlyGetIdentity()

===================================Engine37==================================================

Fri Feb 20 17:33:46 1998  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_DagNode.cc (stackArguments): only stack arguments that are
	not flagged as unstackable

===================================Engine36==================================================

Thu Feb 12 14:40:08 1998  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsAutomaton.cc (~CUI_LhsAutomaton): added
	(CUI_LhsAutomaton): clear all automata pointers at outset to allow
	for safe destruction at any time.
	(addSubpattern): no need to clear automata pointers here

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): added decl for
	~CUI_LhsAutomaton()

	* CUI_Term.cc (normalize): compare() == 0 changed to equal() (2 places)

	* CUI_Matcher.cc (match): compare() != 0 changed to !equal()
	(idemCollapseMatch): compare() == 0 changed to equal()
	(id1CollapseMatch): compare() == 0 changed to equal()

	* CUI_LhsCompiler.cc (analyseConstraintPropagation):compare() == 0
	changed to equal() 
	(compileLhs): compare() == 0 changed to equal()

	* CUI_DagNode.cc (normalizeAtTop): compare() == 0 changed to
	equal() (2 places)

	* CUI_LhsAutomaton.hh (match): compare() == 0 changed to equal()
	(2 places)

=============================Engine35========================================================

Tue Dec 23 13:27:27 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsCompiler.cc (compileLhs): use greedySafe()

Wed Dec 10 16:44:50 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsAutomaton.cc (addSubpattern): added a real ugly hack to
	prevent first topAutomaton being compiled for greedy matching in
	idem case because even if variables are not shared between
	subterms, extension is.

Fri Dec  5 14:45:23 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Symbol.cc (compileOpDeclarations): call
	leftIdentitySortCheck(), rightIdentitySortCheck() and
	idempotentSortCheck() if needed

Thu Dec  4 10:43:15 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Matcher.cc (id1CollapseMatch): only exclude the case where
	the subject (portion of subject) matched is our identity if
	ID0_COLLAPSE; otherwise we miss matches if we only have a right
	identity

	* CUI_Symbol.cc (CUI_Symbol): deleted inert arg

	* CUI_Symbol.hh (class CUI_Symbol): deleted inert arg from ctor
	decl

	* CUI_LhsAutomaton.cc (dump): removed extra \t
	(Subpattern::dump): print ground alien correctly

	* CUI_LhsCompiler.cc (compileLhs): make flags an int to avoid
	conversion from `int' to `enum CUI_LhsAutomaton::Flags warning

Wed Dec  3 11:14:09 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsCompiler.cc (compileLhs): heavily rewritten to use flags
	and handle non-comm case; also comm case optimized in that we set
	forward and reverse flags to avoid checking other possibility in
	the case where the subterms are stable and have different top symbols

	* CUI_Matcher.cc: commMatch() -> freeMatch() throughout

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): commMatch() -> freeMatch()

	* CUI_LhsAutomaton.cc (CUI_LhsAutomaton): rewritten to use Flags
	(addSubpattern): rewritten to use Flags
	(operator<<): added (Flags version)
	(dump): now print flags

	* CUI_Matcher.cc (match): rewritten to use Flags

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): deleted idempotent
	and subpatternsDistinct data memebers
	(class CUI_LhsAutomaton): redesigned around new enum Flags

	* CUI_Matcher.cc (match): use forward, reverse and conditional
	reverse flags to handle non-commutative case

	* CUI_LhsCompiler.cc (analyseConstraintPropagation): handle
	non-commutative case

Tue Dec  2 10:24:34 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_DagNode.cc (copyEagerUptoReduced2): rewritten to deal with
	non-permutative strategies
	(normalizeAtTop): rewritten to handle non-commutative case
	(collapseTo): rewritten to deal with non-permutative strategies

	* CUI_Symbol.hh (comm): added
	(leftId): added
	(rightId): added
	(idem): updated

	* CUI_Term.cc (normalize): rewritten to handle non-commutative case
	(findEagerVariables): rewritten to deal with non-permutative strategies
	(markEagerArguments): rewritten to deal with non-permutative strategies
	(analyseCollapses): deal with seperate left and right identity axioms

	* CUI_Symbol.cc (CUI_Symbol): take axioms arg; call setStrategy()
	if not commutative
	(eqRewrite): rewritten to deal with non-permutative strategies

	* CUI_Symbol.hh (class CUI_Symbol): idemFlag data member deleted,
	axioms data memeber added, enum Axioms added,
	ctor decl now take Axioms arg

Mon Dec  1 12:34:48 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_DagNode.cc (copyEagerUptoReduced2): use getPermuteStrategy();
	PermuteSymbol -> BinarySymbol
	(collapseTo): use getPermuteStrategy();
	PermuteSymbol -> BinarySymbol

	* CUI_Term.cc (findEagerVariables): use getPermuteStrategy();
	PermuteSymbol -> BinarySymbol (*3)
	(markEagerArguments): use getPermuteStrategy();
	PermuteSymbol -> BinarySymbol

	* CUI_Symbol.cc (CUI_Symbol): PermuteSymbol -> BinarySymbol; call
	setPermuteStrategy()
	(eqRewrite): use getPermuteStrategy() (*3)

	* CUI_Symbol.hh (class CUI_Symbol): PermuteSymbol -> BinarySymbol

Tue Nov 25 10:20:05 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsAutomaton.cc (dump): implemented

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): updated dump() decl
	(class CUI_LhsAutomaton): unionized struct Subpattern
	(class CUI_LhsAutomaton): added decl for Subpattern::dump()

	* CUI_RhsAutomaton.cc (buildAliens): deleted
	(dump): implemented

	* CUI_RhsAutomaton.hh (addAlien): deleted
	(class CUI_RhsAutomaton): deleted decls for buildAliens(),
	addAlien(); deleted data member aliens; update decl for
	dump()

=============================Engine33========================================================

Tue Nov 18 16:36:36 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Term.cc (dumpArguments): deleted
	(dump): added

	* CUI_Term.hh (class CUI_Term): deleted decls for
	compileLhsNonCollapse(), compileLhsCollapse() and addSubterm()
	(class CUI_Term): dumpArguments() decl now passes
	variableInfo by ref; removed const; switch varableInfo,
	indentLevel args
	(class CUI_Term): dumpArguments() decl becomes dump()

	* CUI_LhsCompiler.cc (compileLhs): incorporate
	compileLhsNonCollapse() and compileLhsCollapse() since these are
	now very similar
	(compileLhsNonCollapse): deleted
	(compileLhsCollapse): deleted

=============================Engine32========================================================

Tue Nov 11 10:22:20 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): removed comment
	that id1CollapsePossible implies subpatternsDistinct as we no
	longer ensure this; we don't generate repeated solutions since if
	we have a collapse and the subpatterns are identical then (1) we
	are not idempotent and (2) the only thing we could match by
	collapse is identity and this case is caught in id1CollapseMatch()

	* CUI_LhsAutomaton.cc (addSubpattern): in the variable case we
	need to insert variable into boundUniquely if we are in the
	uniqueBranch situation

	* CUI_Theory.hh: deleted forward decl for class CUI_Subproblem

	* CUI_DagNode.hh (class CUI_DagNode): revoke friendship for class
	CUI_Subproblem since this class won't be created

	* CUI_LhsCompiler.cc (compileLhsCollapse): pass greedy to ctor;
	removed call to complete()
	(compileLhsCollapse): take greedy into spl calculation
	(compileLhsNonCollapse): pass greedy to ctor; removed call to
	complete()
	(compileLhsNonCollapse): use addSubpattern() in place of addSubterm()
	(addSubterm): deleted

	* CUI_LhsAutomaton.cc (operator<<): added

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): greedyMatchOK data
	member becomes const

	* CUI_LhsAutomaton.cc (complete): deleted
	(CUI_LhsAutomaton): added greedyMatchOK arg

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): boundUniquely arg
	to addSubpattern() no longer const
	(class CUI_LhsAutomaton): ctor takes greedyMatchOK arg
	(class CUI_LhsAutomaton): deleted decl for complete()
	(class CUI_LhsAutomaton): UNSET -> UNDEFINED

	* CUI_LhsAutomaton.cc (addGroundAlien): deleted
	(addTopVariable): deleted
	(addNonGroundAlien): deleted
	(addSubpattern): now handle uniqueBranch case

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): deleted decls for
	addGroundAlien(), addTopVariable(), addNonGroundAlien()

	* CUI_Matcher.cc (id1CollapseMatch): reject matches where subject
	(or in extension case matched portion) is our identity since these
	solutionns will have already been found on the id0Collapse branch
	(idemCollapseMatch): (non-ex) reject matches where subject is our
	identity
	(idemCollapseMatch): (ex) add EqualitySubproblem to reject matches
	where matched portion is our identity

Mon Nov 10 11:59:54 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsCompiler.cc (compileLhsCollapse): use addSubpattern()

	* CUI_LhsAutomaton.cc (addSubpattern): added

	* CUI_Term.hh (class CUI_Term): added decls for
	compileLhsNonCollapse() and compileLhsCollapse()

	* CUI_LhsCompiler.cc (compileLhs): main code split off into
	compileLhsCollapse() and compileLhsNonCollapse()
	(compileLhsNonCollapse): created
	(addSubterm): standard automata are always compiled with
	matchAtTop = false
	(compileLhsCollapse): added

Fri Nov  7 10:01:16 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsCompiler.cc (compileLhs): if one subterm is variable and
	other is not match variable last to improve substitution
	(addSubterm): in variable case when we have unique branch, update boundUniquely

	* CUI_Matcher.cc (match): fixed bug where we were passing solution
	rather than local to simpler matching functions

	* CUI_Term.cc (normalize): set hash value in the case we don't collapse

	* CUI_LhsAutomaton.cc (addNonGroundAlien): added
	(addTopVariable): added
	(addGroundAlien): added

	* CUI_Term.hh (class CUI_Term): added decl for addSubterm()

	* CUI_LhsCompiler.cc (analyseConstraintPropagation): check for
	ground() before testing for willGroundOutMatch()
	(addSubterm): added
	(compileLhs): rewritten

Thu Nov  6 10:30:42 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): added decls for
	ctor and complete()

	* CUI_LhsAutomaton.cc (complete): added
	(CUI_LhsAutomaton): added

	* CUI_LhsCompiler.cc (betterToReverseOrder): moved here from CUI_Term.cc
	(analyseConstraintPropagation): moved here from CUI_Term.cc
	(compileLhs): moved here from CUI_Term.cc

	* CUI_Term.cc (insertAbstractionVariables): deleted

	* CUI_Term.hh (class CUI_Term): deleted decl for
 	insertAbstractionVariables()

	* CUI_Matcher.cc (idemCollapseMatch): ExtensionMatchSubproblem()
	needs nrVariables arg
	(match): handle non-collapse failure efficiently

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): deleted
	abstractionVariable data member

	* CUI_Matcher.cc (idemCollapseMatch): (non-ext version) rewritten to use new
	Subpattern::match(); now deals correctly with matchAtTop case when
	there is no extension
	(idemCollapseMatch): (ext version) deleted null subproblem special
	case; since our new extensionInfo convention allows us to return
	both a subproblem and valid extensionInfo we don't need this case;
	The speed up of handling this special case is marginal since we
	must be at top we will not lose any constraint propagation by
	delaying second subterm match until solve phase. BTW this case
	should be very rare anyway. Use class ExtensionMatchSubproblem an
	avoid the need for abstraction variables.
	(match): simplified by using ?: within if()

Wed Nov  5 09:56:45 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Matcher.cc (id0CollapseMatch): rewritten to use new
	Subpattern::match()
	(id1CollapseMatch): made symmetric with id0CollapseMatch()

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): added matchAtTop
	and extensionInfo args to Subpattern::match()
	(match): added matchAtTop and extensionInfo args

	* CUI_Matcher.cc (match): removed uniqueBranch code from from
	collapse cases

	* CUI_Term.cc (analyseConstraintPropagation): simplified and bug
	fixed; don't bother with analysis in collapse cases; take
	honorGroundOutMatch into account; make sure that subterms are match
	idependent before calling betterToReverseOrder(); treat subterms
	the same as a special case
	(betterToReverseOrder): remove test for collapse since this will
	be done in caller

	* CUI_Matcher.cc (match): rewritten to use uniqueBranch

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): extAutomaton ->
	topAutomaton since we may need to clone subject when matching at top.

	* CUI_Matcher.cc (id0CollapseMatch): rewritten to make use of the
	fact that identity dags are now safe from garbage collection and
	aboid the need for an abstraction variable
	(id1CollapseMatch): added; symmetric with id0CollapseMatch()

	* CUI_Term.hh (class CUI_Term): added decls for
	betterToReverseOrder(), id0CollapsePossible and id1CollapsePossible

	* CUI_Term.cc (analyseCollapses): use Term::commonSymbols(); set
	idemCollapsePossible
	(analyseCollapses): set id0CollapsePossible and id1CollapsePossible
	(betterToReverseOrder): added
	(analyseConstraintPropagation): implemented

	* CUI_Term.hh (class CUI_Term): added data member idemCollapsePossible

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): added uniqueBranch
	and collapsePossible data members

Tue Nov  4 17:13:59 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): added idempotent
	and matchAtTop data members

	* CUI_Matcher.cc (match): in non collapse case don't try 2nd
	possibility if subpatterns are the same or subject subterms are
	the same.

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): added
	subpatternsDistinct data member

Mon Nov  3 12:02:21 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_LhsAutomaton.cc: created

	* CUI_LhsAutomaton.hh (class CUI_LhsAutomaton): created

	* CUI_Matcher.cc: greatly simplified from rought draft using
	DisjunctiveSubproblemAccumulator

=============================Engine31========================================================

Tue Oct 21 12:36:47 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Term.cc (dagify2): switched decl to new convention

	* CUI_Term.hh (class CUI_Term): switched dagify2() decl to new convention

Fri Oct 17 10:37:12 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_ArgumentIterator.hh (CUI_ArgumentIterator): initialize
	position to 0, not 2

	* CUI_Term.cc (normalize): fixed bug in 2nd id collapse case

	* CUI_DagNode.cc (normalizeAtTop): fixed bug in 2nd id collapse case

	* CUI_Term.cc: created

	* CUI_ArgumentIterator.hh (class CUI_ArgumentIterator): created

	* CUI_ArgumentIterator.cc: created

	* CUI_RhsAutomaton.cc: created

	* CUI_RhsAutomaton.hh (class CUI_RhsAutomaton): created

	* CUI_Term.hh: created

Thu Oct 16 17:33:23 1997  Steven Eker  <eker@lilac.csl.sri.com>

	* CUI_Symbol.hh (idem): added
	(class CUI_Symbol): added decl for idem()

	* CUI_DagNode.hh (class CUI_DagNode): added decl for collapseTo()

	* CUI_DagNode.cc (collapseTo): added

	* CUI_DagArgumentIterator.cc: created

	* CUI_DagArgumentIterator.hh (class CUI_DagArgumentIterator): created

	* CUI_DagNode.cc: created

	* CUI_DagNode.hh (class CUI_DagNode): created

	* CUI_Symbol.cc: created

	* CUI_Symbol.hh (class CUI_Symbol): created

