With package `remreset`

the reset dependencies can be removed. For example,
if counter `theorem`

is reset if counter `subsection`

is incremented, then

```
\usepackage{remreset}
\makeatletter
\@removefromreset{theorem}{subsection}
\makeatother
```

the resetting is removed.

The other way `\@addtoreset`

does not need a package. For example, if counter `theorem`

should be reset if counter `section`

is incremented:

```
\makeatletter
\@addtoreset{theorem}{section}
\makeatother
```

The appearance of the counter is controlled by `\the<counter>`

. For example, in the latter case it could be redefined to:

```
\renewcommand*{\thetheorem}{\thesection.\arabic{theorem}}
```

Macro `\numberwithin`

of package `amsmath`

performs both steps, adding reset dependency and renaming `\the<counter>`

:

```
\usepackage{amsmath}
\numberwithin{theorem}{section}
```

I hope, you get the idea. A minimal working example is missing. Thus it is not clear to me, what you are doing. Especially the numbering inside subsections is quite unusual.
Perhaps it is wise to check the preamble if this is not intended.

Also it looks even more odd, if the numbering occurs inside subsections without the section number, but with subsection number. The numbers are not unique, thus it is not clear which theorems are meant if only the reference is given.

I would keep the numbering scheme easy and understandable:

Plain numbers without resetting at all: Theorem 1, Theorem 2, …

```
1. First chapter
Theorem 1
Theorem 2
2. Second chapter
Theorem 3
Theorem 4
```

Numbering in a large entity like chapter or section, if the class does not provide chapters:

```
1. First chapter
Theorem 1.1
Theorem 1.2
2. Second chapter
Theorem 2.1
Theorem 2.2
```

Then the reader has a chance to understand the numbering without going in deciphering mode.

You could load the `enumitem`

package and set up the `enumerate`

environment inside the `defn`

environment to use lowercase-roman "numbers" followed by a `)`

. In any cross-references to these items, the trailing parenthesis should probably be omitted.

```
\documentclass{article}
\usepackage{enumitem}
\usepackage{ntheorem}
\theoremstyle{plain}
\theorembodyfont{\upshape}
\newtheorem{defn}{Definition}
\begin{document}
\begin{defn} \label{defn:three}
Consider a system that satisfies the following conditions:
\begin{enumerate}[label=\roman*), ref=\roman*]
\item \label{item:mumble} Mumble \dots
\item Grumble \dots
\item \label{item:cough} Cough cough \dots
\end{enumerate}
Such a system is called a \dots
\end{defn}
Conditions \ref{item:mumble} and \ref{item:cough} in Definition \ref{defn:three} amount to \dots
\end{document}
```

## Best Answer

The last question how to use the section counter in conjunction with the equation counter:

`\renewcommand{\theequation}{\arabic{section}.\arabic{equation}}`

will print the equation number with the section number as prefix only, not the full nine yards with

`chapter.section.X`

.Now the more generic answer about the

`\thefoo`

- like commands.In principle such commands like

`\thesection`

are recursively defined!Depending on the real setup (with

`chngcntr`

's`\counterwithin`

etc. commands) and the underlying class the structure is usuallyIn this case,

`foolevelone`

would be`chapter`

,`fooleveltwo`

is`section`

and`foolevelthree`

will be`subsection`

etc.The precise setup will differ most likely in the usage of

`\arabic`

,`\alph`

,`\Alph`

,`\roman`

,`\Roman`

mainly.In order to get the current section number, just use

`\arabic{section}`

or`\number\value{section}`

The advantage of this numbering scheme is a definition mapping which equation/section/figure etc. belongs to which chapter or structure level.

The disadvantage is that you can't use something like

`\setcounter{section}{\thesection}`

in most cases, because

`\thesection`

may have non-numbers (like periods or roman figures) in its output.Some more details -- from

`latex.ltx`

`\newcounter{foo}`

will call`\@definecounter`

effectively, here is its definition:At the end the

`\gdef\....`

will define`\thefoo`

being a command that prints the counter value with arabic numbers -- this is the default setup, so right from the start, any`\the...`

(as long as related to counters) will print arabic numbers.The final output behaviour is defined by the class (in most cases), like here in

`article.cls`

As can be seen by the row of

`\renewcommand{\the...}`

macros, the commands are recursively defined, where`\@arabic\c@foo`

is the internal representation of`\arabic{foo}`

actual (`\c@foo`

the 'real' counter macro name)