2022-12-19  Steven Eker  <eker@pup>

	* variantUnifierFilter.cc (VariantUnifierFilter::insertUnifier): take the range
	of the internal tuple from the root of the context rather than from the first
	binding in the unifier, to fix a bug in the case that the unifier is the empty
	assignment

===================================Maude138===========================================

2022-02-21  Steven Eker  <eker@pup>

	* narrowingSequenceSearch3.cc (NarrowingSequenceSearch3::findNextUnifier): use
	FilteredVariantUnifierSearch for unifying with goal if FILTER_VARIANT_UNIFIERS
	has been passed

===================================Maude137b===========================================

2021-05-04  Steven Eker  <eker2@eker10>

	* narrowingSequenceSearch.cc
	(NarrowingSequenceSearch::findNextMatch): use
	getVariableInfo().getNrVariables() in place of getNrOfVariablesInSubject()

	* narrowingSearchState.hh: deleted getNrOfVariablesInSubject()

===================================Maude136===========================================

2021-02-19  Steven Eker  <eker2@eker10>

	* unificationProblem.hh (class UnificationProblem): delete
	destructiveUpdates data member; update decl for ctor

	* unificationProblem.cc (UnificationProblem::UnificationProblem):
	removed destructiveUpdates argument

	* irredundantUnificationProblem.cc: don't pass a
	destructiveUpdates argument

	* unificationProblem.cc
	(UnificationProblem::findOrderSortedUnifiers): use new
	freeVariables semantics
	(UnificationProblem::bindFreeVariables): make new variables and do
	instantiation of orginal bindings if destructiveUpdates == false
	(UnificationProblem::UnificationProblem): force destructiveUpdates
	= false because they produce denormalized unifiers
	(UnificationProblem::bindFreeVariables): get name for new variable
	from old variable
	(UnificationProblem::bindFreeVariables): delete the code for the
	destructiveUpdate case

	* unificationProblem.hh (class UnificationProblem): data member
	freeVariables becomes a NatSet rather than a Vector<int>

	* irredundantUnificationProblem.cc
	(IrredundantUnificationProblem::IrredundantUnificationProblem):
	pass destructiveUpdates = false to UnificationProblem

	* unificationProblem.cc
	(UnificationProblem::UnificationProblem): take and set
	destructiveUpdates flag

	* unificationProblem.hh (class UnificationProblem): update ctor
	decl
	(class UnificationProblem): added data member destructiveUpdates

	* unificationProblem.cc (UnificationProblem::bindFreeVariables):
	index -> newSortIndex

2021-02-18  Steven Eker  <eker2@eker10>

	* irredundantUnificationProblem.cc
	(IrredundantUnificationProblem::findNextUnifier): fix off-by-error
	in call to UnifierFilter

===================================Maude133===========================================

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

	* narrowingSearchState2.cc
	(NarrowingSearchState2::NarrowingSearchState2): pass
	maintainInvariants = false to instantiate()

	* narrowingSearchState3.cc
	(NarrowingSearchState3::makeAccumulatedSubstitution): pass
	maintainInvariants = true to instantiate()

	* narrowingSequenceSearch3.cc
	(NarrowingSequenceSearch3::NarrowingSequenceSearch3): pass
	maintainInvariants = false to instantiate(); comment out hack to
	compute sorts
	(NarrowingSequenceSearch3::findNextUnifier): pass
	maintainInvariants = false to instantiate() (2 places)

	* narrowingSequenceSearch.cc
	(NarrowingSequenceSearch::NarrowingSequenceSearch): pass
	maintainInvariants = false to instantiate()

	* narrowingUnificationProblem.cc
	(NarrowingUnificationProblem::bindFreeVariables): pass
	maintainInvariants = true to instantiate()

	* unificationProblem.cc
	(UnificationProblem::findOrderSortedUnifiers): pass
	maintainInvariants = true to instantiate()

	* variantMatchingProblem.cc
	(VariantMatchingProblem::findNextMatcher): pass maintainInvariants
	= true to instantiate()

	* variantNarrowingSearchState.cc
	(VariantNarrowingSearchState::findNextVariant): pass
	maintainInvariants = false to instantiate() (2 places)

	* variantSearch.cc: pass maintainInvariants = false to
	instantiate()

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

	* narrowingSequenceSearch3.hh (class NarrowingSequenceSearch3):
	added data member nrStatesExpanded

	* narrowingSequenceSearch3.cc
	(NarrowingSequenceSearch3::NarrowingSequenceSearch3): initialize
	nrStatesExpanded
	(NarrowingSequenceSearch3::findNextInterestingState): increment
	nrStatesExpanded everytime we try to expand a state; output this
	number in a Verbose() message

	* narrowingFolder.cc (NarrowingFolder::getNextSurvivingState):
	removed Verbose() since we can't be sure of number of surviving
	state - this is because cleanGraph() will erase states that
	have been expanded if we're not keeping a history

	* narrowingSequenceSearch3.cc
	(NarrowingSequenceSearch3::findNextInterestingState): fix
	Verbose() for total number of states seen so that it executes if
	we stop because of depth; include initial state in count

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

	* narrowingSequenceSearch3.cc: added hack to compute sorts in
	goal; probably we should fix this by having a flag to
	instantiate() to say whether sorts are expected and should be
	maintained for ground dags

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

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

	* variantSearch.cc: fill out problemOkay

	* variantSearch.hh (class VariantSearch): added decl for problemOK()
	(VariantSearch::problemOK):added
	(class VariantSearch): added data member problemOkay

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

	* variantFolder.cc (VariantFolder::insertVariant): deleted
	commented out code (3 places)

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

	* variantSearch.cc: removed BUG comment from reduce() call and
	added a detailed explanation of why the potential bug is in fact
	avoided by DagNode::indexVariables(NarrowingVariableInfo& indices,
	int baseIndex)

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

	* narrowingSequenceSearch3.cc (NarrowingSequenceSearch3): deleted
	fold and keepHistory arguments; take and store variantFlags
	argument
	(NarrowingSequenceSearch3::findNextInterestingState): pass
	variantFlags to NarrowingSearchState3

	* narrowingSequenceSearch3.hh (class NarrowingSequenceSearch3):
	added enum flags; delete ctor fold and keepHistory arguments;
	added variantFlags argument
	(class NarrowingSequenceSearch3): added variantFlags data member

	* narrowingSearchState3.cc
	(NarrowingSearchState3::markReachableNodes): deleted because
	blockerDags vector is always empty

	* narrowingSearchState3.hh (class NarrowingSearchState3): make
	blockerDags const since it will always be empty; delete
	SimpleRootContainer private base class; delete decl for
	markReachableNodes()

	* narrowingSearchState3.cc (NarrowingSearchState2): take and store
	variantFlags
	(NarrowingSearchState3::findNextNarrowing): pass variantFlags to
	VariantUnificationProblem()

	* narrowingSearchState3.hh (class NarrowingSearchState3): added
	variantFlags argument to ctor; added data member variantFlags

	* narrowingSearchState2.hh (class NarrowingSearchState2): added
	data member variantFlags

	* narrowingSearchState2.cc (NarrowingSearchState2): take and store
	variantFlags argument
	(NarrowingSearchState2::findNextNarrowing): pass variantFlags to
	VariantUnificationProblem()

	* narrowingSearchState2.hh (class NarrowingSearchState2): added
	variantFlags argument to ctor

	* variantUnificationProblem.cc: take variantFlags and use them to
	decide between FilteredVariantUnifierSearch() and VariantSearch();
	pass them on to the chosen constructor

	* variantUnificationProblem.hh (class VariantUnificationProblem):
	added variantFlags argument to ctor; added enum Flags

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

	* filteredVariantUnifierSearch.cc: updated comments

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

	* variantFolder.hh (class VariantFolder): deleted decls for
	getNextSurvivingVariant(), getLastReturnedVariant()

	* variantFolder.cc (VariantFolder::getNextSurvivingVariant):
	deleted
	(VariantFolder::getLastReturnedVariant): deleted

	* variantSearch.hh (class VariantSearch): deleted decls for
	getNextVariant(), getLastReturnedVariant()

	* variantSearch.cc (VariantSearch::getNextVariant): deleted
	(VariantSearch::getLastReturnedVariant): deleted

	* variantSearch.hh (VariantSearch::getCurrentVariant): translate
	parentNumber to external numbering scheme
	(class VariantSearch): data member nrVariantsReturned becomes
	nrVariantsFound

	* variantSearch.cc (VariantSearch::getNextVariant): deleted
	(VariantSearch::findNextVariant): increment nrVariantsFound
	(VariantSearch): initialize nrVariantsFound rather than
	nrVariantsReturned
	(VariantSearch::findNextVariant): build internal to external
	variant numbering map

	* variantSearch.hh (class VariantSearch): added decl for
	findNextVariant()

	* variantSearch.cc (VariantSearch::findNextVariant): added

	* variantSearch.hh (VariantSearch::getCurrentVariant): added

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

	* narrowingUnificationProblem.cc
	(NarrowingUnificationProblem::bindFreeVariables): use range-based
	for loop
	(NarrowingUnificationProblem::findOrderSortedUnifiers): use
	range-based loop (3 places)

	* unificationProblem.cc (UnificationProblem::bindFreeVariables):
	use range-based for loop

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

	* narrowingSearchState2.hh (class NarrowingSearchState2):
	rearrange data members for more compact layout

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

	* narrowingSequenceSearch3.cc
	(NarrowingSequenceSearch3::findNextInterestingState): updated call
	to NarrowingSearchState3()

	* narrowingSearchState3.hh (class NarrowingSearchState3): updated
	decl for ctor

	* narrowingSearchState3.cc: switch order of freshVariableGenerator
	and incomingVariableFamily for consistancy with other classes

	* narrowingSearchState3.hh (class NarrowingSearchState3): don't
	derive from CacheableState since we're not caching these

	* narrowingFolder.cc (NarrowingFolder::insertState): use StateSet

	* narrowingFolder.hh (class NarrowingFolder): added typedef
	StateSet

	* narrowingFolder.cc (~NarrowingFolder): use range-based for loop
	(NarrowingFolder::markReachableNodes): use range-based for loop
	(NarrowingFolder::insertState): use range-based for loop

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

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

	* variantSearch.hh (VariantSearch::makeVariantMatchingProblem):
	take subject as a RewritingContext

	* variantMatchingProblem.cc (VariantMatchingProblem): take subject
	as a RewritingContext; don't index subject variables here
	(~VariantMatchingProblem): delete subject
	(VariantMatchingProblem::checkVariablesInSubject): access subject
	as a RewritingContext
	(VariantMatchingProblem::markReachableNodes): don't mark subject
	(VariantMatchingProblem::findNextMatcher): access subject as a
	RewritingContext

	* variantMatchingProblem.hh
	(VariantMatchingProblem::freshVariablesNeeded): added
	(class VariantMatchingProblem): take and store subject as a
	RewritingContext

	* variantFolder.hh (class VariantFolder): better explained the
	semantics of findNextVariantThatMatches()

	* variantFolder.cc (VariantFolder::findNextVariantThatMatches):
	need to clear matcher on failure so caller doesn't try to double
	delete it

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

	* variantUnifierFilter.cc
	(VariantUnifierFilter::markReachableNodes): deleted
	(VariantUnifierFilter::insertUnifier): use setNode()/getNode() for
	encodedUnifier
	(VariantUnifierFilter): don't initialize encodedUnifier

	* variantUnifierFilter.hh (class VariantUnifierFilter): remove
	SimpleRootContainer as a base class
	(class VariantUnifierFilter): deleted decl for
	markReachableNodes(); make encodedUnifier a DagRoot

	* variantUnifierFilter.cc
	(VariantUnifierFilter::findNextSurvivingUnifier): moved here; no
	longer inline
	(VariantUnifierFilter): initialize currentUnifierSubsumed;
	currentUnifier
	(VariantUnifierFilter::findNextSurvivingUnifier): delete
	currentUnifier if it was subsumed and we move the iterator past it
	(VariantUnifierFilter::insertUnifier): don't waste time trying to
	subsume new unifier with current unifier if the
	currentUnifierSubsumed flag is set; set flag rather the deleting
	the currentUnifier if new unifier subsumes it

	* variantUnifierFilter.hh (class VariantUnifierFilter): added data
	member currentUnifierSubsumed

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

	* variantUnifierFilter.hh
	(VariantUnifierFilter::findNextSurvivingUnifier): support
	extraction even as new unifiers may be added

	* filteredVariantUnifierSearch.cc
	(FilteredVariantUnifierSearch::findNextUnifier): support
	incremental extraction

	* variantUnifierFilter.cc (VariantUnifierFilter::insertUnifier):
	allow unifiers to be added after extraction started

	* filteredVariantUnifierSearch.cc (FilteredVariantUnifierSearch):
	init flags; don't pass IRREDUNDANT_MODE by default

	* filteredVariantUnifierSearch.hh (class
	FilteredVariantUnifierSearch): added data member flags

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

	* filteredVariantUnifierSearch.hh
	(FilteredVariantUnifierSearch::filteringIncomplete()): added

	* variantUnifierFilter.cc: initialize filteringIncompleteFlag
	(VariantUnifierFilter::insertUnifier): check for incompleteness of
	subsumption variant set

	* variantUnifierFilter.hh
	(VariantUnifierFilter::filteringIncomplete): added
	(class VariantUnifierFilter): added data member
	filteringIncompleteFlag

	* variantMatchingProblem.cc
	(VariantMatchingProblem::checkVariablesInSubject): added
	(VariantMatchingProblem::findNextMatcher): call
	checkVariablesInSubject() and avoid used variables

	* variantMatchingProblem.hh (class VariantMatchingProblem): added
	decl for checkVariablesInSubject()
	(class VariantMatchingProblem): added decl for data member
	indicesToAvoid, checkedVariablesInSubject

2020-08-27  Steven Eker  <eker2@eker10>

	* variantSearch.cc (VariantSearch): use range-based for loop
	(VariantSearch::markReachableNodes): use range-based for loop
	(VariantSearch::expandLayer): use range-based for loop

	* unifierFilter.cc (~UnifierFilter): use range-based for loop
	(UnifierFilter::markReachableNodes): use range-based for loop
	(UnifierFilter::insertUnifier): use range-based for loop

	* variantFolder.cc (VariantFolder::insertVariant): deleted
	commented out code

	* narrowingSequenceSearch.cc (~NarrowingSequenceSearch): use range
	based for loop

	* narrowingSequenceSearch3.cc (NarrowingSequenceSearch3):
	simplified and eliminated call to getBaseVariableSymbol(); deleted
	commented out code

	* narrowingSequenceSearch.cc (NarrowingSequenceSearch): simplified
	and eliminated call to getBaseVariableSymbol()

	* narrowingSearchState2.cc (NarrowingSearchState2): simplified and
	eliminated call to getBaseVariableSymbol()

	* variantUnificationProblem.cc
	(VariantUnificationProblem::findNextUnifier): simplified and
	eliminated calls to getBaseVariableSymbol()

	* unificationProblem.cc
	(UnificationProblem::findOrderSortedUnifiers): only use
	getBaseVariableSymbol() for fresh variables

2020-08-26  Steven Eker  <eker2@eker10>

	* variantMatchingProblem.cc
	(VariantMatchingProblem::findNextMatcher): handle null returned by
	instantiate()

	* variantSearch.cc (VariantSearch): use original variable symbol
	directly rather than getting sort and using getBaseVariableSymbol()

	* variantMatchingProblem.cc
	(VariantMatchingProblem::findNextMatcher): pass variableInfo
	rather than nrFreeVariables to findNextVariantThatMatches()
	(VariantMatchingProblem::findNextMatcher): bind unbound variables
	to fresh variables

	* variantFolder.hh (class VariantFolder): updated decl for
	findNextVariantThatMatches()

	* variantFolder.cc (VariantFolder::findNextVariantThatMatches):
	pass back variableInfo rather than nrFreeVariables

	* variantSearch.hh (VariantSearch::makeVariantMatchingProblem):
	pass freshVariableGenerator to VariantMatchingProblem()

	* variantMatchingProblem.hh (class VariantMatchingProblem):
	updated decl for ctor; added data member freshVariableGenerator

	* variantMatchingProblem.cc (VariantMatchingProblem): take
	freshVariableGenerator

	* variantFolder.cc (VariantFolder::findNextVariantThatMatches):
	take and fill out nrFreeVaraibles

	* variantFolder.hh (class VariantFolder): updated decl for
	findNextVariantThatMatches()

	* variantMatchingProblem.cc
	(VariantMatchingProblem::findNextMatcher): pass nrFreeVariables to
	findNextVariantThatMatches()

	* variantSearch.cc (VariantSearch): warning for MATCH_MODE
	problems with unsafe variable names

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

	* variantMatchingProblem.cc
	(VariantMatchingProblem::findNextMatcher): apply matcher to
	current variant substitution to get variant matcher
	(VariantMatchingProblem::findNextMatcher): null out matcher and
	subprobem after we delete them

	* variantFolder.hh (class VariantFolder): updated decl for
	findNextVariantThatMatches()

	* variantFolder.cc (VariantFolder::findNextVariantThatMatches):
	pass indexOfLastUsedVariant by reference so we can update it

	* variantMatchingProblem.cc
	(VariantMatchingProblem::markReachableNodes): don't use auto&
	since a reference is the same size as the thing refered to

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

	* variantSearch.hh (class VariantSearch): added
	DELETE_LAST_VARIANT_MATCHING_PROBLEM to enum Flags
	(VariantSearch::getLastVariantMatchingProblem): added
	(VariantSearch::makeVariantMatchingProblem): moved here

	* variantSearch.cc (VariantSearch): initialize
	lastVariantMatchingProblem
	(~VariantSearch): delete lastVariantMatchingProblem if requested

	* variantSearch.hh (class VariantSearch): added data member
	lastVariantMatchingProblem
	(class VariantSearch): added decl for makeVariantMatchingProblem()

	* variantSearch.cc (VariantSearch::makeVariantMatchingProblem):
	added

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

	* variantFolder.hh (class VariantFolder): added decl for
	prepareForVariantMatching()

	* variantFolder.cc: use data member variableInfo rather than a
	local variable
	(VariantFolder::prepareForVariantMatching): added

	* variantFolder.hh (class VariantFolder): added data member
	variableInfo to struct RetainedVariant

	* variantSearch.cc: hande MATCH_MODE; call
	VariantFolder::prepareForVariantMatching()

	* variantSearch.hh (class VariantSearch): added MATCH_MODE to enum
	Flags

	* variantFolder.hh (class VariantFolder): added decl for
	findNextVariantThatMatches()

	* variantFolder.cc (VariantFolder::findNextVariantThatMatches):
	added

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

	* higher.hh: added class VariantMatchingProblem

	* variantMatchingProblem.cc
	(VariantMatchingProblem::VariantMatchingProblem): init matcher,
	currentVariant
	(~VariantMatchingProblem): delete matcher, subproblem

	* variantMatchingProblem.hh (class VariantMatchingProblem): added
	data members matcher, currentVariant

	* variantMatchingProblem.cc
	(VariantMatchingProblem::VariantMatchingProblem): init
	indexOfLastUsedVariant, subproblem

	* variantMatchingProblem.hh (class VariantMatchingProblem): added
	data members indexOfLastUsedVariant, subproblem

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

	* variantFolder.cc (VariantFolder::markReachableNodes): use range
	based for loop (2 places)
	(~VariantFolder): use range based for loop

	* variantMatchingProblem.cc: created

	* variantMatchingProblem.hh: created

