Matches packages whose names match the regular expression name. This is the “default” search mode and is used for patterns that don't start with ~.

	Note
	To match packages whose names contain several different substrings, use the ?name term (described below); for instance, “?name(apti)?name(tude)” will match any package whose name contains both “apti” and “tude”.

Matches packages that correspond to the value of variable, which must be bound by an enclosing ?for. For instance, ?for x: ?depends( ?recommends( ?=x ) ) will match any package x that depends on a package which recommends x.

For instance, the following search expression matches packages that conflict with themselves:

Matches packages which do not match the pattern pattern. For instance, “?not(?broken)” selects packages that are not “broken”.

	Note
	To include a “!” in a search string, it must be “escaped” by placing a tilde (“~”) in front of it; otherwise, aptitude will consider it to be part of a ?not term. For instance, to select packages whose description contains “extra!”, use “?description(extra~!)”.

Matches packages that match both pattern1 and pattern2.

Matches packages that match either pattern1 or pattern2.

	Note
	To use the character “|” in a regular expression, it must be “escaped” to prevent aptitude from creating an OR term from it: “~|”.

Matches pattern. For instance, “opengl (perl|python)” matches any package whose name contains opengl, and also contains either perl or python.

Matches packages upon which the given action is going to be performed. action can be “install”, “upgrade”, “downgrade”, “remove”, “purge”, “hold” (tests whether a package has been placed on hold), or “keep” (tests whether a package will be unchanged).

Note that this only tests whether an action is actually queued up to be performed on a package, not whether it could be performed. Thus, for instance, ?action(upgrade) matches exactly those packages that you have already decided to upgrade, not packages which could be upgraded in the future (for that, use ?upgradable).

Matches any package whose versions all match the given expression. Each version of a package will be separately tested against pattern, and the package will match if all of its versions match. Packages without versions, such as virtual packages, will always be matched by this search term.

This term may not be used in a context in which the versions to match against have already been narrowed, such as within ?depends or ?narrow. However, it may always be used within ?widen.

Matches a package if any one of its versions matches the enclosed pattern. This is the dual to ?all-versions.

This term may not be used in a context in which the versions to match against have already been narrowed, such as within ?depends or ?narrow. However, it may always be used within ?widen.

	Note
	This term is closely related to ?narrow. In fact, ?any-version(pattern1 pattern2) is exactly the same as ?narrow(pattern1, pattern2).

Matches package versions which are available from an archive that matches the regular expression archive. For instance, “?archive(testing)” matches any package available from the testing archive.

Matches packages which were automatically installed.

Matches any package or version if the given pattern matches the package or version bound to variable, which must be defined in an enclosing ?for.

The two search patterns in the above example both match any package x such that x depends on a package y which in turn depends on a package z such that x also depends directly on z. The first pattern uses ?bind directly, while the second one uses an equivalent shorthand syntax.

Matches packages that are “broken”: they have an unfulfilled dependency, predependency, breaks, or conflict.

Matches packages which have an unfulfilled (“broken”) dependency of the given depType. depType can be “depends”, “predepends”, “recommends”, “suggests”, “breaks”, “conflicts”, or “replaces”.

Matches packages with an unsatisfied dependency of type depType on a package matching pattern. depType may be any one of the dependency types listed in the documentation of ?broken-depType.

Matches packages which conflict with a package matching the given pattern. For instance, “?conflicts(?maintainer(dburrows@debian.org))” matches any package which conflicts with a package I maintain.

Matches packages which have been removed, but whose configuration files remain on the system (ie, they were removed but not purged).

depType may be any one of the dependency types given in the documentation of ?broken-depType, as well as provides: for instance, ?depends(libpng3) will match any package that depends on libpng3. If the short form (~D) is used and depType is not present, it defaults to depends.

If depType is “provides”, matches packages that provide a package matching pattern (the equivalent of ?provides). Otherwise, matches packages which declare a dependency of type depType upon a package version which matches pattern.

Matches packages whose description matches the regular expression description.

Matches Essential packages.

This term does not match any package. ^[15]

Matches pattern, but the given variable may be used inside pattern to refer to the package or package version this term to.

You can use variable in two ways. To apply a ?-style term to the variable, write ?variable:term-name(args); for instance, ?x:depends(apt). In addition, the term ?=variable will select any package or version that matches the value of the given variable.

For instance, the following term will match any package x that both depends and recommends a second package y.

Matches packages which are not installed, or which were automatically installed and are not depended upon by any installed package.

Matches package versions which are currently installed.

Since all versions are tested by default, this normally matches packages which are currently installed.

Matches packages whose Maintainer field matches the regular expression maintainer. For instance, “?maintainer(joeyh)” will find all packages maintained by Joey Hess.

This term “narrows” the search to package versions matching filter. In particular, it matches any package version which matches both filter and pattern. The string value of the match is the string value of pattern.

Matches packages whose name matches the regular expression name. For instance, most of the packages that match “?name(^lib)” are libraries of one sort or another.

Matches packages which are “new”: that is, they have been added to the archive since the last time the list of packages was cleared using Actions → Forget new packages (f) or the command-line action forget-new.

This term matches any installed package which is not available in any version from any archive. These packages appear as “Obsolete or Locally Installed” in the visual interface.

Matches package versions whose origin matches the regular expression origin. For instance, “!?origin(debian)” will find any unofficial packages on your system (packages not from the Debian archive).

Matches package versions which provide a package that matches the pattern. For instance, “?provides(mail-transport-agent)” will match all the packages that provide “mail-transport-agent”.

Matches packages whose priority is priority; priority must be extra, important, optional, required, or standard. For instance, “?priority(required)” matches packages whose priority is “required”.

depType may be either “provides” or one of the dependency types given in the documentation of ?broken-depType. If depType is not present, it defaults to depends.

If depType is “provides”, matches packages whose name is provided by a package version matching pattern. Otherwise, matches packages which a package version matching pattern declares a dependency of type depType upon.

depType may be either “provides” or one of the dependency types given in the documentation of ?broken-depType. If depType is not present, it defaults to depends.

Matches packages which a package version matching pattern declares an unsatisfied dependency of type depType upon.

Matches packages whose section matches the regular expression section.

Matches packages whose source package name matches the regular expression name.

Matches packages whose source version matches the regular expression version.

Matches packages whose Tag field matches the regular expression tag. For instance, the pattern ?tag(game::strategy) would match strategy games.

For more information on tags and debtags, see http://debtags.alioth.debian.org.

Matches packages that appear in a task whose name matches the regular expression task.

This term matches any package. For instance, “?installed?provides(?true)” matches installed packages which are provided by any package.

This term matches any installed package which can be upgraded.

This term matches any package that is marked with a user-tag matching the regular expression tag.

Matches any package version whose version number matches the regular expression version, with the exceptions noted below. For instance, “?version(debian)” matches packages whose version contains “debian”.

The following values of version are treated specially. To search for version numbers containing these values, preface the value with a backslash; for instance, to find packages whose version number contains CURRENT, search for \CURRENT.

Matches any package which is purely virtual: that is, its name is provided by a package or mentioned in a dependency, but no package of that name exists. For instance, “?virtual!?provides(?true)” matches packages which are virtual and are not provided by any package: ie, packages which are depended upon but do not exist.

“Widens” the match: if the versions to match against have been limited by an enclosing term (such as ?depends), these limits are dropped. Thus, ?widen(pattern) matches a package version if pattern matches any version of that package.