public override bool CanResolve(Mention.MentionContext mention)
 {
     string firstToken = mention.FirstTokenText.ToLower();
     string firstTokenTag = mention.FirstToken.SyntacticType;
     bool canResolve = mention.HeadTokenTag == "NN" && !IsDefiniteArticle(firstToken, firstTokenTag);
     return canResolve;
 }

 /// <summary>
 /// Creates a new entity based on the specified mention and its specified gender and number properties.
 /// </summary>
 /// <param name="mention">
 /// The first mention of this entity.
 /// </param>
 /// <param name="gender">
 /// The gender of this entity.
 /// </param>
 /// <param name="genderProbability">
 /// The probability that the specified gender is correct.
 /// </param>
 /// <param name="number">
 /// The number for this entity.
 /// </param>
 /// <param name="numberProbability">
 /// The probability that the specified number is correct.
 /// </param>
 public DiscourseEntity(Mention.MentionContext mention, Similarity.GenderEnum gender, double genderProbability, Similarity.NumberEnum number, double numberProbability)
     : base(mention)
 {
     mGender = gender;
     mGenderProbability = genderProbability;
     mNumber = number;
     mNumberProbability = numberProbability;
 }

        public override bool CanResolve(Mention.MentionContext mention)
		{
			string firstToken = mention.FirstTokenText.ToLower();
			string firstTokenTag = mention.FirstToken.SyntacticType;
			bool canResolve = mention.HeadTokenTag == PartsOfSpeech.NounSingularOrMass 
                && !IsDefiniteArticle(firstToken, firstTokenTag);
			return canResolve;
		}

 public virtual double GetNonReferentialProbability(Mention.MentionContext mention)
 {
     List<string> features = GetFeatures(mention);
     double probability = mModel.Evaluate(features.ToArray())[mNonReferentialIndex];
     if (mDebugOn)
     {
         System.Console.Error.WriteLine(this + " " + mention.ToText() + " ->  null " + probability + " " + string.Join(",", features.ToArray()));
     }
     return probability;
 }

        protected internal override List<string> GetFeatures(Mention.MentionContext mention, DiscourseEntity entity)
        {
            List<string> features = base.GetFeatures(mention, entity);

            if (entity != null)
            {
                features.AddRange(GetContextFeatures(mention));
                features.AddRange(GetStringMatchFeatures(mention, entity));
            }
            return features;
        }

		protected internal override bool IsExcluded(Mention.MentionContext entityContext, DiscourseEntity discourseEntity)
		{
			if (base.IsExcluded(entityContext, discourseEntity))
			{
				return true;
			}
			else
			{
                Mention.MentionContext currentEntityContext = discourseEntity.LastExtent;
				return (!CanResolve(currentEntityContext) || base.IsExcluded(entityContext, discourseEntity));
			}
		}

 public virtual void AddEvent(Mention.MentionContext context)
 {
     List<string> features = GetFeatures(context);
     if (context.Id == -1)
     {
         mEvents.Add(new SharpEntropy.TrainingEvent(MaximumEntropyResolver.Same, features.ToArray()));
     }
     else
     {
         mEvents.Add(new SharpEntropy.TrainingEvent(MaximumEntropyResolver.Diff, features.ToArray()));
     }
 }

        private void Initialize(Mention.IHeadFinder headFinder)
		{
            Mention.IParse head = headFinder.GetLastHead(Parse);
			List<Mention.IParse> tokenList = head.Tokens;
			this.HeadTokenIndex = headFinder.GetHeadIndex(head);
            Mention.IParse headToken = headFinder.GetHeadToken(head);
            _tokens = tokenList.ToArray();
			this.HeadTokenTag = headToken.SyntacticType;
			this.HeadTokenText = headToken.ToString();
			if (PartsOfSpeech.IsNoun(this.HeadTokenTag) && !PartsOfSpeech.IsProperNoun(this.HeadTokenTag))
			{
				this.Synsets = GetSynsetSet(this);
			}
			else
			{
				this.Synsets = new Util.HashSet<string>();
			}
		}

 /// <summary>
 /// Determines if the specified entity is too far from the specified mention to be resolved to it.  
 /// Once an entity has been determined to be out of range subsequent entities are not considered.
 /// </summary>
 /// <seealso cref="IsExcluded">
 /// </seealso>
 /// <param name="mention">
 /// The mention which is being considered.
 /// </param>
 /// <param name="entity">
 /// The entity to which the mention is to be resolved.
 /// </param>
 /// <returns>
 /// true is the entity is in range of the mention, false otherwise.
 /// </returns>
 protected internal virtual bool IsOutOfRange(Mention.MentionContext mention, DiscourseEntity entity)
 {
     return false;
 }

 /// <summary>
 /// Returns the text of the head word for the specified mention.
 /// </summary>
 /// <param name="mention">
 /// The mention.
 /// </param>
 /// <returns>
 /// The text of the head word for the specified mention.
 /// </returns>
 protected internal virtual string GetHeadString(Mention.MentionContext mention)
 {
     return mention.HeadTokenText.ToLower();
 }

 /// <summary>
 /// Returns the head parse for the specified mention.
 /// </summary>
 /// <param name="mention">
 /// The mention.
 /// </param>
 /// <returns>
 /// the head parse for the specified mention.
 /// </returns>
 protected internal virtual Mention.IParse GetHead(Mention.MentionContext mention)
 {
     return mention.HeadTokenParse;
 }

 public virtual DiscourseEntity Retain(Mention.MentionContext mention, DiscourseModel discourseModel)
 {
     int entityIndex = 0;
     if (mention.Id == - 1)
     {
         return null;
     }
     for (; entityIndex < discourseModel.EntityCount; entityIndex++)
     {
         DiscourseEntity currentDiscourseEntity = discourseModel.GetEntity(entityIndex);
         Mention.MentionContext candidateExtentContext = currentDiscourseEntity.LastExtent;
         if (candidateExtentContext.Id == mention.Id)
         {
             Distances.Add(entityIndex);
             return currentDiscourseEntity;
         }
     }
     //System.err.println("AbstractResolver.Retain: non-referring entity with id: "+ec.toText()+" id="+ec.id);
     return null;
 }

 public abstract bool CanResolve(Mention.MentionContext mention);

 /// <summary>
 /// Returns features indicating whether the specified mention and the specified entity are compatible.
 /// </summary>
 /// <param name="mention">
 /// The mention.
 /// </param>
 /// <param name="entity">
 /// The entity.
 /// </param>
 /// <returns> 
 /// list of features indicating whether the specified mention and the specified entity are compatible.
 /// </returns>
 private List<string> GetCompatibilityFeatures(Mention.MentionContext mention, DiscourseEntity entity)
 {
     List<string> compatibilityFeatures = new List<string>();
     string semanticCompatibilityFeature = GetSemanticCompatibilityFeature(mention, entity);
     compatibilityFeatures.Add(semanticCompatibilityFeature);
     string genderCompatibilityFeature = GetGenderCompatibilityFeature(mention, entity);
     compatibilityFeatures.Add(genderCompatibilityFeature);
     string numberCompatibilityFeature = GetNumberCompatibilityFeature(mention, entity);
     compatibilityFeatures.Add(numberCompatibilityFeature);
     if (semanticCompatibilityFeature == mSimilarityCompatible && genderCompatibilityFeature == mGenderCompatible && numberCompatibilityFeature == mNumberCompatible)
     {
         compatibilityFeatures.Add("all.compatible");
     }
     else if (semanticCompatibilityFeature == mSimilarityIncompatible || genderCompatibilityFeature == mGenderIncompatible || numberCompatibilityFeature == mNumberIncompatible)
     {
         compatibilityFeatures.Add("some.incompatible");
     }
     return compatibilityFeatures;
 }

        public override DiscourseEntity Retain(Mention.MentionContext mention, DiscourseModel discourseModel)
        {
            //System.err.println(this+".retain("+ec+") "+mode);
            if (mResolverMode == ResolverMode.Train)
            {
                DiscourseEntity discourseEntity = null;
                bool referentFound = false;
                bool hasReferentialCandidate = false;
                bool nonReferentFound = false;
                for (int entityIndex = 0; entityIndex < GetNumberEntitiesBack(discourseModel); entityIndex++)
                {
                    DiscourseEntity currentDiscourseEntity = discourseModel.GetEntity(entityIndex);
                    Mention.MentionContext entityMention = currentDiscourseEntity.LastExtent;
                    if (IsOutOfRange(mention, currentDiscourseEntity))
                    {
                        if (mention.Id != -1 && !referentFound)
                        {
                            //System.err.println("retain: Referent out of range: "+ec.toText()+" "+ec.parse.getSpan());
                        }
                        break;
                    }
                    if (IsExcluded(mention, currentDiscourseEntity))
                    {
                        if (ShowExclusions)
                        {
                            if (mention.Id != - 1 && entityMention.Id == mention.Id)
                            {
                                System.Console.Error.WriteLine(this + ".retain: Referent excluded: (" + mention.Id + ") " + mention.ToText() + " " + mention.IndexSpan + " -> (" + entityMention.Id + ") " + entityMention.ToText() + " " + entityMention.Span + " " + this);
                            }
                        }
                    }
                    else
                    {
                        hasReferentialCandidate = true;
                        bool useAsDifferentExample = defaultReferent(currentDiscourseEntity);
                        //if (!sampleSelection || (mention.getId() != -1 && entityMention.getId() == mention.getId()) || (!nonReferentFound && useAsDifferentExample)) {
                        List<string> features = GetFeatures(mention, currentDiscourseEntity);

                        //add Event to Model
                        if (mDebugOn)
                        {
                            System.Console.Error.WriteLine(this + ".retain: " + mention.Id + " " + mention.ToText() + " -> " + entityMention.Id + " " + currentDiscourseEntity);
                        }
                        if (mention.Id != - 1 && entityMention.Id == mention.Id)
                        {
                            referentFound = true;
                            mEvents.Add(new SharpEntropy.TrainingEvent(Same, features.ToArray()));
                            discourseEntity = currentDiscourseEntity;
                            //System.err.println("MaxentResolver.retain: resolved at "+ei);
                            Distances.Add(entityIndex);
                        }
                        else if (!mPairedSampleSelection || (!nonReferentFound && useAsDifferentExample))
                        {
                            nonReferentFound = true;
                            mEvents.Add(new SharpEntropy.TrainingEvent(Diff, features.ToArray()));
                        }
                        //}
                    }
                    if (mPairedSampleSelection && referentFound && nonReferentFound)
                    {
                        break;
                    }
                    if (mPreferFirstReferent && referentFound)
                    {
                        break;
                    }
                }
                // doesn't refer to anything
                if (hasReferentialCandidate)
                {
                    mNonReferentialResolver.AddEvent(mention);
                }
                return discourseEntity;
            }
            else
            {
                return base.Retain(mention, discourseModel);
            }
        }

 private string ExcludedHonorificMentionString(Mention.MentionContext entityContext)
 {
     System.Text.StringBuilder output = new System.Text.StringBuilder();
     bool first = true;
     object[] mentionTokens = entityContext.Tokens;
     for (int tokenIndex = 0; tokenIndex < mentionTokens.Length; tokenIndex++)
     {
         string token = mentionTokens[tokenIndex].ToString();
         if (!(Linker.HonorificsPattern.Match(token).Value == token))
         {
             if (!first)
             {
                 output.Append(" ");
             }
             output.Append(token);
             first = false;
         }
     }
     return output.ToString();
 }

 private string ExcludedTheMentionString(Mention.MentionContext entityContext)
 {
     System.Text.StringBuilder output = new System.Text.StringBuilder();
     bool first = true;
     object[] mentionTokens = entityContext.Tokens;
     for (int tokenIndex = 0; tokenIndex < mentionTokens.Length; tokenIndex++)
     {
         string token = mentionTokens[tokenIndex].ToString();
         if (token != "the" && token != "The" && token != "THE")
         {
             if (!first)
             {
                 output.Append(" ");
             }
             output.Append(token);
             first = false;
         }
     }
     return output.ToString();
 }

 /// <summary>
 /// Returns distance features for the specified mention and entity.
 /// </summary>
 /// <param name="mention">
 /// The mention.
 /// </param>
 /// <param name="entity">
 /// The entity.
 /// </param>
 /// <returns>
 /// list of distance features for the specified mention and entity.
 /// </returns>
 protected internal virtual List<string> GetDistanceFeatures(Mention.MentionContext mention, DiscourseEntity entity)
 {
     List<string> features = new List<string>();
     Mention.MentionContext currentEntityContext = entity.LastExtent;
     int entityDistance = mention.NounPhraseDocumentIndex - currentEntityContext.NounPhraseDocumentIndex;
     int sentenceDistance = mention.SentenceNumber - currentEntityContext.SentenceNumber;
     int hobbsEntityDistance;
     if (sentenceDistance == 0)
     {
         hobbsEntityDistance = currentEntityContext.NounPhraseSentenceIndex;
     }
     else
     {
         //hobbsEntityDistance = entityDistance - (entities within sentence from mention to end) + (entities within sentence form start to mention)
         //hobbsEntityDistance = entityDistance - (cec.maxNounLocation - cec.getNounPhraseSentenceIndex) + cec.getNounPhraseSentenceIndex;
         hobbsEntityDistance = entityDistance + (2 * currentEntityContext.NounPhraseSentenceIndex) - currentEntityContext.MaxNounPhraseSentenceIndex;
     }
     features.Add("hd=" + hobbsEntityDistance);
     features.Add("de=" + entityDistance);
     features.Add("ds=" + sentenceDistance);
     //features.add("ds=" + sdist + pronoun);
     //features.add("dn=" + cec.sentenceNumber);
     //features.add("ep=" + cec.nounLocation);
     return features;
 }

 private string GetExactMatchFeature(Mention.MentionContext entityContext, Mention.MentionContext compareContext)
 {
     //System.err.println("getExactMatchFeature: ec="+mentionString(ec)+" mc="+mentionString(xec));
     if (MentionString(entityContext).Equals(MentionString(compareContext)))
     {
         return "exactMatch";
     }
     else if (ExcludedHonorificMentionString(entityContext).Equals(ExcludedHonorificMentionString(compareContext)))
     {
         return "exactMatchNoHonor";
     }
     else if (ExcludedTheMentionString(entityContext).Equals(ExcludedTheMentionString(compareContext)))
     {
         return "exactMatchNoThe";
     }
     else if (ExcludedDeterminerMentionString(entityContext).Equals(ExcludedDeterminerMentionString(compareContext)))
     {
         return "exactMatchNoDT";
     }
     return null;
 }

 /// <summary>
 /// Returns a list of features for deciding whether the specified mention refers to the specified discourse entity.
 /// </summary>
 /// <param name="mention">
 /// the mention being considers as possibly referential. 
 /// </param>
 /// <param name="entity">
 /// The discourse entity with which the mention is being considered referential.  
 /// </param>
 /// <returns>
 /// a list of features used to predict reference between the specified mention and entity.
 /// </returns>
 protected internal virtual List<string> GetFeatures(Mention.MentionContext mention, DiscourseEntity entity)
 {
     List<string> features = new List<string>();
     features.Add(Default);
     features.AddRange(GetCompatibilityFeatures(mention, entity));
     return features;
 }