2020-08-06  Steven Eker  <eker2@eker10>

	* variantUnifierFilter.cc: initialize encodedUnifier
	(VariantUnifierFilter::insertUnifier): use object data member
	encodedUnifier rather than local pointer
	(VariantUnifierFilter::insertUnifier): add in the rewrite counts
	from the variant searchs done for subsumption

	* variantUnifierFilter.hh (class VariantUnifierFilter): added data
	member encodedUnifier

	* variantUnifierFilter.cc
	(VariantUnifierFilter::markReachableNodes): implemented

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

	* variantUnifierFilter.cc
	(VariantUnifierFilter::getNextSurvivingUnifier): deleted stub
	(VariantUnifierFilter::insertUnifier): added Assert()
	(VariantUnifierFilter::~VariantUnifierFilter): implemented

	* variantUnifierFilter.hh (class VariantUnifierFilter): data
	member nextUnifer becomes currentUnifier
	(VariantUnifierFilter::findNextSurvivingUnifier): added
	(VariantUnifierFilter::getCurrentSurvivingUnifier): added
	(class VariantUnifierFilter): deleted decl for
	getNextSurvivingUnifier()

	* filteredVariantUnifierSearch.cc
	(FilteredVariantUnifierSearch::findNextUnifier): implemented
	(FilteredVariantUnifierSearch::getCurrentUnifier): implemented

2020-08-04  Steven Eker  <eker2@eker10>

	* filteredVariantUnifierSearch.cc
	(FilteredVariantUnifierSearch::findNextUnifier): added stub
	(FilteredVariantUnifierSearch::getCurrentUnifier): added stub

	* filteredVariantUnifierSearch.hh (class
	FilteredVariantUnifierSearch): added decls for findNextUnifier(),
	getCurrentUnifier()

	* variantSearch.cc (VariantSearch::getNextUnifier): deleted

	* variantSearch.hh (VariantSearch::getLastReturnedUnifier): deleted
	(class VariantSearch): deleted decls for getNextUnifier(),
	getLastReturnedUnifier()

	* filteredVariantUnifierSearch.hh (class
	FilteredVariantUnifierSearch): deleted decls for getNextUnifier(),
	getLastReturnedUnifier()

	* filteredVariantUnifierSearch.cc: rewritten to use
	findNextUnifier()/getCurrentUnifier() rather than getNextUnifier()
	(FilteredVariantUnifierSearch::getNextUnifier): deleted
	(FilteredVariantUnifierSearch::getLastReturnedUnifier): deleted

	* narrowingSequenceSearch3.cc
	(NarrowingSequenceSearch3::findNextUnifier): use
	findNextUnifier()/getCurrentUnifier() rather than getNextUnifier()

	* variantUnificationProblem.cc
	(VariantUnificationProblem::findNextUnifier): use
	findNextUnifier()/getCurrentUnifier() rather than getNextUnifier()

	* variantFolder.hh (VariantFolder::getCurrentVariantSize): added

	* variantSearch.hh (class VariantSearch): added decls for
	findNextUnifier(), getCurrentUnifier()

	* variantSearch.cc (VariantSearch::findNextUnifier): added
	(VariantSearch::getCurrentUnifier): added

	* variantFolder.hh (class VariantFolder): added decls for
	findNextSurvivingVariant() and getCurrentVariant()

	* variantFolder.cc (VariantFolder::findNextSurvivingVariant):
	added
	(VariantFolder::getCurrentVariant()): added

	* variantFolder.hh (class VariantFolder): added data member
	currentVariant

2020-08-03  Steven Eker  <eker2@eker10>

	* higher.hh: added class FilteredVariantUnifierSearch

	* filteredVariantUnifierSearch.cc: created

	* filteredVariantUnifierSearch.hh: created

	* variantUnifierFilter.cc (VariantUnifierFilter::insertUnifier):
	handle nrFreeVariables argument
	(VariantUnifierFilter::getNextSurvivingUnifier): take
	nrFreeVariables argument

	* variantUnifierFilter.hh (class VariantUnifierFilter): added
	nrFreeVariables data member to struct RetainedUnifier
	(VariantUnifierFilter::RetainedUnifier::RetainedUnifier): take and
	store nrFreeVariables
	(class VariantUnifierFilter): updated decl for insertUnifier() and
	getNextSurvivingUnifier()

	* variantSearch.hh (class VariantSearch): reorganized member
	functions and comments; made getNextUnifier(),
	getLastReturnedUnifier() virtual

	* variantUnifierFilter.hh (class VariantUnifierFilter): updated
	decl for ctor; deleted data member blockerDags

	* variantUnifierFilter.cc (VariantUnifierFilter::insertUnifier):
	pass dummy vector instead of blockerDags
	(VariantUnifierFilter::VariantUnifierFilter): don't take
	blockerDags argument


