When to explicitly specify type arguments in generic C# method calls?

I have a generic class that offers common methods for predicates of concrete types (I use PredicateBuilder extention methods for that)

public class GenericPredicate<TItem>
{
    protected GenericPredicate(Expression<Func<TItem, bool>> predicate)
    {
        Predicate = predicate;
    }

    protected GenericPredicate()
    {
    }

    public Expression<Func<TItem, bool>> Predicate { get; protected set; }

    //Combines two predicates
    public TPred And<TPred>(TPred second) where TPred : GenericPredicate<TItem>, new()
    {
        return new TPred { Predicate = Predicate.And(second.Predicate) };
    }

    //Negates the predicate
    public TPred Not<TPred>() where TPred : GenericPredicate<TItem>, new()
    {
        return new TPred { Predicate = Predicate.Not() };
    }
}

And concrete predicates:

public class PersonPredicate : GenericPredicate<Person>
{
    protected PersonPredicate(Expression<Func<Person, bool>> predicate)
        : base(predicate)
    {
    }

    public PersonPredicate()
    {
    }

    public static PersonPredicate IsAdult()
    {
        return new PersonPredicate(p => p.Age >= 18);
    }

    public static PersonPredicate IsFemale()
    {
        return new PersonPredicate(p => Equals(p.Gender, Gender.Female));
    }
}

In the factory where I instantiate the concrete predicates I get the error

The type arguments for method Not cannot be inferred from the usage

when calling the generic Not()

PersonPredicate isFemale = PersonPredicate.IsFemale();
PersonPredicate isAdult = PersonPredicate.IsAdult();
PersonPredicate femaleAndAdult = isFemale.And(isAdult);
PersonPredicate notFemale = isFemale.Not(); //Error as described
PersonPredicate notFemaleWorkaround = isFemale.Not<PersonPredicate>();  // Works as suggested by compiler

So, the compiler doesn't know what TItem is. What makes me confused is that the generic And() method works without specifying the type arguments explicitly