2020-07-29  Steven Eker  <eker2@eker10>

	* irredundantUnificationProblem.hh (class
	IrredundantUnificationProblem): commented out decl for
	markReachableNodes()

	* irredundantUnificationProblem.cc
	(IrredundantUnificationProblem::markReachableNodes): commented out
	- UnifierFilter protects the unifiers it returns

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

	* higher.hh: added class VariantUnifierFilter

	* variantUnifierFilter.hh (class VariantUnifierFilter): updated
	decl for ctor

	* variantUnifierFilter.cc (VariantUnifierFilter::insertUnifier):
	finished

	* variantUnifierFilter.hh
	(VariantUnifierFilter::RetainedUnifier::RetainedUnifier): added
	(VariantUnifierFilter::RetainedUnifier::~RetainedUnifier): added

	* variantUnifierFilter.cc
	(VariantUnifierFilter::VariantUnifierFilter): take and initialize
	freshVariableGenerator

	* variantUnifierFilter.hh
	(VariantUnifierFilter::RetainedUnifier::subsumes): added

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

	* variantUnifierFilter.hh: created

	* variantUnifierFilter.cc: created

	* variantNarrowingSearchState.cc
	(VariantNarrowingSearchState::VariantNarrowingSearchState):
	updated comments; use range-based for loop for indexing variant
	substitution; use range-based for loop for iterating over
	equations
	(VariantNarrowingSearchState::findNextVariant): use range-based
	for loop for iterating over blocker dags
	(VariantNarrowingSearchState::findNextVariant): replaced commned
	out print statements with DebugInfo()s
	(VariantNarrowingSearchState::VariantNarrowingSearchState):
	replaced commented out print statement with DebugEnter()

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

	* variantFolder.hh (class VariantFolder): updated decl for
	subsumes()

	* variantFolder.cc (VariantFolder::subsumes): made const

	* variantSearch.hh (class VariantSearch): added decl for
	isSubsumed()

	* variantSearch.cc: added

	* variantFolder.hh (class VariantFolder): added decl for
	isSubsumed(

	* variantFolder.cc (VariantFolder::isSubsumed): added
	(VariantFolder::insertVariant): use isSubsumed()

	* variantSearch.cc (VariantSearch::VariantSearch): in
	SUBSUMPTION_MODE we don't keep the variant substitution and we
	generate a minimal complete set of variants upfront so we can be
	done with blockerDags which some other subsumption search may
	neeed to use

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

	* variantSearch.hh (class VariantSearch): added SUBSUMPTION_MODE
	to Flags

	* variantUnificationProblem.cc: use new VariantSearch calling
	conventions

	* narrowingSequenceSearch3.cc
	(NarrowingSequenceSearch3::findNextUnifier): use new VariantSearch
	calling conventions

	* variantSearch.cc (VariantSearch::VariantSearch): added argument
	flags; deleted arguments unificationMode, irredundantMode,
	deleteFreshVariableGenerator, checkVariableNames; use flags rather
	than unificationMode (2 places)
	(VariantSearch::expandVariant): use flags rather that
	unificationMode (2 places)
	(VariantSearch::VariantSearch): use flags instead of
	checkVariableNames (2 places); use flags instead of
	irredundantMode; updated comment to explain why we expect to get
	redundant unifiers even with irredundant variants
	(VariantSearch::~VariantSearch): use flags instead of
	deleteFreshVariableGenerator

	* variantSearch.hh (class VariantSearch): added enum Flags
	(class VariantSearch): updated ctor decl
	(class VariantSearch): added data member flags; deleted data
	members unificationMode, irredundantMode,
	deleteFreshVariableGenerator
	(VariantSearch::getIrredundantMode): use flags

2020-07-15  Steven Eker  <eker2@eker10>

	* irredundantUnificationProblem.cc
	(IrredundantUnificationProblem::findNextUnifier): don't pass
	argument to RewritingContext ctor

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

	* higher.hh: added forward decl for class
	IrredundantUnificationProblem

2020-07-10  Steven Eker  <eker2@eker10>

	(IrredundantUnificationProblem::findNextUnifier): fill out sorts
	of each binding using dummy RewritingContext

	* irredundantUnificationProblem.hh: created

	* irredundantUnificationProblem.cc: created

	* unificationProblem.cc (UnificationProblem::getSolution): moved
	here because it can no longer be inline, having become virtual
	(getNrFreeVariables): ditto

	* unificationProblem.hh (class UnificationProblem): make
	markReachableNodes() protected so derived class can override it

	* unifierFilter.hh (class UnifierFilter): provide default values
	for postionIndex, equationIndex

	* unificationProblem.hh (class UnificationProblem): made dtor,
	findNextUnifier(), getSolution(), getNrFreeVariables() virtual

	* unifierFilter.hh (class UnifierFilter): added comment to explain
	that posistionIndex and equationIndex are opaque and can be use to
	store whatever integers the caller finds useful to maintain along
	side a unifier

===================================Maude129===========================================

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

	* variantNarrowingSearchState.cc
	(VariantNarrowingSearchState::collectUnifiers): make message
	printed out every thousand unifier depend on globalVerboseFlag
	rather than on DEBUG mode so we can get the same result in test
	suite whether we are debugging or not

2020-06-10  Steven Eker  <eker2@eker10>

	* variantFolder.cc
	(VariantFolder::RetainedVariant::RetainedVariant) fixed symmetric
	bug

	* unifierFilter.cc
	(UnifierFilter::RetainedUnifier::RetainedUnifier): fix bug where
	we were compiling matching using one variable count and then
	running matching with a higher variable count because we added
	abstraction variables for a later binding. Compilation has to be a
	separate pass after all abstraction variables have been added

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

	* narrowingSequenceSearch.cc
	(NarrowingSequenceSearch::findNextNormalForm): added DebugInfo()
	for duplicate states
	(NarrowingSequenceSearch::findNextInterestingState)
	(NarrowingSequenceSearch::findNextNormalForm): added DebugInfo()
	for replacement and narrowedDag
	(NarrowingSequenceSearch::findNextNormalForm)
	(NarrowingSequenceSearch::findNextInterestingState): make dup
	state DebugInfo() more prominent

2020-04-15  Steven Eker  <eker2@eker9>

	* cacheableState.hh (class CacheableState): delete stray ;

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

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

	* unificationProblem.cc (UnificationProblem): pass true to
	warnAboutUnimplemented (2 places)

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

2018-11-05  Steven Eker  <eker@install.csl.sri.com>

	* searchState.hh (PositionState): added comment on
	setInitialSubstitution() convention

2018-11-02  Steven Eker  <eker@install.csl.sri.com>

	* positionState.hh (P): added and explanation of why DagPair exists

===================================Maude120===========================================

2018-10-23  Steven Eker  <eker@install.csl.sri.com>

	* positionState.cc (exploreNextPosition): use stackPhysicalArguments()

2018-09-28  Steven Eker  <eker@install.csl.sri.com>

	* variantSearch.hh (getLastReturnedUnifier): take and pass
	variableFamily

	* variantSearch.cc (getLastReturnedVariant): pass variableFamily
	to VariantFolder::getLastReturnedVariant()

	* variantFolder.hh (SimpleRootContainer): updated decl for
	getLastReturnedVariant()

	* variantFolder.cc (getLastReturnedVariant): take variableFamily
	argument
	(getNextSurvivingVariant): code cleaning

	* variantSearch.hh (SimpleRootContainer): updated decls for
	getNextVariant() and getLastReturnedVariant()

	* variantSearch.cc (getNextVariant): take variableFamily argument
	(getLastReturnedVariant): take variableFamily argument

	* narrowingSequenceSearch.cc (findNextMatch): delete commented
	out matchState->transferCount(*(getContext())) and add comment
	to explain

	* searchState.hh (transferCount): becomes transferCountTo()
	(transferCount): use transferCountFrom()

	* variantUnificationProblem.cc (findNextUnifier):
	transferCount() -> transferCountFrom()

	* stateTransitionGraph.cc (getNextState): transferCount() ->
	transferCountTo()

	* rewriteSequenceSearch.cc (findNextMatch): transferCount() ->
	transferCountTo()

	* rewriteConditionState.cc (solve): transferCount() ->
	transferCountTo()

	* narrowingSequenceSearch3.cc (NarrowingSequenceSearch3):
	transferCount() -> transferCountFrom()
	(findNextUnifier, findNextInterestingState):
	transferCount() -> transferCountFrom()

	* narrowingSearchState2.cc (findNextNarrowing): transferCount() ->
	transferCountFrom() (2 places)

	* stateTransitionGraph.hh (transferCount): becomes
	transferCountTo()
	(transferCountTo): use transferCountFrom()

2018-09-27  Steven Eker  <eker@install.csl.sri.com>

	* variantSearch.hh (SimpleRootContainer): changed default value
	for incomingVariableFamily from 2 to NONE so we still report
	@ variables as a problem if no incomingVariableFamily is specified

	* variantSearch.cc (VariantSearch): change secondVariableFamily
	calculation to handle NONE correctly

	* variantSearch.hh (SimpleRootContainer): disallowedVariableFamily ->
	incomingVariableFamily

	* variantSearch.cc (VariantSearch): disallowedVariableFamily ->
	incomingVariableFamily
	(VariantSearch): pass incomingVariableFamily to
	variableNameConflict()

2018-09-25  Steven Eker  <eker@install.csl.sri.com>

	* unificationProblem.hh (getVariableFamily): added

2018-09-21  Steven Eker  <eker@install.csl.sri.com>

	* unificationProblem.cc (UnificationProblem): initialize
	variableFamilyToUse
	(UnificationProblem): pass variableFamilyToUse to
	UnificationContext
	(findOrderSortedUnifiers): pass variableFamilyToUse to
	getFreshVariableName()

	* unificationProblem.hh (SimpleRootContainer): updated
	decl for ctor
	(SimpleRootContainer): added data member variableFamilyToUse

	* unificationProblem.cc (UnificationProblem): take
	incomingVariableFamily and pass it to variableNameConflict()

2018-09-19  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.hh (SimpleRootContainer): deleted
	decl for simpler ctor

	* narrowingSearchState2.cc (NarrowingSearchState2): deleted
	simpler version since nothing calls it

===================================Maude119===========================================

2018-03-23  Rubén Rubio  <rubenrub@ucm.es>

	* pattern.cc (prepare): added
	(Pattern): allow pattern processing to be postponed (for their use in SubtermStrategy)

	* pattern.hh (prepare): added, and two new attributes prepared and withExtension
	(Pattern): allow pattern processing to be postponed

2017-12-05  Steven Eker  <eker@install.csl.sri.com>

	* narrowingFolder.cc (RetainedState):getNrRealVariables() ->
	getNrProtecctedVariables() to fix symmetric bug

	* variantFolder.cc (RetainedVariant): getNrRealVariables() ->
	getNrProtecctedVariables() to fix symmetric bug

2017-12-04  Steven Eker  <eker@install.csl.sri.com>

	* unifierFilter.cc (RetainedUnifier): us getNrProtectedVariables()
	rather than getNrRealVariables() to fix bug where we weren't
	accounting for abstraction variables

===================================Maude116===========================================

2017-05-26  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSequenceSearch3.cc (NarrowingSequenceSearch3): fixed
	bug where we were not deleting stateBeingExpanded

2017-05-25  Steven Eker  <eker@install.csl.sri.com>

	* narrowingFolder.cc (addHistory): added Assert() to catch null
	values in unifier
	(addHistory): reverted - nulls in a unifier are legal between
	the rule variables and the dag variables
	(markReachableNodes): check for null pointers in the unifier
	(addHistory): added comment to explain why we don't need
	to protect our variableInfo copy

	* higher.hh: deleted class NarrowingSequenceSearch2

2017-05-24  Steven Eker  <eker@install.csl.sri.com>

	* narrowingFolder.hh (getHistory): handle unifierVariableInfo

	* narrowingSequenceSearch3.hh (getHistory): handle
	unifierVariableInfo

	* narrowingSequenceSearch3.cc (findNextInterestingState): pass
	variableInfo to addHistory(); don't make a copy of the unifier

	* narrowingFolder.hh (SimpleRootContainer): updated decl for
	addHistory(); added variableInfo data member to struct
	RetainedState

	* narrowingFolder.cc (addHistory): moved here
	(addHistory): take variableInfo argument; make copies of unifier
	and variableInfo

	* narrowingFolder.hh (SimpleRootContainer): deleted decl
	for getState()

	* narrowingFolder.cc (insertState): check that ther
	is a parent state before incrementing its descendant
	count
	(getState): deleted

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

	* narrowingFolder.hh (getHistory): added
	(getDepth): added

	* narrowingSequenceSearch3.hh (getExtraStateInfo): added
	(getHistory): added

2017-05-19  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSequenceSearch2.cc: deleted

	* narrowingSequenceSearch2.hh: deleted

	* narrowingFolder.cc (RetainedState): call
	determineContextVariables() and insertAbstractionVariables()

	* narrowingSequenceSearch3.hh (getUnifierVariableFamily): added
	(getStateDag): deleted

2017-05-18  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.cc (NarrowingSearchState2): fix bug that
	we didn't hande the ground case
	(NarrowingSearchState2): fix similar bug with blocker dags

	* narrowingSequenceSearch3.cc (NarrowingSequenceSearch3): rename
	user variables to #variables; this side steps a bug where original
	variables could be lost due to reduce and then garbage collected

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

	* narrowingSequenceSearch3.cc (findNextInterestingState): use
	replacementContextProtector to protect replacementContext across
	a reduce() call

	* narrowingSequenceSearch3.hh (SequenceSearch): added data member
	replacementContextProtector

	* narrowingFolder.cc (insertState): increment the nrDescendants in
	the not folding but keeping history case

	* narrowingFolder.hh (SimpleRootContainer): added decl for cleanGraph()

	* narrowingFolder.cc (cleanGraph): added

	* narrowingFolder.hh (SimpleRootContainer): added nrDescendants
	field to RetainedState

	* narrowingFolder.cc (RetainedState): initialize nrDescendants

2017-05-16  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSequenceSearch3.cc (NarrowingSequenceSearch3): initialize
	stateBeingExpandedDepth, expansionSuccessful

	* narrowingSequenceSearch3.hh (SequenceSearch): added data members
	stateBeingExpandedDepth, expansionSuccessful

	* narrowingSequenceSearch3.cc (findNextInterestingState): support
	=>!

2017-05-12  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSequenceSearch3.hh (getStateInfo): added
	(getVariableInfo): becomes getUnifierVariableInfo()
	(getInitialVariableInfo): added

	* narrowingSequenceSearch3.cc (findNextInterestingState): test for !=
	depth to treat -1 as unbounded

	* narrowingFolder.cc (subsumes): initialize subproblem to 0

	* narrowingSequenceSearch3.hh (SequenceSearch): added data member
	nextInterestingState
	(getStateDag): added

	* narrowingSequenceSearch3.cc (NarrowingSequenceSearch3): initialize
	nextInterestingState
	(findNextUnifier): nextInterestingState is no longer local

	* narrowingSequenceSearch3.hh (getUnifier, getVariableInfo): added

2017-05-11  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState3.cc (makeAccumulatedSubstitution): implemented

	* narrowingFolder.hh (keepingHistory): added

	* narrowingFolder.cc (RetainedState): zero out narrowingContext
	and narrowingPosition
	(markReachableNodes): mark narrowingContext if non-null

	* narrowingFolder.hh (SimpleRootContainer): added data member
	narrowingContext to struct RetainedState
	(addHistory): take and save narrowingContext

	* narrowingSearchState3.hh (SimpleRootContainer): updated decl
	for getNarrowedDag()
	(getSubstitution): becomes getUnifier()

	* narrowingSearchState3.cc (getNarrowedDag): implemented

2017-05-10  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState3.cc (NarrowingSearchState3): implemented
	(~NarrowingSearchState3): implemented
	(markReachableNodes): implemented
	(findNextNarrowing): implemented

	* narrowingSequenceSearch3.cc (findNextUnifier): handle instantiation of
	goal correctly
	(NarrowingSequenceSearch3): index goal

2017-05-09  Steven Eker  <eker@install.csl.sri.com>

	* higher.hh: added class NarrowingSearchState3 and
	class NarrowingSequenceSearch3

	* narrowingSequenceSearch3.cc: created

	* narrowingSequenceSearch3.hh: created

	* narrowingSearchState3.hh: created

	* narrowingSearchState3.cc: created

	* narrowingFolder.hh (SimpleRootContainer): added data member
	currentStateIndex

	* narrowingFolder.cc (NarrowingFolder): initialize
	currentStateIndex

	* narrowingFolder.hh (SimpleRootContainer): updated decl for
	getNextSurvivingState()

	* narrowingFolder.cc (getNextSurvivingState): added

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

	* narrowingFolder.cc (insertState): fill out depth field

	* narrowingFolder.hh (SimpleRootContainer): added depth field
	to struct RetainedState

2017-05-04  Steven Eker  <eker@install.csl.sri.com>

	* narrowingFolder.hh (getState): added

2017-05-03  Steven Eker  <eker@install.csl.sri.com>

	* narrowingFolder.hh (SimpleRootContainer): added field
	narrowingPosition
	(addHistory): handle narrowingPosition

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

	* narrowingSearchState2.hh (SimpleRootContainer): updated decl for
	complex ctor

	* narrowingSearchState2.cc (NarrowingSearchState2): deleted label arg

2017-05-01  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.cc (NarrowingSearchState2): don't initialize
	label (both versions)

	* narrowingSearchState2.hh (SimpleRootContainer): deleted label
	data member

	* narrowingSearchState2.cc (findNextNarrowing): check narrowing
	attribute rather than label

	* narrowingFolder.cc (markReachableNodes): protect
	accumulatedSubstitution and unifier from garbage collection

	* narrowingFolder.hh (addHistory, addAccumulatedSubstitution): added

	* narrowingFolder.cc (RetainedState): default initialization of
	variableFamily, accumulatedSubstitution, rule, unifier

2017-04-28  Steven Eker  <eker@install.csl.sri.com>

	* higher.hh: added class NarrowingFolder

	* narrowingFolder.hh: created

	* narrowingFolder.cc: created

===================================Maude113===========================================

2017-04-25  Steven Eker  <eker@install.csl.sri.com>

	* positionState.cc (rebuildAndInstantiateDag): deleted commented
	out code

===================================Maude112b===========================================

2017-03-30  Steven Eker  <eker@install.csl.sri.com>

	* variantSearch.hh (SimpleRootContainer): added data member
	irredundantMode
	(getIrredundantMode): added

	* variantSearch.cc (VariantSearch): initialize irredundantMode

===================================Maude112a===========================================

2017-03-10  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSequenceSearch.hh (getContext): don't Assert() that
	stateStack.size() > 0

	* narrowingSequenceSearch.cc (findNextInterestingState): call
	incrementNarrowingCount()

2017-03-09  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSequenceSearch2.cc (NarrowingSequenceSearch2): initialize
	currentDepth
	(findNextInterestingState): respect maxDepth in the non-normal form
	case
	(findNextInterestingState): respect maxDepth in normal form case

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

	* narrowingSequenceSearch2.hh (getUnifierVariableFamily): added

	* narrowingSequenceSearch2.cc (findNextUnifier): use getStateDag(),
	getStateVariableFamily()

	* narrowingSequenceSearch2.hh (SequenceSearch): added data members
	expansionSuccessful, expansionFinished
	(getStateDag, getVariableFamily): handle normalFormNeeded flag
	(getStateVariableFamily): renamed from getVariableFamily()

	* narrowingSequenceSearch2.cc (NarrowingSequenceSearch2): set
	expansionFinished = true so we don't expand a nonexistent state
	(findNextInterestingState): reorganized using expansionSuccessful
	and expansionFinished flags; handle normalFormNeeded
	(~NarrowingSequenceSearch2): hand responsibility for deleting context
	of state just expanded to stateBeingExpanded object

	* narrowingSequenceSearch2.hh (isIncomplete): added
	(getVariableFamily): added

	* narrowingSequenceSearch2.cc (findNextUnifier): propagate incompleteness
	from VariantSearch object
	(findNextInterestingState): propagate incompleteness from
	NarrowingSearchState2 object

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

	* narrowingSequenceSearch2.cc (allVariablesBelongToIncomingFamily): added
	(NarrowingSequenceSearch2): support renaming if variables from outside
	of family are detected
	(findNextInterestingState): transfer reduce and narrowing step counts to
	initial
	(NarrowingSequenceSearch2): transfer reduce count to initial
	(findNextInterestingState): call incrementNarrowingCount() after each
	successful narrowing step
	(findNextUnifier): transfer count from context in VariantSearch object
	(NarrowingSequenceSearch2): fix bug where we weren't initializing
	nextToExpand

2017-03-01  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSequenceSearch2.cc (findNextInterestingState): added support
	for tracing and abort

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

	* narrowingSequenceSearch2.hh (getVariableInfo): added

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

	* narrowingSequenceSearch2.hh: created

	* narrowingSequenceSearch2.cc: created

	* higher.hh: added class NarrowingSequenceSearch2

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

	* positionState.cc (rebuildAndInstantiateDag): use new
	instantiateWithReplacement() convention

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

	* positionState.cc (exploreNextPosition): use Symbol version of
	stackArguments()
	(PositionState): pass eager flag to RedexPosition
	(exploreNextPosition): pass eagerContext flag to stackArguments()
	(rebuildAndInstantiateDag): use eager flag to decide which bindings
	to pass to instantiateWithReplacement()

2017-01-27  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.hh (SimpleRootContainer): added GC_VAR_GEN to
	enum Flags; pass it by default

	* positionState.hh (P): made flags an int for safety

	* narrowingSearchState2.cc (NarrowingSearchState2): added simplified
	ctor that assumes all variables are in-family and there are no
	blocker dags
	(NarrowingSearchState2): only delete the variable generator if the flag
	was passed

2017-01-11  Steven Eker  <eker@install.csl.sri.com>

	* rewriteConditionFragment.cc (solve): stack<> -> Stack<>

	* rewriteConditionFragment.hh: stack<> -> Stack<>

	* assignmentConditionFragment.cc (solve): stack<> -> Stack<>

	* assignmentConditionFragment.hh: stack<> -> Stack<>

	* sortTestConditionFragment.cc (solve): stack<> -> Stack<>

	* sortTestConditionFragment.hh: stack<> -> Stack<>

	* equalityConditionFragment.cc (solve): stack<> -> Stack<>

	* equalityConditionFragment.hh: stack<> -> Stack<>

	* searchState.hh: stack<> -> Stack<>

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

2017-01-06  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.cc (NarrowingSearchState2): index blockerDags

	* narrowingSearchState2.hh (SimpleRootContainer): blockerDags no longer const

	* narrowingSearchState2.cc (getNarrowedDag): fix bug where we had an assignment
	inside ?:
	(NarrowingSearchState2): rename variables blockerDags

	* variantUnificationProblem.cc (findNextUnifier): use unifier size to
	know how many bindings to extract from unifier - this makes a difference
	if there are other variables in the context or blocker terms

2017-01-05  Steven Eker  <eker@install.csl.sri.com>

	* variantSearch.cc (VariantSearch): check for unsafe variables names in
	blocker dags

2017-01-03  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.hh (SimpleRootContainer): added data member
	reverseMapping

	* narrowingSearchState2.cc (NarrowingSearchState2): fill out reverseMapping
	(getNarrowedDag): use reverseMapping
	(~NarrowingSearchState2): delete reverseMapping

	* narrowingSearchState2.hh (SimpleRootContainer): updated
	decl for getNarrowedDag()

	* narrowingSearchState2.cc (getNarrowedDag): pass back a
	replacementContext

===================================Maude111a===========================================

2016-12-20  Steven Eker  <eker@install.csl.sri.com>

	* variantUnificationProblem.cc (findNextUnifier): undo change -
	we introduced a suble bug by moving a necessary side effect
	into an Assert()

	* narrowingSearchState2.cc (NarrowingSearchState2): rearrange Assert()
	to avoid unused variable warning

2016-12-19  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.cc (findNextNarrowing): transfer counts
	from newContext to context if they differ (2 places)

	* variantUnificationProblem.cc (VariantUnificationProblem): initialize
	context
	(VariantUnificationProblem): new data member rather than local
	variable for newContext
	(findNextUnifier): tranfer counts from newContext to context

	* variantUnificationProblem.hh (SimpleRootContainer): added data
	members context and newContext

2016-12-16  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.hh (getNrOfVariablesInSubject): deleted

	* narrowingSearchState2.cc (getNarrowedDag): use stored
	module pointer

	* narrowingSearchState2.hh (getReplacedDag): added
	(getActiveContext): added
	(getActiveVariableInfo): added

2016-12-15  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.hh (SimpleRootContainer): added decl
	for allVariablesBelongToIncomingFamily();
	disallowedVariableFamily ->incomingVariableFamily throughout
	(getRule, getSubstitution): moved here

	* narrowingSearchState2.cc: disallowedVariableFamily ->
	incomingVariableFamily throughout
	(allVariablesBelongToIncomingFamily): added

2016-12-14  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.cc (NarrowingSearchState2): fill out
	freshVariableInfo as we create fresh variables.
	(findNextNarrowing): pass freshVariableInfo rather than variableInfo
	to VariantUnificationProblem()

	* narrowingSearchState2.hh (SimpleRootContainer): added data member
	freshVariableInfo

	* narrowingSearchState2.cc (NarrowingSearchState2): don't
	initialize PositionState; dynamically create a PositionState
	object
	(~NarrowingSearchState2): delete positionState
	(findNextNarrowing, getNarrowedDag): use positionState

	* narrowingSearchState2.hh (SimpleRootContainer): removed
	PositionState as a base class; added data member positionState

	* narrowingSearchState2.cc (~NarrowingSearchState2): delete
	freshVariableGenerator

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

	* narrowingSequenceSearch.cc (NarrowingSequenceSearch): clear
	incompleteFlag
	(findNextInterestingState): update incompleteFlag

	* narrowingSequenceSearch.hh (SequenceSearch): added data
	member incompleteFlag
	(isIncomplete): added

	* narrowingSearchState.hh (PositionState): added data
	member incompleteFlag
	(isIncomplete): added

	* narrowingSearchState.cc (findNextNarrowing): update
	incompleteFlag
	(NarrowingSearchState): clear completeFlag

	* narrowingSearchState2.hh (SimpleRootContainer): added data
	member incompleteFlag

	* narrowingSearchState2.cc (findNextNarrowing): update
	incompleteFlag
	(NarrowingSearchState2): clear incompleteFlag

	* narrowingSearchState2.hh (isIncomplete): added

2016-12-09  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.cc (NarrowingSearchState2): use newContext
	(findNextNarrowing): use newContext
	(NarrowingSearchState2): delete newContext

	* narrowingSearchState2.hh (SimpleRootContainer): added data
	member newContext

	* narrowingSearchState2.cc (getNarrowedDag): make a clone of replacement
	so metaContexts work

2016-12-08  Steven Eker  <eker@install.csl.sri.com>

	* narrowingSearchState2.cc (NarrowingSearchState2): new implementation
	that handles variable renaming and initial reduction

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

	* narrowingSearchState2.hh (SimpleRootContainer): derive from CacheableState

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

	* variantUnificationProblem.cc (VariantUnificationProblem): don't
	clear incompleteFlag

	* narrowingSearchState2.cc (findNextNarrowing): pass blockerDags to
	VariantUnificationProblem()

	* variantUnificationProblem.cc (findNextUnifier): don't update incompleteFlag

	* variantUnificationProblem.hh (isIncomplete): use variantSearch incomplete
	flag rather than local one

	* variantUnificationProblem.cc (VariantUnificationProblem): handle blockerDags
	argument

	* variantUnificationProblem.hh (SimpleRootContainer): updated ctor

	* variantSearch.hh (SimpleRootContainer): updated comments

	* narrowingSearchState2.hh (SimpleRootContainer): added decl for
	markReachableNodes()

	* narrowingSearchState2.cc (NarrowingSearchState2): take blockerDags argument

	* variantSearch.hh (SimpleRootContainer): updated decl for ctor

	* narrowingSearchState2.hh (SimpleRootContainer): private derivation
	from SimpleRootContainer
	(SimpleRootContainer): added data member blockerDags

	* narrowingSearchState2.cc (markReachableNodes): added

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

	* variantUnificationProblem.cc (VariantUnificationProblem): pass
	checkVariableNames = false to avoid checks that are unneeded
	and might cause an issue

	* variantSearch.cc (VariantSearch): handle checkVariableNames
	argument

	* variantSearch.hh (SimpleRootContainer): updated decl for ctor

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

	* variantUnificationProblem.cc (VariantUnificationProblem): pass false
	to VariantSearch deleteFreshVariableGenerator arg

	* variantSearch.cc (VariantSearch): handle deleteFreshVariableGenerator
	arg
	(VariantSearch): conditionally delete freshVariableGenerator

	* variantSearch.hh (SimpleRootContainer): added data member
	deleteFreshVariableGenerator; updated decl for ctor

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

	* narrowingSearchState2.hh (PositionState): default to REPECT_FROZEN

	* variantUnificationProblem.cc (findNextUnifier): fix bug where
	we weren't creating fresh variables to bind to unbound variables
	from the preEquation
	(findNextUnifier): increment nrFreeVariables after, rather than
	before fresh variable is created so that numbering is correct

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

	* narrowingSearchState2.cc (findNextNarrowing): don't narrow
	at variable positions
	(findNextNarrowing): check that rule has the right kind on top

	* narrowingSearchState.cc (findNextNarrowing): don't narrow at
	variable positions

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

	* variantUnificationProblem.cc (findNextUnifier): use new
	VariableInfo::variable2Index() member function to translate
	variable from preEquation
	(VariantUnificationProblem): save pointer to preEquation
	(findNextUnifier): fix multiple bugs in manipulation of indices

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

	* higher.hh: added class VariantUnificationProblem,
	class NarrowingSearchState2

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

	* narrowingSearchState2.hh: created

	* narrowingSearchState2.cc: created

	* variantSearch.hh (SimpleRootContainer): added data member targetCopy

	* variantSearch.cc (markReachableNodes): mark targetCopy
	(VariantSearch): use copyAll() to make a complete copy of the target
	dag

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

	* variantUnificationProblem.hh (SimpleRootContainer): added data member
	nrPreEquationVariables

	* variantUnificationProblem.cc (findNextUnifier): avoid binding slots that
	fall in the hole between preEquation variables and target variables
	(VariantUnificationProblem): store nrPreEquationVariables

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

	* variantUnificationProblem.hh: created

	* variantUnificationProblem.cc: created

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

	* variantSearch.hh (SimpleRootContainer): updated decl for ctor

	* variantSearch.cc (VariantSearch): take disallowedVariableFamily
	arg rather than firstVariableFamily, secondVariableFamily args

	* variantFolder.cc: deleted commented out version of getNextSurvivingVariant()

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

	* variantSearch.cc (VariantSearch): need to pass firstVariableFamily when we
	create fresh variables for initial substitution

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

	* variantSearch.cc (expandVariant): pass variableFamily to insertVariant()
	(VariantSearch): pass UNDEFINED as variableFamily to insertVariant()
	(getNextUnifier): Assert() check for UNDEFINED variableFamily

	* variantFolder.hh (SimpleRootContainer): updated decl for insertVariant()

	* variantFolder.cc (getNextSurvivingVariant): fill out variableFamily
	(insertVariant): take variableFamily argument and copy it into RetainedVariant

	* variantFolder.hh (SimpleRootContainer): added data member variableFamily
	to struct RetainedVariant

	* variantSearch.cc (getNextUnifier): pass variableFamily argument to
	getNextSurvivingVariant()
	(getNextVariant): pass dummy variableFamily argument to
	getNextSurvivingVariant()

	* variantFolder.cc (getNextSurvivingVariant): added variableFamily
	argument

	* variantFolder.hh (SimpleRootContainer): updaed decl for
	getNextSurvivingVariant()

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

	* variantSearch.hh (SimpleRootContainer): updated decl for getNextUnifier()

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

	* variantSearch.hh (SimpleRootContainer): updated ctor;
	odd -> useFirstVariableFamily

	* variantSearch.cc (VariantSearch): take arguments
	firstVariableFamily, secondVariableFamily
	(expandVariant, VariantSearch): odd -> useFirstVariableFamily

	* variantSearch.hh (SimpleRootContainer): added data members
	firstVariableFamily, secondVariableFamily

	* variantNarrowingSearchState.hh (PositionState): updated decl
	for ctor

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState): odd
	becomes variableFamily throughout

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

	* narrowingUnificationProblem.cc: odd -> variableFamily throughout

	* narrowingUnificationProblem.hh (SimpleRootContainer): data member
	odd becomes int variableFamily; updated ctor decls

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

	* narrowingUnificationProblem.cc (classifyVariables): simplified
	to make use of the invariant that variables occuring in a binding
	to an original variable must themselves be unbound (otherwise
	they would have been instiatiated away by PendingUnificationStack)
	(findNextUnifier): removed commented out code

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

2016-05-17  Steven Eker  <eker@install.csl.sri.com>

	* equalityConditionFragment.hh (normalize): added

2016-04-08  Steven Eker  <eker@install.csl.sri.com>

	* unificationProblem.cc (findOrderSortedUnifiers): use
	getCachedPairing()

	* narrowingUnificationProblem.hh (SimpleRootContainer): deleted
	data members order, done, pending; deleted decls for explore(),
	extractUnifier()

	* narrowingUnificationProblem.cc (explore, extractUnifier): deleted

	* narrowingUnificationProblem.hh (SimpleRootContainer): added
	decl for classifyVariables()

	* narrowingUnificationProblem.cc (classifyVariables): added
	(findNextUnifier): use classifyVariables()

	* unificationProblem.cc (bindFreeVariables): added

	* unificationProblem.hh (SimpleRootContainer): added decl for
	bindFredVariables()

	* unificationProblem.cc (findNextUnifier): code cleaning
	(findNextUnifier): re-organization

2016-04-07  Steven Eker  <eker@install.csl.sri.com>

	* narrowingUnificationProblem.hh (SimpleRootContainer): updated comments

	* narrowingUnificationProblem.cc (NarrowingUnificationProblem): code
	cleaning

2016-04-06  Steven Eker  <eker@install.csl.sri.com>

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers): code
	cleaning

	* unificationProblem.cc (findOrderSortedUnifiers): code
	cleaning

2016-04-01  Steven Eker  <eker@install.csl.sri.com>

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers): deleted
	commented out code

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

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers): undo
	last change as it introduced a bug where we were expecting
	identities mappings on other BDD variables
	(findOrderSortedUnifiers): use cached pairing for secondArgToReal
	and explicitly add needed identity mappings

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

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers): use
	cached pairing for realTofirstArg

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

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers):
	use computeGeneralizedSort2()

	* unificationProblem.cc (findOrderSortedUnifiers): use
	computeGeneralizedSort2()

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

2016-02-05  Steven Eker  <eker@install.csl.sri.com>

	* variantSearch.cc (getLastReturnedVariant): pass pointers
	rather than references to
	VariantFolder::getLastReturnedVariant()
	(getNextVariant): pass pointers rather than references to
	VariantFolder::getLastReturnedVariant()

	* variantSearch.hh (getLastReturnedUnifier): removed dummy
	variables now that we've changed interface to
	VariantFolder::getNextSurvivingVariant()

	* variantSearch.cc (getNextUnifier): removed dummy variables
	now that we've changed interface to
	VariantFolder::getNextSurvivingVariant()

	* variantFolder.hh (SimpleRootContainer): updated decls for
	getNextSurvivingVariant() and getLastReturnedVariant()

	* variantFolder.cc (getNextSurvivingVariant): variantNumber,
	parentNumber and moreInLayer are now pointers rather than
	references so that they can be null if the information
	isn't wanted by the caller
	(getLastReturnedVariant): symmetric changes to above, for
	parentNumber and moreInLayer

2016-02-04  Steven Eker  <eker@install.csl.sri.com>

	* variantSearch.hh (getLastReturnedUnifier): pass dummy
	args to VariantFolder::getLastReturnedVariant()

	* variantSearch.cc (getLastReturnedVariant): added Assert()
	to insist that there is actuualy a variant to return

	* variantFolder.cc (getLastReturnedVariant): moved here; no
	longer inline

	* variantSearch.cc (getLastReturnedVariant): moved here; no
	longer inline

	* variantFolder.hh (getLastReturnedVariant): take parentNumber
	and moreInLayer arguments

	* variantSearch.hh (getLastReturnedVariant): take parentIndex
	and moreInLayer args; updated decl for getNextVariant()

	* variantSearch.cc (getNextVariant): return parentIndex and
	moreInLayer

2016-01-28  Steven Eker  <eker@install.csl.sri.com>

	* variantFolder.hh (SimpleRootContainer): updated decl for
	getNextSurvivingVariant()

	* variantFolder.cc (getNextSurvivingVariant): pass back
	variantNumber and variantIndex

	* variantSearch.cc (getNextVariant): use new getNextSurvivingVariant()
	convention; track nrVariantReturned
	(getNextUnifier): use new getNextSurvivingVariant() convention

	* variantSearch.hh (SimpleRootContainer): added data members
	nrVariantsReturned, internalIndexToExternalIndex 

2016-01-22  Steven Eker  <eker@install.csl.sri.com>

	* variantSearch.cc (getNextUnifier, getNextVariant): pass dummy
	argument to getNextSurvivingVariant()

	* variantFolder.hh (SimpleRootContainer): updated decl for
	getNextSurvivingVariant()

	* variantFolder.cc (insertVariant): manage layerNumber field
	(getNextSurvivingVariant): rewritten to check for a next variant in
	the same layer as the one we just found

	* variantFolder.hh (SimpleRootContainer): added layerNumber field to
	struct RetainedVariant

===================================Maude109===========================================

2015-10-16  Steven Eker  <eker@ape.csl.sri.com>

	* unifierFilter.cc (subsumes): symmetric change to below

	* variantFolder.cc (subsumes): allocate at least one slot, but
	clear the correct number of variables (even if it is 0) so that we
	don't get a size mismatch with local substitutions in matching
	automata

===================================Maude108a===========================================

2015-09-17  Steven Eker  <eker@ape.csl.sri.com>

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	fixed nasty bug where we were narrowing with variant equations
	from the wrong component

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers): use
	getRemappedLeqRelation() for fresh variables
	(findOrderSortedUnifiers): use applyLeqRelation() and
	getRemappedLeqRelation() for original variables

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

	* variantSearch.hh (SimpleRootContainer): get rid of default
	values for arguments

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

	* variantSearch.hh (SimpleRootContainer): added data member
	incompleteFlag
	(isIncomplete): added

	* variantSearch.cc (expandVariant): update incompleteFlag
	(VariantSearch): clear incompleteFlag

	* narrowingUnificationProblem.hh (isIncomplete): added

	* variantNarrowingSearchState.hh (PositionState): added data
	member incompleteFlag
	(isIncomplete): added

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	check unification problems for incompleteness and update incompleteFlag
	(VariantNarrowingSearchState): clear incompleteFlag

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

	* unificationProblem.cc: deleted commented out variable order
	stuff

	* unificationProblem.hh (isIncomplete): added
	(SimpleRootContainer): deleted commented out variable order stuff
	that is now done in PendingUnficationStack as part of the cycle
	breaking code

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

2015-02-23  Steven Eker  <eker@ape.csl.sri.com>

	* variantSearch.hh (getLastReturnedVariant)
	(getLastReturnedUnifier): added

	* variantFolder.hh (getLastReturnedVariant): added

===================================Maude107===========================================

2014-11-18  Steven Eker  <eker@ape.csl.sri.com>

	* unificationProblem.cc (UnificationProblem): added
	instrumentation

	* narrowingUnificationProblem.cc (NarrowingUnificationProblem):
	use DebugAdvisory()

===================================Maude106===========================================

2014-08-06  Steven Eker  <eker@ape.csl.sri.com>

	* equalityConditionFragment.hh (ConditionFragment): added decl for
	buildInstances()

	* equalityConditionFragment.cc (buildInstances): added

===================================Maude104===========================================

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

	* variantSearch.cc (VariantSearch): don't initialize
	irredundantMode mode
	(expandLayer): clear both frontiers if we abort

	* variantSearch.hh (SimpleRootContainer): deleted data members
	unifierCollection, irredundantMode, unifierIndex
	(SimpleRootContainer): added data member nrVariantVariables
	(SimpleRootContainer): updated decl for expandLayer()

	* variantSearch.cc (expandVariant): rewritten to place variants
	corresponding to unifiers in the common VariantFolder
	(expandLayer): swap frontiers even if newFrontier empty so we
	don't revisit old frontier
	(getNextUnifier): rewritten to handle combined variant/unifier
	collection
	(VariantSearch): don't rely on expandLayer() return value
	(getNextVariant): don't rely on expandLayer() return value
	(expandLayer): don't return a value

	* variantFolder.cc (RetainedVariant): added comments
	(subsumes): allow comparison of variants of different sizes, with
	instant failure

2014-02-28  Steven Eker  <eker@ape.csl.sri.com>

	* variantSearch.cc (getNextVariant): use irredundantMode flag
	(getNextUnifier): use irredundantMode flag

	* variantSearch.hh (SimpleRootContainer): added data member
	irredundantMode

	* variantSearch.cc (VariantSearch): use expandLayer()
	(getNextVariant): rewritten to be incemental and moved here
	(getNextUnifier): rewritten to be incemental and moved here
	(VariantSearch): no longer call expandLayer() here

	* variantSearch.hh (SimpleRootContainer): added decl
	expandLayer(); decl for expand() becomes expandVariant()

	* variantSearch.cc (expandLayer): added
	(expand): becomes expandVariant(), loses odd arg

	* variantSearch.hh (SimpleRootContainer): added data member odd

	* variantFolder.hh (SimpleRootContainer): deleted data members
	startedExtractingVariants, nextVariant; added data member
	currentVariantIndex

	* variantFolder.cc (getNextSurvivingVariant): rewritten to allow
	variants to be extracted, even though fresh variants may still be
	inserted
	(VariantFolder): init currentVariantIndex; don't init
	startedExtractingVariants

===================================Maude101===========================================

2014-02-06  Steven Eker  <eker@ape.csl.sri.com>

	* variantSearch.cc (expand): #if out debugging code

2013-12-20  Steven Eker  <eker@ape.csl.sri.com>

	* variantNarrowingSearchState.cc (collectUnifiers): wrap
	informational code in #ifndef NO_ASSERT

===================================Maude100a===========================================

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

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers): added
	DebugAdvisory()s to examine the growth of BDD variables

===================================Maude97===========================================

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

	* unificationProblem.cc (findNextUnifier): added Assert() and
	removed "breaking here" comment

	* unificationProblem.hh (SimpleRootContainer): commented out decls
	for extractUnifier() and explore(), and data members order, done
	and pending

	* unificationProblem.cc (extractUnifier, explore): commented out
	(findNextUnifier): commented out call to extractUnifier -
	pendingStack.solve() should do this work as part of cycle
	resolution

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

2012-08-22  Steven Eker  <eker@ape.csl.sri.com>

	* variantFolder.cc (subsumes): call okToCollectGarbage()

	* unifierFilter.cc (subsumes): call okToCollectGarbage()

	* variantNarrowingSearchState.cc (collectUnifiers): can't use
	getDagNode() if we using the built in variant unification
	equations because find next position won't have been called

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

	* variantNarrowingSearchState.cc (collectUnifiers): added code to
	print out message if excessive number of unifiers seen

	* variantSearch.cc (expand): added code to print variants as they
	are added to collection for debugging purposes

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

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	don't clear() zero number of variables

2012-08-07  Steven Eker  <eker@ape.csl.sri.com>

	* narrowingSequenceSearch.cc (findNextNormalForm)
	(NarrowingSequenceSearch): pass odd argument to
	NarrowingSearchState()
	(findNextInterestingState): pass odd argument to NarrowingSearchState()

	* narrowingSearchState.cc (NarrowingSearchState): deal with odd
	argument
	(findNextNarrowing): pass odd to NarrowingUnificationProblem()
	(getNarrowedDag): uncomment code that clears slots between rule
	variables and start of dag variables; use
	getNrProtectedVariables() rather than getNrRealVariables() since
	abstraction variables won't be written over by rhs construction

	* narrowingSearchState.hh (isOdd): added
	(PositionState): updated ctor; added data member odd

	* narrowingSequenceSearch.cc (NarrowingSequenceSearch): rename
	variables in initial state so that they don't clash with variables
	in rules
	(NarrowingSequenceSearch): delete initial

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

	* variantNarrowingSearchState.hh (PositionState): deleted data
	member unificationMode

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	support unfication mode
	(VariantNarrowingSearchState): don't initialize unificationMode

	* narrowingUnificationProblem.hh (SimpleRootContainer): added decl
	for new ctor

	* narrowingUnificationProblem.cc (NarrowingUnificationProblem):
	don't initialize target
	(NarrowingUnificationProblem): added ctor for lhs vs rhs version

	* narrowingUnificationProblem.hh (SimpleRootContainer): deleted
	data member target

	* variantSearch.cc (VariantSearch): code cleaning; no longer count
	notional rewrites

	* variantNarrowingSearchState.cc (findNextVariant): handle virtual
	narrowing step in unification mode

	* variantNarrowingSearchState.hh (PositionState): added decl for
	collectUnifier()

	* variantNarrowingSearchState.cc (collectUnifiers): added
	(VariantNarrowingSearchState): use collectUnifiers

	* variantSearch.cc (expand): pass unificationMode to
	VariantNarrowingSearchState()

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	store unificationMode

	* variantNarrowingSearchState.hh (PositionState): updated ctor decl
	(PositionState): added data member unificationMode

	* variantSearch.hh (SimpleRootContainer): added data member unifierIndex

	* variantSearch.cc (expand): handle null variant terms indicating
	unifiers
	(VariantSearch): initialize unifierIndex

2012-07-27  Steven Eker  <eker@ape.csl.sri.com>

	* variantSearch.cc (VariantSearch): support unificationMode

	* variantSearch.hh (getNextUnifier): added
	(SimpleRootContainer): added data members unificationMode and
	unifierCollection; updated decl for ctor

2012-07-26  Steven Eker  <eker@ape.csl.sri.com>

	* variantNarrowingSearchState.cc (findNextVariant): check
	instantiated block dag to see that it isn't null

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers): use
	variableIndexToSort() (3 places)
	(bindFreeVariables): use findOrderSortedUnifiers()

	* narrowingUnificationProblem.hh (SimpleRootContainer): added data
	member nrPreEquationVariables; added decl for variableIndexToSort()

	* narrowingUnificationProblem.cc (NarrowingUnificationProblem):
	initialize nrPreEquationVariables
	(bindFreeVariables): dispense with local  nrPreEquationVariables
	(findOrderSortedUnifiers): dispense with local
	nrPreEquationVariables
	(extractUnifier): dispense with local  nrPreEquationVariables
	(variableIndexToSort): added

2012-07-20  Steven Eker  <eker@ape.csl.sri.com>

	* variantSearch.cc (expand): fixed bug where we using a local
	blockerDags variable

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

	* variantSearch.cc (VariantSearch): index, normalize, sort and
	check blocker dags

2012-07-18  Steven Eker  <eker@ape.csl.sri.com>

	* variantSearch.cc (VariantSearch): take blockerDags argument
	(markReachableNodes): protect blockerDags

	* variantSearch.hh (SimpleRootContainer): added data member
	blockerDags; update decl for ctor

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	clear blockerSubstitution to ensure any variables that only occur
	in blocker dags are assigned 0

	* variantNarrowingSearchState.hh (PositionState): store a
	reference rather than a shallow copy of variantSubstitution

	* variantNarrowingSearchState.cc (findNextVariant): check for
	blocker dags becoming reducible

	* variantSearch.cc (VariantSearch): try indexing varriables in
	start dag from 0 since everything gets reindexed by
	VariantNarrowingSearchState() anyway
	(expand): pass blockerDags to  VariantNarrowingSearchState()

	* variantNarrowingSearchState.hh (PositionState): added data
	member blockerDags; updated decl for ctor
	(PositionState): added data member blockerSubstitution

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	take blockerDags argument

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

	* variantNarrowingSearchState.hh (PositionState): delete decl for
	reducibleByVariantEquation()

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	code cleaning
	(reducibleByVariantEquation): deleted
	(findNextVariant): use DagNode version of
	reducibleByVariantEquation()
	(VariantNarrowingSearchState): use DagNode version of
	reducibleByVariantEquation()

	* variantNarrowingSearchState.hh (PositionState): removed data
	members firstTargetSlot and nrInterestingVariables

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

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	try doing reducibility check on interesting variables

	* variantNarrowingSearchState.hh (PositionState): added data
	members firstTargetSlot and nrInterestingVariables

	* variantNarrowingSearchState.cc (reducibleByVariantEquation): use
	isIrreducibleByVariantEquations() and
	setIrreducibleByVariantEquations()
	(findNextVariant): try checking bindings to interesting variables
	for reducibility first

	* variantFolder.cc (RetainedVariant): changed comment on call to
	normalize()

	* unifierFilter.cc (~UnifierFilter): RetainedUniferList replaces
	RetainedUnifierMultimap
	(markReachableNodes): RetainedUniferList replaces
	RetainedUnifierMultimap; fix loop variable masking issue
	(insertUnifier): RetainedUniferList replaces
	RetainedUnifierMultimap
	(getNextSurvivingUnifier): RetainedUniferList replaces
	RetainedUnifierMultimap
	(RetainedUnifier): changed comment on call to normalize()

	* unifierFilter.hh (SimpleRootContainer): added positionIndex to
	struct RetainedUnifier; RetainedUnifierMultimap becomes
	RetainedUniferList

2012-07-10  Steven Eker  <eker@ape.csl.sri.com>

	* narrowingSearchState.cc (getNarrowedDag): use new
	rebuildAndInstantiateDag() return value

	* variantNarrowingSearchState.cc (findNextVariant): use new
	rebuildAndInstantiateDag() return value

	* positionState.hh (P): updated decl for
	rebuildAndInstantiateDag()

	* positionState.cc (rebuildAndInstantiateDag): don't both
	returning replacement because it can't change - we don't support
	extension for narrowing

	* narrowingUnificationProblem.hh (SimpleRootContainer): updated
	decl for findOrderSortedUnifiers()

	* narrowingUnificationProblem.cc (findNextUnifier): use
	bindFreeVariables()
	(findOrderSortedUnifiers): removed commented out code
	(findOrderSortedUnifiers): now return bool
	(findNextUnifier): rewritten

	* narrowingUnificationProblem.hh (SimpleRootContainer): added decl
	for bindFreeVariables()

	* narrowingUnificationProblem.cc (bindFreeVariables): added

2012-07-09  Steven Eker  <eker@ape.csl.sri.com>

	* narrowingUnificationProblem.cc (NarrowingUnificationProblem):
	pass odd argument to UnificationContext

2012-07-06  Steven Eker  <eker@ape.csl.sri.com>

	* variantNarrowingSearchState.cc (findNextVariant): clear slots in
	unifier that might have been trample by rhs construction

	* variantSearch.cc (expand): newFrontier is now a VariantIndexVec
	(VariantSearch): frontier is now a VariantIndexVec

	* variantSearch.hh (SimpleRootContainer): replace VariantIndexSet
	with VariantIndexVec

	* variantSearch.cc (expand): hack to trace expansion of variants

	* variantFolder.cc (getNextSurvivingVariant): hack to trace
	parentage of variants

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

	* unifierFilter.hh (SimpleRootContainer): deleted commented out code

	* unifierFilter.cc (RetainedUnifier): code cleaning and add comments
	(subsumes): code cleaning

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	fix bug where we were passing the wrong number of interesting
	variables to UnificationFilter (but this should only be an
	efficiency issue)
	(VariantNarrowingSearchState): code cleaning; fix comments

	* variantSearch.hh (SimpleRootContainer): updated decl for
	getContext(); ifdef'd decl for dumpVariant()

	* variantSearch.cc (VariantSearch): code cleaning; fix out of date comments
	(markReachableNodes): remove commented out code; added comment
	(expand): code cleaning and fix comments
	(dumpVariant): ifdef'd

2012-05-31  Steven Eker  <eker@ape.csl.sri.com>

	* variantFolder.cc (RetainedVariant): compile dags in reverse order
	(subsumes): match dags in reverse order

	* narrowingUnificationProblem.hh (SimpleRootContainer): added data
	member sortConstrainedVariables

	* narrowingUnificationProblem.cc (extractUnifier): don't call
	explore() on unbound variables
	(explore): fill out sortConstraintVariables
	(extractUnifier): clear sortConstrainedVariables
	(findOrderSortedUnifiers): only assign BDD variables to sort
	constrained free variables rather than all free variables
	(findNextUnifier): don't do BDD lookup for free variables which
	are not sort constrained

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	only variable occuring in the term part of the variant being
	narrowing are considered to be interesting for unifier filtering
	purposes

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

	* variantFolder.hh (SimpleRootContainer): updated decl for subsumes()

	* variantFolder.cc (subsumes): fix performance bug where we were
	passing the variant by copy rather than by reference

===================================Maude96a===========================================

2012-05-23  Steven Eker  <eker@ape.csl.sri.com>

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	need to delete unificationProblem after we're done with it

2012-05-22  Steven Eker  <eker@ape.csl.sri.com>

	* unifierFilter.hh (SimpleRootContainer): commented out previous changes

	* unifierFilter.cc (insertUnifier): commented out previous changes
	(getNextSurvivingUnifier): commented out previous changes

	* variantNarrowingSearchState.cc (findNextVariant)
	(VariantNarrowingSearchState): commented out previous changes

	* variantNarrowingSearchState.hh (PositionState): commented out
	previous decl change

	* variantSearch.hh (getNextVariant): pass back nrFreeVariables

	* variantSearch.cc (expand): commented out nrFreeVariables change
	(VariantSearch): check for unsafe variable names

	* variantFolder.hh (SimpleRootContainer): updated decl for
	getNextSurvivingVariant()

	* variantFolder.cc (RetainedVariant): fill out nrFreeVariables
	(getNextSurvivingVariant): return nrFreeVariables

	* variantNarrowingSearchState.hh (PositionState): updated decl for
	findNextVariant()

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	pass nrFreeVariables to  insertUnifier()
	(findNextVariant): get nrFreeVariables from
	getNextSurvivingUnifier()

	* unifierFilter.hh (SimpleRootContainer): add nrFreeVariables to
	struct RetainedUnifier; updated decls for insertUnifier() and
	getNextSurvivingUnifier()

	* unifierFilter.cc (getNextSurvivingUnifier): return nrFreeVariables
	(insertUnifier): store nrFreeVariables

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

	* narrowingSequenceSearch.cc (findNextNormalForm): check for abort
	after reducing; use incrementNarrowingCount() and addInCount()

	* variantSearch.hh (SimpleRootContainer): derive from CacheableState

	* higher.hh: added classes UnifierFilter,
	VariantNarrowingSearchState, VariantSearch, VariantFolder

	* variantSearch.hh (SimpleRootContainer): adde decl for dtor

	* variantSearch.cc (~NarrowingSequenceSearch): added

	* variantSearch.hh (getNextVariant): check for traceAbort()
	(getContext): added

	* variantSearch.cc (VariantSearch): repostition traceAbort() test

	* variantNarrowingSearchState.cc (findNextVariant): call
	incrementVariantNarrowingCount()

	* variantSearch.cc (markReachableNodes): don't protect
	VariableDagNodes in variableInfo now that we notice they
	will be reachable from original dag which itself is protected

	* variantNarrowingSearchState.cc (findNextVariant): pass
	originalVariables to traceVariantNarrowingStep()

	* variantNarrowingSearchState.hh (PositionState): updated decl for
	ctor; added data member originalVariables

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	take extra argument and initialize originalVariables

	* variantSearch.cc (expand): add in subcontext counts
	(VariantSearch): delete redContext; add in count from redContext
	(expand): pass variableInfo to VariantNarrowingSearchState ctor

2012-05-18  Steven Eker  <eker@ape.csl.sri.com>

	* variantNarrowingSearchState.cc (findNextVariant): add tracing

2012-05-17  Steven Eker  <eker@ape.csl.sri.com>

	* variantSearch.cc (VariantSearch): reduce initial term after
	rather than before replacement of variables with fresh variables;
	this fixes a bug where reduction was introducing new ground terms
	without their ground flags set which broke instantiation.
	(VariantSearch): check for abort

	* variantNarrowingSearchState.cc (reducibleByVariantEquation): fix
	multiple problems with the deletion of subproblems

2012-05-11  Steven Eker  <eker@ape.csl.sri.com>

	* variantSearch.hh (SimpleRootContainer): added data member
	protectedVariant

	* variantSearch.cc (expand): use protectedVariant to avoid
	substitution part of new variant being garbage collected when term
	part is reduced

	* variantSearch.hh (V): updated decl for expand()
	(SimpleRootContainer): inherit from SimpleRootContainer
	(SimpleRootContainer): added decl for markReachableNodes()

	* variantSearch.cc (expand): handle odd flag and pass it to
	VariantNarrowingSearchState
	(VariantSearch): maintain odd flag and pass it to expand()

	* variantNarrowingSearchState.hh (PositionState): updated decl for ctor

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	pass odd flag to NarrowingUnificationProblem()

	* narrowingUnificationProblem.cc (NarrowingUnificationProblem):
	handle odd flag
	(findNextUnifier): pass odd flag to getFreshVariableName

	* narrowingUnificationProblem.hh (SimpleRootContainer): added odd
	ctor argument and data member

	* narrowingUnificationProblem.cc (findNextUnifier): removed
	commented out call to freshVariableGenerator->reset();

	* variantNarrowingSearchState.cc (reducibleByVariantEquation):
	delete subproblems

	* variantSearch.cc (VariantSearch): handle the case where
	instantiate() returns null

2012-05-10  Steven Eker  <eker@ape.csl.sri.com>

	* variantNarrowingSearchState.cc (findNextVariant): fix bug where
	we were not handling null returned by instantiate()

	* variantSearch.cc: added

	* variantSearch.hh: added

2012-05-09  Steven Eker  <eker@ape.csl.sri.com>

	* variantFolder.cc: created

	* variantFolder.hh: created

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

	* variantNarrowingSearchState.cc (findNextVariant): use
	reducibleByVariantEquation()
	(findNextVariant): normalize and compute sorts for instantiated
	substition before checking for reducibility

	* variantNarrowingSearchState.hh (PositionState): added decl for
	reducibleByVariantEquation()

	* variantNarrowingSearchState.cc (reducibleByVariantEquation):
	added

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

	* variantNarrowingSearchState.cc (VariantNarrowingSearchState):
	only use equations with the variant attribute
	(VariantNarrowingSearchState): use equations indexed under symbol
	for stable symbols

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

	* unifierFilter.cc (subsumes): don't create zero size
	substitutions as this breaks stuff

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

	* unificationProblem.cc (UnificationProblem): use
	getNrRealVariables() rather than getNrProtectedVariables() - more
	a cleanliness issue here
	(findNextUnifier): ditto
	(findOrderSortedUnifiers): ditto
	(extractUnifier): dirrot

	* narrowingUnificationProblem.cc (findNextUnifier): use
	getNrRealVariables() rather than getNrProtectedVariables(); this
	fixes a nasty problem that we were treating slots introduced for
	purposes such as variable abstraction during matching as real
	variables in the preEquation being used for narrowing, resulting
	in memory corruption
	(extractUnifier): ditto
	(findOrderSortedUnifiers): ditto

	* narrowingSearchState.cc (getNarrowedDag): don't clear slots used
	by rhsBuilder - unification code should never look at these

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

	* unifierFilter.hh (SimpleRootContainer): updated decl for getNextSurvivingUnifier()

	* unifierFilter.cc (getNextSurvivingUnifier): remove const from unifier

	* variantNarrowingSearchState.hh: created

	* variantNarrowingSearchState.cc: created

	* positionState.hh (P): updated decl for rebuildAndInstantiateDag()

	* positionState.cc (rebuildAndInstantiateDag): turned CantHappen()
	into an Assert()
	(rebuildAndInstantiateDag): take PositionIndex

	* unifierFilter.cc (getNextSurvivingUnifier): moved here

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

	* unifierFilter.cc: rewritten

	* unifierFilter.hh (SimpleRootContainer): rewritten to index
	retained unifiers by positionIndex and to store equationIndex

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

	* narrowingUnificationProblem.hh: updated comment to reflect
	change below

	* narrowingUnificationProblem.cc (findNextUnifier): rewritten so
	that we don't modify previously generated unifiers to make new
	unifiers

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

	* narrowingSearchState.cc (getNarrowedDag): new
	rebuildAndInstantiateDag() calling convention

	* positionState.hh (P): updated decl for rebuildAndInstantiateDag()

	* positionState.cc (rebuildAndInstantiateDag): rewritten to take
	an eager copy of the part the substitution we will use if
	there is any instatiation going to happen

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

	* unifierFilter.hh: created

	* unifierFilter.cc: created

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

	* narrowingUnificationProblem.hh (SimpleRootContainer): switched
	rule for preEquation

	* narrowingUnificationProblem.cc: switched rule for preEquation
	thoughout file

	* pattern.hh (PreEquation): adde decl for print()

	* pattern.cc (print): added

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

2011-01-06  Steven Eker  <eker@rho>

	* unificationProblem.cc
	(UnificationProblem::findOrderSortedUnifiers): simplifed
	constraining free fresh variables by using
	getRemappedLeqRelation()
	(UnificationProblem::findOrderSortedUnifiers): simplified
	constraining of free original variable using
	getRemappedLeqRelation()
	(UnificationProblem::findOrderSortedUnifiers): simplied
	constraining of bound original variables using applyLeqRelation()
	(UnificationProblem::findOrderSortedUnifiers): removed a
	DebugAdvisory() since leqRelation does have a meaningful value at
	this point

===================================Maude95c===========================================

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

	* pattern.cc (Pattern::Pattern): call setModuleInfo() to set null
	info so we can identify PreEquations that don't belong to modules

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

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

	* modelCheckerSymbol.cc (SystemAutomaton::checkProposition): reverted

	* satSolverSymbol.cc: reverted

	* satSolverSymbol.hh (class SatSolverSymbol): reverted

	* temporalSymbol.cc (TemporalSymbol::build): reverted - we need
	proposition indices to be contiguous which is not guaranteed by
	HashConsSet

	* temporalSymbol.hh (class TemporalSymbol): reverted

	* modelCheckerSymbol.cc (SystemAutomaton::checkProposition): use
	HashConsSet

	* modelCheckerSymbol.hh (class ModelCheckerSymbol): DagNodeSet ->
	HashConsSet

	* satSolverSymbol.cc (SatSolverSymbol::eqRewrite)
	(SatSolverSymbol::makeModel, SatSolverSymbol::makeFormulaList)
	(SatSolverSymbol::makeFormula): use HashConsSet

	* satSolverSymbol.hh (class SatSolverSymbol): DagNodeSet ->
	HashConsSet

	* temporalSymbol.cc (TemporalSymbol::build): simplified using
	HashConsSet

	* temporalSymbol.hh (class TemporalSymbol): DagNodeSet -> HashConsSet

	* stateTransitionGraph.cc (StateTransitionGraph::markReachableNodes): deleted

	* stateTransitionGraph.hh (class StateTransitionGraph): remove
	derivation from SimpleRootContainer
	(class StateTransitionGraph): deleted decl for
	markReachableNodes()

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

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

	* unificationProblem.cc (UnificationProblem::findNextUnifier): use
	solve()

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

	* unificationProblem.cc (UnificationProblem::findNextUnifier): use
	solve2(); don't use extractUnifier()

2010-05-21  Steven Eker  <eker@rho>

	* rewriteConditionState.hh (class RewriteConditionState): use
	StateTransitionGraph in place of StateTransitionGraph3

	* stateTransitionGraph3.cc: deleted

	* stateTransitionGraph3.hh: deleted

	* rewriteSequenceSearch.cc
	(RewriteSequenceSearch::RewriteSequenceSearch): removed mention of
	StateTransitionGraph3

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch): removed
	mention of StateTransitionGraph3

	* modelCheckerSymbol.cc: use StateTransitionGraph in place of
	StateTransistionGraph3 throughout

	* modelCheckerSymbol.hh (class ModelCheckerSymbol): use
	StateTransitionGraph in place of StateTransistionGraph3

===================================Maude94===========================================

2010-04-01  Steven Eker  <eker@rho>

	* unificationProblem.cc (UnificationProblem::markReachableNodes):
	deleted commented out unsortedSolution marking code

	* narrowingUnificationProblem.cc
	(NarrowingUnificationProblem::markReachableNodes): deleted
	commented out unsortedSolution marking code

	* narrowingSearchState.cc
	(NarrowingSearchState::findNextNarrowing): don't pass
	extensionInfo to NarrowingUnificationProblem()

	* narrowingUnificationProblem.hh (class
	NarrowingUnificationProblem): updated ctor decl; deleted
	extensionInfo data member; deleted subproblem commented out data
	member

	* narrowingUnificationProblem.cc
	(NarrowingUnificationProblem::NarrowingUnificationProblem):
	deleted commented out subproblem and extension unification code
	(~NarrowingUnificationProblem): deleted commented out subproblem
	code
	(NarrowingUnificationProblem::findNextUnifier): deleted commented
	out subproblem code
	(NarrowingUnificationProblem::NarrowingUnificationProblem):
	deleted extensionInfo argument

	* unificationProblem.cc (UnificationProblem::UnificationProblem):
	remove withExtension arg
	(UnificationProblem::UnificationProblem): deleted commented out
	subproblem code
	(UnificationProblem::findNextUnifier): ditto

	* unificationProblem.hh (class UnificationProblem): remove
	withExtension arg from ctor

	* unificationProblem.cc (UnificationProblem::UnificationProblem):
	deleted extension handling code
	(~UnificationProblem): don't delete extensionInfo
	(UnificationProblem::makeContext): deleted

	* unificationProblem.hh (class UnificationProblem): deleted decls
	for makeContext(), getExtensionInfo(), getLeftHandSides(); deleted
	data member extensionInfo and commented out data member subproblem
	(UnificationProblem::getExtensionInfo, Vector): deleted

===================================Maude93a===========================================

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

	* stateTransitionGraph.cc (getNextState): pass SET_UNREWRITABLE
	and SET_UNSTACKABLE flags

	* rewriteSearchState.cc (RewriteSearchState): don't pass
	SET_UNSTACKABLE flag

	* rewriteSearchState.hh (class RewriteSearchState): added
	SET_UNREWRITABLE to enum Flags

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

	* rewriteSearchState.cc (RewriteSearchState): pass SET_UNSTACKABLE
	flag

	* positionState.cc (PositionState): make sure we have
	SET_UNSTACKABLE set without also setting RESPECT_FROZEN
	(exploreNextPosition): handle SET_UNSTACKABLE

	* positionState.hh (class PositionState): added SET_UNSTACKABLE to
	Flags

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

	* rewriteSearchState.cc (findNextRewrite): use
	setUnrewritable()/isUnrewritable()

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

	* stateTransitionGraph3.cc (getNextState): fix symmetric bug where
	we weren't allowing garbage collection

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

	* stateTransitionGraph.cc (getNextState): allow garbage collection
	in the success case

2009-11-25  Steven Eker  <eker@goo.csl.sri.com>

	* stateTransitionGraph.cc: created

	* higher.hh: added class StateTransitionGraph

2009-11-24  Steven Eker  <eker@goo.csl.sri.com>

	* stateTransitionGraph.hh: created

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

2009-11-06  Steven Eker  <eker@goo.csl.sri.com>

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers):
	constrain free fresh variables to have sort indices in valid range

	* unificationProblem.cc (findOrderSortedUnifiers): move
	constraints on free fresh variables to after the BDD variables
	have been allocate, using a separate loop

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

	* unificationProblem.cc (findOrderSortedUnifiers): fix a critical
	bug in the algorithm - notion of a sort index being valid cannot
	be carried through generalized sort computations, and therefore
	for free variables that are also fresh variables, and won't
	otherwise be constrained, additional constraints must be added to
	ensure they only range over valid sort indices

2009-09-23  Steven Eker  <eker@goo.csl.sri.com>

	* unificationProblem.cc (findOrderSortedUnifiers): added
	DebugAdvisory() to investigate the BDD variable bug

===================================Maude92a===========================================

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

	* narrowingUnificationProblem.cc (findOrderSortedUnifiers): use &
	rather that /\ in comment to avoid multi-line comment warning
	(findOrderSortedUnifiers): delete nrFreeVariable
	(findNextUnifier): added #if NO_ASSERT to avoid compiler warning
	(2 places)

	* unificationProblem.cc (findOrderSortedUnifiers): use & rather
	that /\ in comment to avoid multi-line comment warning
	(findNextUnifier): added #if NO_ASSERT to avoid compiler warning
	(2 places)

===================================Maude91a===========================================

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

	* unificationProblem.cc (UnificationProblem): change variable name
	warning

===================================Maude91===========================================

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

	* narrowingUnificationProblem.cc (markReachableNodes): symmetric
	with below

	* unificationProblem.cc (markReachableNodes): comment out
	unsortedSolution now that UnificationContext handles this

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

	* narrowingUnificationProblem.cc (findNextUnifier): use
	pendingStack rather than subproblem

	* narrowingUnificationProblem.hh (class
	NarrowingUnificationProblem): pendingStack replaces subproblem

	* narrowingUnificationProblem.cc (NarrowingUnificationProblem):
	use new computeSolvedForm() convention

	* unificationProblem.hh (class UnificationProblem): pendingStack
	replaces subproblem

	* unificationProblem.cc (UnificationProblem): use new
	computeSolvedForm() convention
	(findNextUnifier): use pendingStack rather than subproblem

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

	* narrowingSequenceSearch.cc (NarrowingSequenceSearch): handle
	narrowingFlags arg
	(NarrowingSequenceSearch, findNextNormalForm) 
	(findNextInterestingState): pass narrowingFlags to
	NarrowingSearchState()

	* narrowingSequenceSearch.hh (class NarrowingSequenceSearch):
	added data member narrowing flags; updated decl for ctor

	* narrowingSearchState.cc (NarrowingSearchState): initialize
	noFurtherPositions
	(findNextNarrowing): support SINGLE_POSITION flag

	* narrowingSearchState.hh (class NarrowingSearchState): added
	SINGLE_POSITION flag
	(class NarrowingSearchState): added data member noFurtherPositions

	* narrowingSequenceSearch.cc (findNextNormalForm): use new
	getNarrowedDag() and traceNarrowingStep() conventions
	(findNextInterestingState): ditto

	* narrowingSearchState.hh (class NarrowingSearchState): updated
	decl for getNarrowedDag()

	* narrowingSearchState.cc (getNarrowedDag): return replacement via
	a reference arg

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

	* narrowingSequenceSearch.cc (findNextInterestingState): support tracing
	(findNextNormalForm): support tracing

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

	* narrowingSearchState.hh (getVariableInfo): added

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

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

	* narrowingSequenceSearch.hh (getVariableCounter) 
	(setVariableCounter): deleted
	(getVariableTotalForPreviouslyReturnedStates): added

	* narrowingSequenceSearch.cc (findNextMatch): do variableTotal
	accounting
	(NarrowingSequenceSearch): clear
	variableTotalForPreviouslyReturnedStates and
	variableTotalForAllReturnedStates

	* narrowingSequenceSearch.hh (class NarrowingSequenceSearch):
	deleted data member variableCounter

	* narrowingSearchState.hh (getNrOfVariablesInSubject): added

	* narrowingSearchState.cc (NarrowingSearchState): comment out
	whole info loop

	* narrowingSequenceSearch.hh (getStateDag): use stateStack and
	getContext() in place of contextStack()

	* narrowingSearchState.hh (getContext): added

	* narrowingSequenceSearch.hh (class NarrowingSequenceSearch):
	deleted data member context stack
	(getContext): added Assert() to protect against empty stack

	* narrowingSequenceSearch.cc (NarrowingSequenceSearch): don't use
	contextStack
	(NarrowingSequenceSearch): don't delete stuff from contextStack
	(findNextNormalForm, findNextInterestingState): don't use
	contextStack

	* narrowingSearchState.hh (class NarrowingSearchState): added data
	member context

	* narrowingSearchState.cc (NarrowingSearchState): save context
	(NarrowingSearchState): delete context

	* narrowingSequenceSearch.cc (findNextInterestingState): fix bug
	where we weren't deleting state and context afte during
	backtracking

	* narrowingSearchState.cc (findNextNarrowing): fix bug where we
	weren't deleting a UnificationProblem after it fails to provide
	another solution

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

	* narrowingSequenceSearch.hh (getFreshVariableGenerator): added
	(class NarrowingSequenceSearch): added data member variableCounter
	(getVariableCounter, setVariableCounter): added

	* narrowingSequenceSearch.cc (findNextMatch): handle null goal

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

	* higher.hh: added class CacheableState

	* searchState.hh (class SearchState): derive from CacheableState

	* sequenceSearch.hh: derive from CacheableState

	* unificationProblem.hh (class UnificationProblem): derive from
	CacheableState

	* cacheableState.hh: created

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

	* narrowingSearchState.cc (findNextNarrowing): pass 0 as
	extensionInfo to NarrowingUnificationProblem()

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

	* sortTestConditionFragment.cc (check): allow for the case that
	normalize() deletes the original term due to collapse

	* rewriteConditionFragment.cc (check): allow for the case that
	normalize() deletes the original term due to collapse

	* assignmentConditionFragment.cc (check): allow for the case that
	normalize() deletes the original term due to collapse

	* equalityConditionFragment.cc (check): allow for the case that
	normalize() deletes the original term due to collapse

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

	* narrowingSequenceSearch.cc (findNextMatch): use getStateDag()

	* narrowingSequenceSearch.hh (getContext): added
	(getStateDag): added

	* higher.hh: added class SequenceSearch

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch): derive
	from SequenceSearch

	* narrowingSequenceSearch.hh (class NarrowingSequenceSearch):
	derive from SequenceSearch

	* sequenceSearch.hh (class SequenceSearch): created

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

	* narrowingSearchState.hh (class NarrowingSearchState): added decl
	for ~NarrowingSearchState()

	* narrowingSearchState.cc (~NarrowingSearchState): added

	* narrowingSequenceSearch.cc (~NarrowingSequenceSearch): delete
	any pending states and contexts on the stacks
	(~NarrowingSequenceSearch): delete freshVariableGenerator

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

	* narrowingSequenceSearch.cc (findNextNormalForm): use seenSet
	(NarrowingSequenceSearch): initialize seenSet
	(findNextInterestingState): use seenSet
	(findNextNormalForm): falsify topOfStackFresh after detecting a
	dup

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

	* narrowingSequenceSearch.hh (class NarrowingSequenceSearch):
	added data member seenSet

	* narrowingSequenceSearch.cc (findNextMatch): call
	findNextNormalForm() from here
	(findNextInterestingState): don't call findNextNormalForm() from
	here

	* narrowingSequenceSearch.hh (class NarrowingSequenceSearch):
	replace firstCall flag with topOfStackFresh flag

	* narrowingSequenceSearch.cc (findNextNormalForm): handle maxDepth
	(findNextNormalForm): reorganized
	(findNextNormalForm): simplified; get rid of firstCall flag
	(NarrowingSequenceSearch): initialize topOfStackFresh flag

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

	* narrowingSequenceSearch.cc (NarrowingSequenceSearch): initialize
	firstCall

	* narrowingSequenceSearch.hh (class NarrowingSequenceSearch):
	added decl for findNextNormalForm(); added data member firstCall

	* narrowingSequenceSearch.cc (findNextNormalForm): added

	* narrowingSequenceSearch.hh (class NarrowingSequenceSearch):
	deleted data member reachingInitialStateOK

	* narrowingSequenceSearch.cc (NarrowingSequenceSearch): don't
	initialize reachingInitialStateOK

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

	* narrowingSearchState.hh (class NarrowingSearchState): pass
	ALLOW_NONEXEC as default flags argument

2007-10-31  Steven Eker  <eker@goo.csl.sri.com>

	* narrowingSequenceSearch.cc (findNextInterestingState): handle
	maxDepth == NONE
	(findNextInterestingState): handle trying of initial state

2007-10-30  Steven Eker  <eker@goo.csl.sri.com>

	* narrowingSequenceSearch.cc (findNextInterestingState): use
	contextStack
	(findNextMatch): use contextStack
	(NarrowingSequenceSearch): initialize contextStack
	(findNextInterestingState): start backtracking if current depth reached.

	* narrowingSequenceSearch.hh (class NarrowingSequenceSearch):
	added data member contextStack

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

	* narrowingSequenceSearch.hh: created

	* narrowingSequenceSearch.cc: created

	* rewriteSequenceSearch.hh: #define _rewriteSequenceSearchState_hh_
	becomes _rewriteSequenceSearch_hh_

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

	* positionState.hh (class PositionState): added decl for
	rebuildAndInstantiateDag()

	* positionState.cc (rebuildAndInstantiateDag): added

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

	* narrowingSearchState.cc (findNextNarrowing): pass extension info
	to NarrowingUnificationProblem()

2007-10-17  Steven Eker  <eker@goo.csl.sri.com>

	* higher.hh: added classes NarrowingUnificationProblem and
	NarrowingSearchState

	* narrowingSearchState.cc (getSubstitution): added
	(findNextNarrowing): implemented

	* narrowingSearchState.hh (class NarrowingSearchState): added data
	member unificationProblem; added decl for getSubstitution()

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

	* narrowingSearchState.hh (class NarrowingSearchState): added data
	member variableInfo

	* narrowingSearchState.cc: created
	(NarrowingSearchState): use variableInfo

	* narrowingSearchState.hh: created

	* narrowingUnificationProblem.cc: created

	* narrowingUnificationProblem.hh: created

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

	* unificationProblem.cc (UnificationProblem): use data member variableInfo
	(findNextUnifier): use variableInfo
	(findOrderSortedUnifiers): use variableInfo
	(extractUnifier): use variableInfo

	* unificationProblem.hh (class UnificationProblem): added many
	commments
	(getVariableInfo): added
	(class UnificationProblem): made VariableInfo base class private
	(class UnificationProblem): made VariableInfo a data member rather
	than a base class

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

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

	* unificationProblem.cc (~UnificationProblem): varsOK ->
	problemOkay
	(UnificationProblem): varsOK -> problemOkay
	(UnificationProblem): check for unimplemented theories

	* unificationProblem.hh (variablesOK): becomes problemOK
	(class UnificationProblem): varsOK becomes problemOkay

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

	* unificationProblem.cc (UnificationProblem): fix bug where we
	were failing but leaving old subproblem ptr around for a double
	deletion

===================================Maude89e===========================================

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

	* unificationProblem.cc (findOrderSortedUnifiers): fix bug where
	we were not telling the BDD package about the BDD variables we
	allocate to represent the sorts of real variables

===================================Maude89d===========================================

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

	* unificationProblem.cc (UnificationProblem): fix bug where we
	we're initializing subproblem in the case that we returned early

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

	* unificationProblem.cc (UnificationProblem): pass extensionInfo

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

	* unificationProblem.cc (~UnificationProblem): delete
	extensionInfo

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

	* unificationProblem.hh (class UnificationProblem): added decl for
	makeContext()
	(class UnificationProblem): added data member extensionInfo
	(getLeftHandSides): added
	(getExtensionInfo): added

	* unificationProblem.cc (UnificationProblem): added withExtension
	arg (but not implementation yet)
	(makeContext): added

	* unificationProblem.hh (class UnificationProblem): added
	withExtension arg to ctor

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

	* unificationProblem.hh (class UnificationProblem): updated decl
	for ctor
	(class UnificationProblem): added data members leftHandDags,
	rightHandDags, leftHandSides, rightHandSides; deleted data members
	lhs, rhs, lhsDag, rhsDag

	* unificationProblem.cc (~UnificationProblem): fix memory leak
	where we weren't deleting terms if variables weren't ok
	(UnificationProblem): rewritten to do simultaneous unification
	(~UnificationProblem): destruct vectors of terms
	(markReachableNodes): mark vectors of dags

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

	* unificationProblem.hh (variablesOK): added
	(class UnificationProblem): added data member varsOK

	* unificationProblem.cc (UnificationProblem): check variable names
	for safety
	(UnificationProblem): don't delete uninitialized pointers if
	variables names are not OK

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

	* unificationProblem.cc (UnificationProblem): removed
	lastVariableIndex argument
	(findOrderSortedUnifiers): don't use lastVariableIndex

	* unificationProblem.hh (class UnificationProblem): updated ctor decl
	(class UnificationProblem): removed lastVariableIndex data member

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

	* unificationProblem.cc (UnificationProblem): handle
	lastVariableIndex arg
	(findOrderSortedUnifiers): use lastVariableIndex

===================================Maude89c===========================================

2007-04-19  Steven Eker  <eker@goo.csl.sri.com>

	* unificationProblem.cc (UnificationProblem): fix bug where
	subproblem was not being initialized in failure case with
	resulting memory corruption in dtor

===================================Maude89b===========================================

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

	* unificationProblem.cc (UnificationProblem): removed support for
	Robinson style unification
	(findNextUnifier): removed support for Robinson style unification

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

	* unificationProblem.cc (UnificationProblem): need to delete
	subproblem

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

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

	* unificationProblem.cc (UnificationProblem): don't call
	Substitution::notify(); make sortedSolution a specific size
	(findOrderSortedUnifiers): use actual variables rather than
	original variables to determine the number of free variables
	(extractUnifier): nrRealVariables -> nrOriginalVariables
	(findOrderSortedUnifiers): use acutal variables rather than
	original variables when binding free variables to fresh variables
	(findOrderSortedUnifiers): use getFreshVariableSort() to get the
	sort of fresh variables so we know how many BDD variables to
	allocate them
	(findOrderSortedUnifiers): same fix in two other places
	(UnificationProblem): don't use Substitution::clear() since we may
	have a large subsitution than has been notified
	(markReachableNodes): split marking of sortedSolution and
	unsortedSolution for safety
	(UnificationProblem): zero sortedSolution to prevent barfing on GC

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

	* unificationProblem.cc (findNextUnifier): don't call
	FreshVariableGenerator::reset()
	(findOrderSortedUnifiers): new FreshVariableGenerator semantics

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

	* unificationProblem.hh (class UnificationProblem):
	unsortedSolution becomes a UnificationContext*

	* unificationProblem.cc (findNextUnifier): use unificationSolve()
	(UnificationProblem): use UnificationContext
	(markReachableNodes): mark lhsDag and unsortedSolution

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

	* unificationProblem.cc (extractUnifier): need to bind unsortedSolution

	* unificationProblem.hh (class UnificationProblem): decl for
	extractUnifier() replaces decl for orderVariables()

	* unificationProblem.cc (orderVariables): becomes extractUnifier()
	(findNextUnifier, UnificationProblem): support solved form

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

	* unificationProblem.cc (findNextUnifier): fix bug in that we are
	not looking for another unsorted solution if our current unsorted
	solution fails to have at least on sorted solution

	* unificationProblem.hh (class UnificationProblem): added data
	members order, done and pending
	(class UnificationProblem): added decls for orderVariables() and
	explore()

	* unificationProblem.cc (orderVariables): added
	(explore): added

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

	* unificationProblem.cc (UnificationProblem): added solved form
	hack for experimentation

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

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

	* unificationProblem.cc (findOrderSortedUnifiers): use
	sortedSolution
	(~UnificationProblem): delete sortedSolution
	(markReachableNodes): use sortedSolution
	(findNextUnifier): use sortedSolution
	(UnificationProblem): call Substitution::notify()

	* unificationProblem.hh (class UnificationProblem): removed
	Substitution as a base class
	(class UnificationProblem): added data member sortedSolution
	(getSolution): added

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

	* unificationProblem.cc (findNextUnifier): use reset()

	* unificationProblem.hh (class UnificationProblem): added reset
	function to class FreshVariableGenerator

	* unificationProblem.cc (findOrderSortedUnifiers): only do the
	instantiation step if we actually have free variables

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

	* unificationProblem.cc (findNextUnifier): second call to solve()
	needs to have false flag
	(findOrderSortedUnifiers): clear free variables from previous
	unsorted unifier

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

	* unificationProblem.cc (markReachableNodes): no need to mark
	unsortedSolution now that it is a RewritingContext

	* unificationProblem.hh (class UnificationProblem): added data
	member unsortedSolution

	* unificationProblem.cc (findOrderSortedUnifiers): clone
	unsortedSolution
	(findNextUnifier): handle looking for solutions to subproblems
	(markReachableNodes): mark unsortedSolution
	(UnificationProblem): build solution in unsortedSolution; don't
	call findOrderSortedUnifiers()

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

	* unificationProblem.cc (UnificationProblem): use
	computeBaseSortForGroundSubterms()
	(findOrderSortedUnifiers): use DagNode version of
	computeGeneralizedSort()

===================================Maude88e===========================================

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

	* unificationProblem.cc (~UnificationProblem): delete
	freshVariableGenerator
	(findOrderSortedUnifiers, findNextUnifier): use
	freshVariableGenerator as a ptr rather than as a ref
	(UnificationProblem): take freshVariableGenerator as a ptr rather
	than as a ref

	* unificationProblem.hh (class UnificationProblem): added virtual
	dtor to FreshVariableGenerator; freshVariableGenerator now passed
	as a ptr
	(class UnificationProblem): freshVariableGenerator data member now
	a ptr

	* higher.hh: added class UnificationProblem

	* unificationProblem.cc: moved here

	* unificationProblem.hh: moved here

===================================Maude88d===========================================

2006-11-14  Steven Eker  <eker@goo.csl.sri.com>

	* rewriteSequenceSearch.cc (findNextInterestingState): rewritten
	to use new flags and to allow cycles to the initial state in the
	=>1 and =>+ cases

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch): deleted
	data member searchType; added data members reachingInitialStateOK
	and normalFormNeeded

	* rewriteSequenceSearch.cc (RewriteSequenceSearch): don't save
	searchType; initialize reachingInitialStateOK and normalFormNeeded

===================================Maude88c===========================================

2006-11-09  Steven Eker  <eker@goo.csl.sri.com>

	* equalityConditionFragment.cc (solve): comment out state variable

	* sortTestConditionFragment.cc (solve): comment out state variable

2006-11-06  Steven Eker  <eker@goo.csl.sri.com>

	* assignmentConditionFragment.cc (makeRhsInstance): take
	Substitution& rather than RewritingContext&

	* assignmentConditionFragment.hh (class
	AssignmentConditionFragment): updated decl for makeRhsInstance()

	* rewriteConditionFragment.hh (class RewriteConditionFragment):
	updated decl for makeLhsInstance()

	* rewriteConditionFragment.cc (makeLhsInstance): take
	Substitution& rather than RewritingContext&

2006-10-30  Steven Eker  <eker@goo.csl.sri.com>

	* rewriteConditionFragment.cc (makeLhsInstance): added
	(matchRoot): added

	* rewriteConditionFragment.hh (class RewriteConditionFragment):
	added decls for makeLhsInstance() and matchRoot()

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

	* stateTransitionGraph3.cc (getNextState): fix trace bug using new
	rebuildDag() semantics

	* positionState.cc (rebuildDag): now return DagPair

	* positionState.hh (class PositionState): added typedef DagPair;
	both rebuildDag() functions now return DagPair

2006-10-25  Steven Eker  <eker@goo.csl.sri.com>

	* positionState.hh (getDagNode): added PositionIndex version

2006-10-23  Steven Eker  <eker@goo.csl.sri.com>

	* assignmentConditionFragment.cc (makeRhsInstance, matchRoot):
	moved here

2006-10-20  Steven Eker  <eker@goo.csl.sri.com>

	* assignmentConditionFragment.hh (matchRoot): added
	(makeRhsInstance): added

2006-10-18  Steven Eker  <eker@goo.csl.sri.com>

	* equalityConditionFragment.cc (dump): added

	* equalityConditionFragment.hh (class EqualityConditionFragment):
	added decl for dump()

===================================Maude88b===========================================

2006-10-05  Steven Eker  <eker@goo.csl.sri.com>

	* searchState.cc (findFirstSolution): check that pattern and
	subject are in the same component

2006-09-29  Steven Eker  <eker@goo.csl.sri.com>

	* positionState.hh (rebuildDag): added simplified version
	(getPositionIndex): added
	(class PositionState): added typedef for PositionIndex

	* positionState.cc (rebuildDag): rewritten to take external
	extension info and position index

2006-09-25  Steven Eker  <eker@goo.csl.sri.com>

	* searchState.cc (hasCondition): added
	(findNextSolution): use local version of hasCondition()
	(findFirstSolution): use local version of hasCondition()
	(hasCondition): use getFlags()

	* searchState.hh (class SearchState): added decl for
	hasCondition()

	* rewriteSearchState.hh (class RewriteSearchState): renumbered
	ALLOW_NONEXEC in enum Flags

	* matchSearchState.hh (class MatchSearchState): renumbered
	GC_PATTERN in enum Flags

	* searchState.hh (class SearchState): added IGNORE_CONDITION to
	enum Flags

2006-09-14  Steven Eker  <eker@goo.csl.sri.com>

	* positionState.hh (class PositionState): added explanation of
	maxDepth edge cases

===================================Maude88a===========================================

2006-04-05  Steven Eker  <eker@goo.csl.sri.com>

	* rewriteSearchState.hh (class RewriteSearchState): add default
	label arg for ctor

	* rewriteSequenceSearch.cc: fix comment

===================================Maude87a===========================================

2003-11-06  Steven Eker  <eker@goo.csl.sri.com>

	* satSolverSymbol.cc (attachData): use NULL_DATA()
	(getDataAttachments): added
	(getSymbolAttachments): added
	(getTermAttachments): added

	* satSolverSymbol.hh (class SatSolverSymbol): added decls for
	getDataAttachments(), getSymbolAttachments(), getTermAttachments()

	* modelCheckerSymbol.cc (attachData): use NULL_DATA()
	(getDataAttachments): added
	(getSymbolAttachments): added
	(getTermAttachments): added

	* modelCheckerSymbol.hh (class ModelCheckerSymbol): added decls
	for getDataAttachments(), getSymbolAttachments(),
	getTermAttachments()

	* temporalSymbol.cc (getSymbolAttachments): added

	* temporalSymbol.hh (class TemporalSymbol): added decl for
	getSymbolAttachments()

2003-07-14  Steven Eker  <eker@goo.csl.sri.com>

	* temporalSymbol.cc (build): TRUE -> LTL_TRUE, FALSE -> LTL_FALSE

===================================Maude81===========================================

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

	* rewriteSearchState.cc (findNextRewrite): use isNonexec()

	* rewriteSearchState.hh (class RewriteSearchState): added enum
	Flags containing ALLOW_NONEXEC

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

	* positionState.hh (getExtensionInfo): no longer const

	* positionState.cc (PositionState): init extensionInfoValid
	(findNextPosition): don't call makeExtensionInfo() here; set
	extensionInfoValid false if we're working with extension

	* positionState.hh (class PositionState): added data member
	extensionInfoValid
	(getExtensionInfo): call makeExtensionInfo() on demand

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

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

	* equalityConditionFragment.cc (preprocess): updated Assert()

	* assignmentConditionFragment.cc (preprocess): updated Assert()

	* rewriteSearchState.cc: removed #pragma

	* rewriteSearchState.hh: removed #pragma

	* temporalSymbol.cc: removed #pragma

	* temporalSymbol.hh: removed #pragma

	* stateTransitionGraph3.cc: removed #pragma

	* stateTransitionGraph3.hh: removed #pragma

	* sortTestConditionFragment.cc: removed #pragma
	(preprocess): updated Assert()

	* sortTestConditionFragment.hh: removed #pragma

	* searchState.cc: removed #pragma

	* searchState.hh: removed #pragma

	* satSolverSymbol.cc: removed #pragma
	(eqRewrite): updated Assert()
	(makeFormula): updated Assert()s

	* satSolverSymbol.hh: removed #pragma

	* rewriteSequenceSearch.cc: removed #pragma

	* rewriteSequenceSearch.hh: removed #pragma

	* rewriteConditionState.cc: removed #pragma

	* rewriteConditionState.hh: removed #pragma

	* rewriteConditionFragment.cc: removed #pragma
	(preprocess): updated Assert()

	* rewriteConditionFragment.hh: removed #pragma

	* positionState.cc: removed #pragma

	* positionState.hh: removed #pragma
	(getDagNode): updated Assert()
	(getExtensionInfo): updated Assert()

	* pattern.cc: removed #pragma

	* pattern.hh: removed #pragma

	* modelCheckerSymbol.cc: removed #pragma
	(eqRewrite): updated Assert()

	* modelCheckerSymbol.hh: removed #pragma

	* matchSearchState.cc: removed #pragma

	* matchSearchState.hh: removed #pragma

	* equalityConditionFragment.cc: removed #pragma

	* equalityConditionFragment.hh: removed #pragma

	* assignmentConditionState.cc: removed #pragma

	* assignmentConditionState.hh: removed #pragma

	* assignmentConditionFragment.cc: removed #pragma

	* assignmentConditionFragment.hh: removed #pragma

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

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

	* modelCheckerSymbol.hh (class ModelCheckerSymbol): parentSymbol
	-> satisfiesSymbol in struct SystemAutomaton; added data member
	satisfiesSymbol

	* modelCheckerSymbol.cc (ModelCheckerSymbol): clear
	satisfiesSymbol
	(attachSymbol): handle satisfiesSymbol
	(copyAttachments): handle satisfiesSymbol
	(checkProposition): removed hacks that were needed because same
	symbol was used for model checking and satisfaction
	(checkProposition): use satisfiesSymbol
	(eqRewrite): use satisfiesSymbol

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

2002-11-25  Steven Eker  <eker@goo.csl.sri.com>

	* positionState.cc (PositionState): switch initializer order to
	placate g++3.2

2002-11-15  Steven Eker  <eker@goo.csl.sri.com>

	* modelCheckerSymbol.cc (eqRewrite): use new style IssueAdvisory()

	* satSolverSymbol.cc (eqRewrite): use new style IssueAdvisory()

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

	* positionState.cc (exploreNextPosition): pass respectFrozen arg
	to stackArguments()

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

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

	* sortTestConditionFragment.cc (compileBuild): call useIndex() on
	lhsIndex; don't set nrIndicesToProtect

	* sortTestConditionFragment.hh (class SortTestConditionFragment):
	deleted data member nrIndicesToProtect

	* rewriteConditionFragment.cc (compileBuild): call useIndex() on
	lhsIndex; don't set nrIndicesToProtect

	* rewriteConditionFragment.hh (class RewriteConditionFragment):
	deleted data member nrIndicesToProtect

	* equalityConditionFragment.cc (compileBuild): don't set
	nrIndicesToProtect

	* equalityConditionFragment.hh (class EqualityConditionFragment):
	deleted data member nrIndicesToProtect

	* assignmentConditionFragment.hh (class
	AssignmentConditionFragment): deleted data member
	nrIndicesToProtect

	* assignmentConditionFragment.cc (compileBuild): call useIndex()
	on rhsIndex, since we are now changing who is responsible for
	caling useIndex()
	(compileBuild): don't set nrIndicesToProtect

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

	* equalityConditionFragment.cc (compileBuild): fixed nasty bug
	introduced by the coloring of constrcution indices: we need to
	call useIndex() to stop lhsIndex and rhsIndex from being shared
	via index coloring

===================================Maude75==================================================

2002-06-12  Steven Eker  <eker@goo.csl.sri.com>

	* pattern.cc (Pattern): pass NONE as PreEquation() label arg
	(Pattern): withExtensionconst -> withExtension (dunno how
	withExtensionconst ever came about!)

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

	* sortTestConditionFragment.cc (check): simplified normalize()
	call

	* rewriteConditionFragment.cc (check): simplified normalize()
	call (2 places)

	* equalityConditionFragment.cc (check): simplified normalize()
	call (2 places)

	* assignmentConditionFragment.cc (check): simplified normalize()
	call (2 places)

	* modelCheckerSymbol.cc (makeTransition): simplified now that
	makeDagNode() takes a default argument

===================================Maude71a==================================================

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

	* modelCheckerSymbol.cc (eqRewrite): use pluralize() in Verbose()
	call

	* satSolverSymbol.cc (postInterSymbolPass): call
	TemporalSymbol::postInterSymbolPass();
	(eqRewrite): fix mistake in advisory - we don't compute negation
	here
	(eqRewrite): added Verbose()

	* modelCheckerSymbol.cc (eqRewrite): findCounterExample() ->
	findCounterexample()

	* modelCheckerSymbol.hh (class ModelCheckerSymbol):
	makeCounterExample() -> makeCounterexample()
	counterExampleSymbol -> counterexampleSymbol

	* higher.hh: ModelSymbol -> ModelCheckerSymbol

	* modelCheckerSymbol.cc: was modelSymbol.cc

	* modelSymbol.cc: ModelSymbol -> ModelCheckerSymbol
	(ModelCheckerSymbol): counterExampleSymbol -> counterexampleSymbol
	(attachSymbol): counterExampleSymbol -> counterexampleSymbol
	(copyAttachments): counterExampleSymbol -> counterexampleSymbol
	(makeCounterExample): counterExampleSymbol -> counterexampleSymbol
	(attachSymbol): don't bind LTL symbols
	(copyAttachments): don't copy LTL symbols
	(checkProposition): FreeSymbol -> TemporalSymbol
	(attachData): FreeSymbol -> TemporalSymbol
	(attachSymbol): FreeSymbol -> TemporalSymbol
	(attachTerm): FreeSymbol -> TemporalSymbol
	(copyAttachments): FreeSymbol -> TemporalSymbol
	(reset): FreeSymbol -> TemporalSymbol
	(build): deleted
	(ModelCheckerSymbol): don't initialize LTL symbols
	(postInterSymbolPass): call TemporalSymbol::postInterSymbolPass()
	(makeCounterExample): becomes makeCounterexample()
	(eqRewrite): makeCounterExample() -> makeCounterexample()
	(eqRewrite): use negate()
	(eqRewrite): use safeCast()

	* modelCheckerSymbol.hh: ModelSymbol -> ModelCheckerSymbol
	(class ModelCheckerSymbol): derive from TemporalSymbol rather than
	FreeSymbol
	(class ModelCheckerSymbol): removed all the LTL Symbo, data members
	(class ModelCheckerSymbol): delete decl for build()
	(class ModelCheckerSymbol): counterExampleSymbol ->
	counterexampleSymbol

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

	* temporalSymbol.cc (conjunct): rewritten since andSymbol may not
	be assoc and therefore we can only pass 2 args at a time to
	makeDagNode()

	* satSolverSymbol.cc (makeFormula): added
	(makeFormulaList): use makeFormula()

	* temporalSymbol.cc (conjunct): added

	* temporalSymbol.hh: added decl for conjunct()

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

	* higher.hh: added fwd decls for class TemporalSymbol and class
	SatSolverSymbol

	* satSolverSymbol.cc: created

	* temporalSymbol.cc: created

	* temporalSymbol.hh: created

	* satSolverSymbol.hh: created

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

	* rewriteConditionState.cc (solve): use transferCount() for
	StateTransitionGraph3

	* stateTransitionGraph3.hh (transferCount): added

	* rewriteSequenceSearch.cc (findNextMatch): use transferCount() in
	place of addInCount() for MatchSearchState

	* stateTransitionGraph3.cc (getNextState): use transferCount() in
	place of addInCount() for RewriteSearchState

	* rewriteSearchState.cc (findNextRewrite): don't call clearCount()

	* matchSearchState.cc (findNextMatch): don't call clearCount()

	* searchState.hh (transferCount): added

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

	* rewriteConditionState.hh (class RewriteConditionState): updated
	data members

	* rewriteConditionState.cc (findNextState): simplified
	(RewriteConditionState): new initialization

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

	* higher.hh: added forward decls for new classes

	* rewriteConditionState.cc: created

	* rewriteConditionState.hh: created

	* rewriteConditionFragment.cc (solve): replaced stub with
	implementation

	* assignmentConditionFragment.cc (solve): use
	AssignmentConditionState 

	* assignmentConditionState.cc: created

	* assignmentConditionState.hh: created

	* rewriteConditionFragment.hh: created

	* rewriteConditionFragment.cc: created

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

	* assignmentConditionFragment.hh: created

	* assignmentConditionFragment.cc: created

	* sortTestConditionFragment.hh: created

	* sortTestConditionFragment.cc: created

	* equalityConditionFragment.hh: created

	* equalityConditionFragment.cc: created

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

	* modelSymbol.cc (ModelSymbol): deleted strategy argument passed
	to FreeSymbol()

	* modelSymbol.hh (class ModelSymbol): deleted static data member
	eagerStrategy

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

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

	* modelSymbol.cc (eqRewrite): fixed a nasty bug where we were
	deleting newContext to early; this left proposition dags that may
	have been copied by a collapse equation unprotected from the
	garbage collector and caused havoc when testing propositions;
	the bug must have been introduced by code cleaning since Alpha68

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

	* modelSymbol.cc (eqRewrite): Added Verbose() call to print number
	of system states examined

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

	* rewriteSequenceSearch.cc (findNextInterestingState): yet another
	rewrite: we now avoid examining more than one arc from each
	maximum depth state if we are looking for normal forms - the
	existence of a single state means we don't have a normal form and
	since we are at max depth we will not explore children
	(RewriteSequenceSearch): handle ONE_STEP by setting maxDepth = 1

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch):
	nextIndex -> nextArc

	* rewriteSequenceSearch.cc (findNextInterestingState): rewritten
	to return exactly those states we should try matching against;
	nextIndex -> nextArc throughout

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch): added
	data member needToTryInitialState

	* rewriteSequenceSearch.cc (RewriteSequenceSearch): added maxDepth
	arg, init maxDepth, exploreDepth, firstDeeperNodeNr
	(findNextMatch): rewritten, assuming smarter findNextInterestingState()

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch): added
	data members maxDepth, exploreDepth, firstDeeperNodeNr; add
	maxDepth arg to ctor decl

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

	* rewriteSequenceSearch.cc (findNextMatch): add rewrites from
	matchState to initial rewriting context
	(findNextInterestingState): check for traceAbort() when we fail to
	find a next arc from current explore state

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch): updated decls

	* rewriteSequenceSearch.cc (findNextInterestingState): added
	(findNextMatch): rewritten using findNextInterestingState()
	(findNextMatch): don't use startMatch()
	(startMatch): deleted
	(RewriteSequenceSearch): don't use startMatch()

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

	* rewriteSequenceSearch.cc: complete rewrite based on StateTransitionGraph3

	* rewriteSequenceSearch.hh: complete rewrite based on StateTransitionGraph3

	* stateTransitionGraph3.hh (getContext): added
	(getStateParent): added

	* modelSymbol.cc (eqRewrite): check for bad LTL formula

	* stateTransitionGraph3.hh (getStateFwdArcs): added

	* modelSymbol.cc (makeCounterExample): pass last target to
	makeTransitionList()
	(makeTransitionList): pass target to makeTransition()
	(makeTransition): include label in transition
	(build): check that formula under LogicFormula::NOT is a proposition

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

	* modelSymbol.cc (makeCounterExample): use makeTransitionList()

	* modelSymbol.hh (class ModelSymbol): updated decls; changed data
	members to symbols need for new style counter-examples

	* modelSymbol.cc (ModelSymbol): handle symbols for new style
	counter-examples
	(attachSymbol): handle symbols for new style counter-examples
	(copyAttachments): handle symbols for new style counter-examples
	(makeStateList): becomes makeTransitionList()
	(makeTransitionList): added

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

	* modelSymbol.cc: use StateTransitionGraph3 throughout

	* modelSymbol.hh (class ModelSymbol): use StateTransitionGraph3

	* stateTransitionGraph3.cc: created

	* stateTransitionGraph3.hh: created

2001-12-21  Steven Eker  <eker@goo.csl.sri.com>

	* modelSymbol.hh (class ModelSymbol): use StateTransitionGraph2

	* stateTransitionGraph2.hh: created

	* stateTransitionGraph2.cc: created

2001-12-19  Steven Eker  <eker@goo.csl.sri.com>

	* positionState.hh (class PositionState): use NO_COPYING() macro

	* searchState.hh (class SearchState): updated decl for initSubstitution()

	* searchState.cc (initSubstitution): made arg const VariableInfo&

	* searchState.hh (class SearchState): updated decl for
	findFirstSolution(), made data member preEquation, const PreEquation*

	* searchState.cc (findFirstSolution): make first arg const PreEquation*

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

	* modelChecker.cc: deleted

	* modelChecker.hh: deleted

	* modelSymbol.cc: cleaned up includes

	* modelSymbol.hh: cleaned up includes; delete class LogicFormula
	hack

===================================Maude69==================================================

2001-12-06  Steven Eker  <eker@goo.csl.sri.com>

	* stateTransitionGraph.cc (getNextState): use addInCount() and
	clearCount() to move rewrites counts from reducing new states to
	initil rewriting context

	* modelSymbol.cc (check): commented out
	(checkProposition): add in test rewrite count to parent rewrite count

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

	* modelSymbol.hh (class ModelSymbol): added data members
	stateListSymbol, nilStateListSymbol, counterExampleSymbol; added
	decls for makeStateList() and makeCounterExample()

	* modelSymbol.cc (ModelSymbol): handle stateListSymbol,
	nilStateListSymbol and counterExampleSymbol
	(attachSymbol): handle stateListSymbol, nilStateListSymbol and
	counterExampleSymbol
	(copyAttachments): handle stateListSymbol, nilStateListSymbol and
	counterExampleSymbol
	(makeStateList): added
	(makeCounterExample): added
	(eqRewrite): use makeCounterExample()

	* modelSymbol.hh (class ModelSymbol): added decl for dump()

	* modelSymbol.cc (dump): added
	(eqRewrite): use getLeadIn(), getCycle()

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

	* modelSymbol.cc (getNextState): added
	(checkProposition): added
	(eqRewrite): rewritten using ModelChecker2

	* modelSymbol.hh (class ModelSymbol): added struct SystemAutomaton

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

	* modelChecker.cc (explorePropertyTransitions): use BuchiAutomaton2
	(explorePropertyTransitions): fixed nasty state ref bug to
	intersectionStates - stale after call to
	exploreSystemTransitions() beacuse intersectionStates vector may expand

	* modelChecker.hh (class ModelChecker): use BuchiAutomaton2

	* modelChecker.cc (findCounterExample): deal with multiple initial states

2001-11-27  Steven Eker  <eker@goo.csl.sri.com>

	* modelSymbol.cc (eqRewrite): added hack to test BuchiAutomaton2

2001-11-14  Steven Eker  <eker@goo.csl.sri.com>

	* modelSymbol.cc (eqRewrite): added hack to test GenBuchiAutomaton
	class

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

	* modelSymbol.cc (eqRewrite): added hack to test
	VeryWeakAlternatingAutomaton class

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

	* modelSymbol.cc (check): fixed nasty bug where we were not
	deleting testContext; this is more than a memory leak since we
	keep dag roots that point to dagNodes whose symbol pointers can
	become stale when a module is deleted, leading to seg faults and
	bus error in the mark pahse of garbage collection
	(eqRewrite): fixed similar bug with newContext; note that
	sysContext will be deleted by ModelChecker via
	StateTransitionGraph

2001-10-24  Steven Eker  <eker@goo.csl.sri.com>

	* modelChecker.cc (findCounterExample): need to make
	intersectionStates of length 1 before starting
	(exploreSystemTransitions): need to increase size of
	intersectionStates if we find a new state;
	(exploreSystemTransitions): added code to fake a loop transition
	if we arrive a a dealocked system state (no other transitions
	available)

	* modelSymbol.cc (eqRewrite): use the ModelChecker class to do the
	model check
	(check): call index2DagNode()

2001-10-23  Steven Eker  <eker@goo.csl.sri.com>

	* modelSymbol.hh (class ModelSymbol): added decls for
	attachTerm(), postInterSymbolPass() and reset(); added data
	members trueTerm and falseTerm

	* modelSymbol.cc (postInterSymbolPass): added
	(copyAttachments): copy trueTerm and falseTerm
	(attachTerm): added
	(reset): added

	* modelChecker.cc (explorePropertyTransitions): look for accepting
	cycles; handle returning bool
	(exploreSystemTransitions): handle returning bool

2001-10-22  Steven Eker  <eker@goo.csl.sri.com>

	* modelChecker.hh (class ModelChecker): added decls for
	explorePropertyTransitions() and exploreSystemTransitions()
	(class ModelChecker): added typedef StatePair and data member
	searchStack

	* modelChecker.cc (explorePropertyTransitions): created
	(exploreSystemTransitions): created

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

	* modelChecker.hh: rewritten

	* modelChecker.cc: created

2001-09-28  Steven Eker  <eker@goo.csl.sri.com>

	* modelSymbol.hh (class ModelSymbol): updated decl for build()

	* modelSymbol.cc (build): convert propositions to indices before
	inserting them into LogicFormula
	(eqRewrite): pass propositions set to build()

===================================Maude68==================================================

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

	* rewriteSequenceSearch.cc (RewriteSequenceSearch): need to make a
	new ArcMap for initial node of search graph
	(findNextMatch): fixed bug where we were eclipsing data member
	stateNr by a local variable and thus getting uninitialized memory
	reads

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

	* rewriteSequenceSearch.cc (findNextMatch): rewritten
	(~RewriteSequenceSearch): delete fwdArcs

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch): deleted
	fwdRules field, made fwdArcs a map<int, set<Rule*> >*
	(getStateFwdRules): deleted

	* rewriteSequenceSearch.cc (findNextMatch): keep track of forward
	arcs and their rules

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch): added
	fwdArcs and fwdRules fields to struct State
	(getStateFwdArcs): added
	(getStateFwdRules): added

2001-06-22  Steven Eker  <eker@goo.csl.sri.com>

	* buchiAutomaton.cc (dump): dump accepting sets

	* buchiAutomaton.hh (class BuchiAutomaton): added decls for
	findUntilSubformulae(), findAcceptingStates(); deleted decls for
	SI(), SI_Neg(), containsNegation()

	* buchiAutomaton.cc (contradiction): use structuallyContradicts()
	instead if SI_Neg()
	(redundant): added LTL2AUT optimization
	(SI_Neg): deleted
	(SI): deleted
	(containsNegation): deleted
	(findUntilSubformulae): added
	(findAcceptingStates): added
	(BuchiAutomaton): do accepting states calculation

	* logicFormula.cc (isNegation): rewritten

2001-06-21  Steven Eker  <eker@goo.csl.sri.com>

	* logicFormula.hh (class LogicFormula): added decls for
	structuallyImplies(), structuallyContradicts(), containsNegation()
	and isNegation()

	* logicFormula.cc (isNegation): added
	(containsNegation): added
	(structuallyContradicts): added
	(structuallyImplies): added

2001-06-20  Steven Eker  <eker@goo.csl.sri.com>

	* buchiAutomaton.cc (contradiction): use SI_Neg()
	(hasToBeStored): return false always
	(SI_Neg): fixed bug in TRUE case

	* buchiAutomaton.hh (class BuchiAutomaton): added decl for SI_Neg()

	* buchiAutomaton.cc (SI_Neg): added

	* buchiAutomaton.hh (class BuchiAutomaton): added decls for add(),
	SI(), containsNegation()

	* buchiAutomaton.cc (cover): use approach similar to published
	algorithm to avoid re-covering subformulae; added Assert() to
	check that we do it correctly
	(add): added
	(SI): added
	(containsNegation): added

2001-06-19  Steven Eker  <eker@goo.csl.sri.com>

	* buchiAutomaton.cc (cover): quick hack to check if we've found to
	cause of the extra states.

2001-06-18  Steven Eker  <eker@goo.csl.sri.com>

	* buchiAutomaton.cc (contradiction): implemented
	(BuchiAutomaton): do breadth-first search
	(contradiction): fixed bugs in PROPOSITION case: need to examine
	upto _and_ including max and we need to check that covered
	actually contains i

2001-06-15  Steven Eker  <eker@goo.csl.sri.com>

	* buchiAutomaton.hh: complete rewrite

	* buchiAutomaton.cc: complete rewrite using Daniele, Giunchilia &
	Vardi approach

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

	* buchiAutomaton.hh (class BuchiAutomaton): added decls for dump()
	and dumpNatSet()

	* buchiAutomaton.cc (dump): added
	(dumpNatSet): added

	* logicFormula.cc (dump): added

	* modelSymbol.hh (class ModelSymbol): added decl for build()

	* buchiAutomaton.cc (BuchiAutomaton): call expand()

	* modelSymbol.cc (build): added

2001-06-05  Steven Eker  <eker@goo.csl.sri.com>

	* modelSymbol.cc (attachData): added

	* higher.hh: added forward decl for class ModelSymbol

	* modelSymbol.hh: created

	* modelSymbol.cc: created

	* higher.hh: added forward decls for classes LogicFormula,
	BuchiAutomaton and StateTransitionGraph

	* buchiAutomaton.cc: created

	* buchiAutomaton.hh: created

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

	* rewriteSequenceSearch.cc (findNextMatch): crude support for
	tracing and traceAbort()

2001-05-10  Steven Eker  <eker@goo.csl.sri.com>

	* rewriteSequenceSearch.hh (getStateNr): added
	(getStateParent): added
	(getStateDag): added

	* rewriteSequenceSearch.cc (RewriteSequenceSearch): use new
	definition of seen
	(~RewriteSequenceSearch): use new definition of seen
	(findNextMatch): store parent states and rules used

	* rewriteSequenceSearch.hh (class RewriteSequenceSearch): added
	struct State

	* rewriteSequenceSearch.cc (findNextMatch): set stateNt whenever
	we create a new matchState

	* rewriteSequenceSearch.hh (getStateNr): added stateNr
	(class RewriteSequenceSearch): added data member 

	* positionState.hh (class PositionState): fixed a nasty bug where
	flags was a bool rather than an int

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

	* rewriteSequenceSearch.hh (getNrStates): added

	* rewriteSequenceSearch.cc: created

	* rewriteSequenceSearch.hh: created

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

	* searchState.cc (initSubstitution): if there is no substition,
	check that the set of unbound variables is empty

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

	* rewriteSearchState.hh (class RewriteSearchState): updated ctor
	decl

	* rewriteSearchState.cc (RewriteSearchState): handle flags arg

	* matchSearchState.cc (MatchSearchState): take and pass flags arg
	(~MatchSearchState): delete pattern only if flag set

	* matchSearchState.hh (class MatchSearchState): added enum Flags;
	added flags arg to ctor

	* searchState.hh (class SearchState): added enum Flags

	* searchState.cc (SearchState): take flags arg rather than
	respectFrozen arg
	(~SearchState): delete substitution and context only if flags set

	* searchState.hh (class SearchState): flags replace respectFrozen
	in ctor decl

	* positionState.cc (PositionState): take flags arg rather than
	respectFrozen arg
	(exploreNextPosition): test flags rather than respectFrozen

	* positionState.hh (class PositionState): delete respectFrozen
	data member; added enum Flags and flags data member; added flags
	arg to ctor decl
	(getFlags): added
