# Tuplet¶

class `abjad.core.Tuplet.``Tuplet`(multiplier=(2, 3), components=None, *, denominator=None, force_fraction=None, hide=None, tweaks=None)

Tuplet.

A tuplet:

```>>> tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
```

A nested tuplet:

```>>> second_tuplet = abjad.Tuplet((4, 7), "g'4. ( a'16 )")
>>> tuplet.insert(1, second_tuplet)
```

A doubly nested tuplet:

```>>> third_tuplet = abjad.Tuplet((4, 5), [])
>>> third_tuplet.extend("e''32 [ ef''32 d''32 cs''32 cqs''32 ]")
>>> second_tuplet.insert(1, third_tuplet)
```

Attributes Summary

 `append` Appends `component` to tuplet. `augmentation` Is true when tuplet multiplier is greater than `1`. `denominator` Gets and sets preferred denominator of tuplet. `diminution` Is true when tuplet multiplier is less than `1`. `extend` Extends tuplet with `argument`. `force_fraction` Gets and sets force fraction flag. `from_duration` Makes tuplet from `duration` and `components`. `from_duration_and_ratio` Makes tuplet from `duration` and `ratio`. `from_leaf_and_ratio` Makes tuplet from `leaf` and `ratio`. `from_ratio_and_pair` Makes tuplet from nonreduced `ratio` and nonreduced `fraction`. `hide` Is true when tuplet bracket hides. `implied_prolation` Gets implied prolation of tuplet. `multiplied_duration` Gets multiplied duration of tuplet. `multiplier` Gets and sets multiplier of tuplet. `normalize_multiplier` Normalizes tuplet multiplier. `rewrite_dots` Rewrites dots. `set_minimum_denominator` Sets preferred denominator of tuplet to at least `denominator`. `toggle_prolation` Changes augmented tuplets to diminished; changes diminished tuplets to augmented. `trivial` Is true when tuplet multiplier is equal to `1` and no multipliers attach to any leaves in tuplet. `trivializable` Is true when tuplet is trivializable (can be rewritten with a ratio of 1:1). `trivialize` Trivializes tuplet. `tweaks` Gets tweaks.

Special methods

`(Container).``__contains__`(argument)

Is true when `argument` appears in container.

Return type: `bool`
`(Component).``__copy__`(*arguments)

Shallow copies component.

Copies indicators.

Does not copy spanners.

Does not copy children.

Returns new component.

`(Container).``__delitem__`(i)

Deletes components(s) at index `i` in container.

Deletes first tuplet in voice:

```>>> voice = abjad.Voice()
>>> voice.append(abjad.Tuplet((2, 3), "c'4 d'4 e'4"))
>>> voice.append(abjad.Tuplet((2, 3), "e'4 d'4 c'4"))
>>> leaves = abjad.select(voice).leaves()
```
```>>> tuplet_1 = voice[0]
>>> del(voice[0])
```

First tuplet no longer appears in voice:

```>>> abjad.show(voice)
```
```>>> abjad.inspect(voice).is_well_formed()
True
```

First tuplet is no longer slurred but is still well-formed:

```>>> abjad.show(tuplet_1)
```
```>>> abjad.inspect(tuplet_1).is_well_formed()
True
```

Withdraws component(s) from crossing spanners.

Preserves spanners that component(s) cover(s).

Returns none.

`(Component).``__format__`(format_specification='')

Formats component.

Returns string.

`(Container).``__getitem__`(argument)

Gets item or slice identified by `argument`.

Traverses top-level items only.

Return type: `Union`[`Component`, `Selection`]
`(Container).``__graph__`(spanner=None, **keywords)

Graphviz graph representation of container.

Returns Graphviz graph.

`(Component).``__illustrate__`()

Illustrates component.

Returns LilyPond file.

`(Container).``__iter__`()

Iterates container.

Abjad containers are iterables:

```>>> import collections
>>> container = abjad.Container()
>>> isinstance(container, collections.Iterable)
True
```

Abjad containers are not sequences:

```>>> import collections
>>> container = abjad.Container()
>>> isinstance(container, collections.Sequence)
False
```

Yields container elements.

Returns generator.

`(Container).``__len__`()

Gets number of components in container.

Return type: `int`
`(Component).``__mul__`(n)

Copies component n times and detaches spanners.

Returns list of new components.

`(Component).``__repr__`()

Gets interpreter representation of leaf.

Returns string.

`(Component).``__rmul__`(n)

Copies component n times and detach spanners.

Returns list of new components.

`(Container).``__setitem__`(i, argument)

Sets container `i` equal to `argument`. Finds spanners that dominate self[i] and children of self[i]. Replaces contents at self[i] with ‘argument’. Reattaches spanners to new contents. Always leaves score tree in tact.

Return type: `None`

Methods

`append`(component, preserve_duration=False)

Appends `component` to tuplet.

Appends note to tuplet:

```>>> tuplet = abjad.Tuplet((2, 3), "c'4 ( d'4 f'4 )")
```
```>>> tuplet.append(abjad.Note("e'4"))
```

Appends note to tuplet and preserves tuplet duration:

```>>> tuplet = abjad.Tuplet((2, 3), "c'4 ( d'4 f'4 )")
```
```>>> tuplet.append(abjad.Note("e'4"), preserve_duration=True)
```
Return type: `None`
`augmentation`()

Is true when tuplet multiplier is greater than `1`.

Augmented tuplet:

```>>> tuplet = abjad.Tuplet((4, 3), "c'8 d'8 e'8")
```
```>>> tuplet.augmentation()
True
```

Diminished tuplet:

```>>> tuplet = abjad.Tuplet((2, 3), "c'4 d'4 e'4")
```
```>>> tuplet.augmentation()
False
```

Trivial tuplet:

```>>> tuplet = abjad.Tuplet((1, 1), "c'8. d'8. e'8.")
```
```>>> tuplet.augmentation()
False
```
Return type: `bool`
`diminution`()

Is true when tuplet multiplier is less than `1`.

Augmented tuplet:

```>>> tuplet = abjad.Tuplet((4, 3), "c'8 d'8 e'8")
```
```>>> tuplet.diminution()
False
```

Diminished tuplet:

```>>> tuplet = abjad.Tuplet((2, 3), "c'4 d'4 e'4")
```
```>>> tuplet.diminution()
True
```

Trivial tuplet:

```>>> tuplet = abjad.Tuplet((1, 1), "c'8. d'8. e'8.")
```
```>>> tuplet.diminution()
False
```
Return type: `bool`
`extend`(argument, preserve_duration=False)

Extends tuplet with `argument`.

Extends tuplet with three notes:

```>>> tuplet = abjad.Tuplet((2, 3), "c'4 ( d'4 f'4 )")
```
```>>> notes = [abjad.Note("e'32"), abjad.Note("d'32"), abjad.Note("e'16")]
>>> tuplet.extend(notes)
```

Extends tuplet with three notes and preserves tuplet duration:

```>>> tuplet = abjad.Tuplet((2, 3), "c'4 ( d'4 f'4 )")
```
```>>> notes = [abjad.Note("e'32"), abjad.Note("d'32"), abjad.Note("e'16")]
>>> tuplet.extend(notes, preserve_duration=True)
```
Return type: `None`
`(Container).``index`(component)

Returns index of `component` in container.

Gets index of last element in container:

```>>> container = abjad.Container("c'4 d'4 f'4 e'4")
```
```>>> note = container[-1]
>>> note
Note("e'4")
```
```>>> container.index(note)
3
```
Return type: `int`
`(Container).``insert`(i, component, fracture_spanners=False)

Inserts `component` at index `i` in container.

Inserts note. Does not fracture spanners:

```>>> container = abjad.Container([])
>>> container.extend("fs16 cs' e' a'")
>>> container.extend("cs''16 e'' cs'' a'")
>>> container.extend("fs'16 e' cs' fs")
```
```>>> container.insert(-4, abjad.Note("e'4"), fracture_spanners=False)
```

Inserts note. Fractures spanners:

```>>> container = abjad.Container([])
>>> container.extend("fs16 cs' e' a'")
>>> container.extend("cs''16 e'' cs'' a'")
>>> container.extend("fs'16 e' cs' fs")
```
```>>> container.insert(-4, abjad.Note("e'4"), fracture_spanners=True)
```
Return type: `None`
`normalize_multiplier`()

Normalizes tuplet multiplier.

```>>> tuplet = abjad.Tuplet((1, 3), "c'4 d' e'")
```
```>>> tuplet.multiplier.normalized()
False
```
```>>> tuplet.normalize_multiplier()
```
```>>> tuplet.multiplier.normalized()
True
```
```>>> tuplet = abjad.Tuplet((8, 3), "c'32 d'32 e'32")
```
```>>> tuplet.multiplier.normalized()
False
```
```>>> tuplet.normalize_multiplier()
```
```>>> tuplet.multiplier.normalized()
True
```
```>>> tuplet = abjad.Tuplet((5, 12), "c'4 d'4 e'4")
```
```>>> tuplet.multiplier.normalized()
False
```
```>>> tuplet.normalize_multiplier()
```
```>>> tuplet.multiplier.normalized()
True
```
Return type: `None`
`(Container).``pop`(i=-1)

Pops component from container at index `i`.

Pops last element from container:

```>>> container = abjad.Container("c'4 ( d'4 f'4 ) e'4")
```
```>>> container.pop()
Note("e'4")
```
```>>> abjad.show(container)
```

Returns component.

`(Container).``remove`(component)

Removes `component` from container.

Removes note from container:

```>>> container = abjad.Container("c'4 ( d'4 f'4 ) e'4")
```
```>>> note = container[2]
>>> note
Note("f'4")
```
```>>> container.remove(note)
```
Return type: `None`
`rewrite_dots`()

Rewrites dots.

Rewrites single dots as 3:2 prolation:

```>>> tuplet = abjad.Tuplet(1, "c'8. c'8.")
```
```>>> tuplet.rewrite_dots()
```

Rewrites double dots as 7:4 prolation:

```>>> tuplet = abjad.Tuplet(1, "c'8.. c'8..")
```
```>>> tuplet.rewrite_dots()
```

Does nothing when dot counts differ:

```>>> tuplet = abjad.Tuplet(1, "c'8. d'8. e'8")
```
```>>> tuplet.rewrite_dots()
```

Does nothing when leaves carry no dots:

```>>> tuplet = abjad.Tuplet((3, 2), "c'8 d' e'")
```
```>>> tuplet.rewrite_dots()
```

Not yet implemented for multiply nested tuplets.

Return type: `None`
`set_minimum_denominator`(denominator)

Sets preferred denominator of tuplet to at least `denominator`.

Sets preferred denominator of tuplet to `8` at least:

```>>> tuplet = abjad.Tuplet((3, 5), "c'4 d'8 e'8 f'4 g'2")
```
```>>> tuplet.set_minimum_denominator(8)
```
Return type: `None`
`toggle_prolation`()

Changes augmented tuplets to diminished; changes diminished tuplets to augmented.

Changes augmented tuplet to diminished:

```>>> tuplet = abjad.Tuplet((4, 3), "c'8 d'8 e'8")
```
```>>> tuplet.toggle_prolation()
```

Multiplies the written duration of the leaves in tuplet by the least power of `2` necessary to diminshed tuplet.

Changes diminished tuplet to augmented:

```>>> tuplet = abjad.Tuplet((2, 3), "c'4 d'4 e'4")
```
```>>> tuplet.toggle_prolation()
```

Divides the written duration of the leaves in tuplet by the least power of `2` necessary to diminshed tuplet.

REGRESSION. Leaves trivial tuplets unchanged:

```>>> tuplet = abjad.Tuplet(1, "c'4 d'4 e'4")
```
```>>> tuplet.toggle_prolation()
```

Does not yet work with nested tuplets.

Return type: `None`
`trivial`()

Is true when tuplet multiplier is equal to `1` and no multipliers attach to any leaves in tuplet.

```>>> tuplet = abjad.Tuplet((1, 1), "c'8 d'8 e'8")
```
```>>> tuplet.trivial()
True
```

Tuplet is not trivial when multipliers attach to tuplet leaves:

```>>> tuplet = abjad.Tuplet((1, 1), "c'8 d'8 e'8")
```
```>>> tuplet.trivial()
False
```
Return type: `bool`
`trivializable`()

Is true when tuplet is trivializable (can be rewritten with a ratio of 1:1).

Redudant tuplet:

```>>> tuplet = abjad.Tuplet((3, 4), "c'4 c'4")
>>> measure = abjad.Measure((3, 8), [tuplet])
```
```>>> tuplet.trivializable()
True
```

Can be rewritten without a tuplet bracket:

```>>> measure = abjad.Measure((3, 8), "c'8. c'8.")
```

Nontrivializable tuplet:

```>>> tuplet = abjad.Tuplet((3, 5), "c'4 c'4 c'4 c'4 c'4")
>>> measure = abjad.Measure((3, 4), [tuplet])
```
```>>> tuplet.trivializable()
False
```

Can not be rewritten without a tuplet bracket.

REGRESSION. Nontrivializable tuplet:

```>>> tuplet = abjad.Tuplet((3, 4), "c'2. c4")
>>> measure = abjad.Measure((3, 4), [tuplet])
```
```>>> tuplet.trivializable()
False
```
Return type: `bool`
`trivialize`()

Trivializes tuplet.

```>>> tuplet = abjad.Tuplet((3, 4), "c'2")
```
```>>> tuplet.trivializable()
True
```
```>>> tuplet.trivialize()
```
Return type: `None`

Class & static methods

static `from_duration`(duration, components)

Makes tuplet from `duration` and `components`.

Makes diminution:

```>>> tuplet = abjad.Tuplet.from_duration((2, 8), "c'8 d' e'")
```
Return type: `Tuplet`
static `from_duration_and_ratio`(duration, ratio, decrease_monotonic=True)

Makes tuplet from `duration` and `ratio`.

Makes tupletted leaves strictly without dots when all `ratio` equal `1`:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((1, 1, 1, -1, -1)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Allows tupletted leaves to return with dots when some `ratio` do not equal `1`:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((1, -2, -2, 3, 3)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Interprets nonassignable `ratio` according to `decrease_monotonic`:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((5, -1, 5)),
...     decrease_monotonic=False,
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Makes augmented tuplet from `duration` and `ratio` and encourages dots:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((1, 1, 1, -1, -1)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Interprets nonassignable `ratio` according to `decrease_monotonic`:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((5, -1, 5)),
...     decrease_monotonic=False,
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Makes diminished tuplet from `duration` and nonzero integer `ratio`.

Makes tupletted leaves strictly without dots when all `ratio` equal `1`:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((1, 1, 1, -1, -1)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Allows tupletted leaves to return with dots when some `ratio` do not equal `1`:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((1, -2, -2, 3, 3)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Interprets nonassignable `ratio` according to `decrease_monotonic`:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((5, -1, 5)),
...     decrease_monotonic=False,
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Makes diminished tuplet from `duration` and `ratio` and encourages dots:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((1, 1, 1, -1, -1)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type = 'RhythmicStaff',
...     )
```

Interprets nonassignable `ratio` according to `direction`:

```>>> tuplet = abjad.Tuplet.from_duration_and_ratio(
...     abjad.Ratio((5, -1, 5)),
...     decrease_monotonic=False,
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Reduces `ratio` relative to each other.

Interprets negative `ratio` as rests.

Returns tuplet.

Return type: `Tuplet`
static `from_leaf_and_ratio`(leaf, ratio)

Makes tuplet from `leaf` and `ratio`.

```>>> note = abjad.Note("c'8.")
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     [1, 2],
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     abjad.Ratio((1, 2, 2)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     [1, 2, 2, 3],
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     [1, 2, 2, 3, 3],
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     abjad.Ratio((1, 2, 2, 3, 3, 4)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     [1],
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     [1, 2],
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     [1, 2, 2],
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     [1, 2, 2, 3],
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     [1, 2, 2, 3, 3],
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_leaf_and_ratio(
...     note,
...     [1, 2, 2, 3, 3, 4],
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((3, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Returns tuplet.

Return type: `Tuplet`
static `from_ratio_and_pair`(ratio, fraction)

Makes tuplet from nonreduced `ratio` and nonreduced `fraction`.

```>>> tuplet = abjad.Tuplet.from_ratio_and_pair(
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((7, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_ratio_and_pair(
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((7, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_ratio_and_pair(
...     abjad.NonreducedRatio((1, 2, 4)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((7, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_ratio_and_pair(
...     abjad.NonreducedRatio((1, 2, 4, 1)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((7, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_ratio_and_pair(
...     abjad.NonreducedRatio((1, 2, 4, 1, 2)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((7, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```
```>>> tuplet = abjad.Tuplet.from_ratio_and_pair(
...     abjad.NonreducedRatio((1, 2, 4, 1, 2, 4)),
...     )
>>> staff = abjad.Staff(
...     [abjad.Measure((7, 16), [tuplet])],
...     lilypond_type='RhythmicStaff',
...     )
```

Interprets `d` as tuplet denominator.

Return type: `Tuplet`

`denominator`

Gets and sets preferred denominator of tuplet.

Gets preferred denominator of tuplet:

```>>> tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
>>> tuplet.denominator is None
True
```
```>>> abjad.show(tuplet)
```

Sets preferred denominator of tuplet:

```>>> tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
```
```>>> tuplet.denominator = 4
```
Return type: `Optional`[`int`]
`force_fraction`

Gets and sets force fraction flag.

The `default.ily` stylesheet included in all Abjad API examples includes the following:

`\override TupletNumber.text = #tuplet-number::calc-fraction-text`

This means that even simple tuplets format as explicit fractions:

```>>> staff = abjad.Staff()
>>> staff.append(abjad.Tuplet((2, 3), "c'4 d' e'"))
>>> staff.append(abjad.Tuplet((2, 3), "c'4 d' e'"))
>>> staff.append(abjad.Tuplet((2, 3), "c'4 d' e'"))
```

To illustrate the effect of Abjad’s force fraction property, we can temporarily restore LilyPond’s default tuplet number formatting like this:

```>>> staff = abjad.Staff()
>>> staff.append(abjad.Tuplet((2, 3), "c'4 d' e'"))
>>> staff.append(abjad.Tuplet((2, 3), "c'4 d' e'"))
>>> staff.append(abjad.Tuplet((2, 3), "c'4 d' e'"))
>>> string = 'tuplet-number::calc-denominator-text'
>>> abjad.override(staff).tuplet_number.text = string
```

Which makes it possible to see the effect of setting force fraction to true on a single tuplet:

```>>> tuplet = staff[1]
>>> tuplet.force_fraction = True
```

Ignored when tuplet number text is overridden explicitly:

```>>> tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
>>> duration = abjad.inspect(tuplet).duration()
>>> markup = duration.to_score_markup()
>>> abjad.override(tuplet).tuplet_number.text = markup
>>> staff = abjad.Staff([tuplet])
```
Return type: `Optional`[`bool`]
`hide`

Is true when tuplet bracket hides.

```>>> tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
```
```>>> tuplet.hide is None
True
```
```>>> tuplet_1 = abjad.Tuplet((2, 3), "c'4 d'4 e'4")
>>> tuplet_2 = abjad.Tuplet((2, 3), "d'4 e'4 f'4")
>>> staff = abjad.Staff([tuplet_1, tuplet_2])
```
```>>> staff[0].hide = True
```

Hides tuplet bracket and tuplet number when true.

Return type: `Optional`[`bool`]
`(Container).``identifier`

Gets and sets bracket comment.

```>>> container = abjad.Container(
...     "c'4 d'4 e'4 f'4",
...     identifier='%*% AB',
...     )
```
```>>> abjad.f(container)
{   %*% AB
c'4
d'4
e'4
f'4
}   %*% AB
```
Return type: `Optional`[`str`]
`(Container).``is_simultaneous`

Is true when container is simultaneous.

Gets simultaneity status of container:

```>>> container = abjad.Container()
>>> container.append(abjad.Voice("c'8 d'8 e'8"))
```
```>>> container.is_simultaneous is None
True
```

Sets simultaneity status of container:

```>>> container = abjad.Container()
>>> container.append(abjad.Voice("c'8 d'8 e'8"))
```
```>>> container.is_simultaneous = True
```
Return type: `Optional`[`bool`]
`multiplier`

Gets and sets multiplier of tuplet.

Gets tuplet multiplier:

```>>> tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
```
```>>> tuplet.multiplier
Multiplier(2, 3)
```

Sets tuplet multiplier:

```>>> tuplet.multiplier = abjad.Multiplier(4, 3)
```
Return type: `Multiplier`
`(Container).``name`

Gets and sets name of container.

Gets container name:

```>>> container = abjad.Container("c'4 d'4 e'4 f'4")
```
```>>> container.name is None
True
```

Sets container name:

```>>> container = abjad.Container(
...     "c'4 d'4 e'4 f'4",
...     name='Special',
...     )
```
```>>> container.name
'Special'
```

Container name does not appear in LilyPond output:

```>>> abjad.f(container)
{
c'4
d'4
e'4
f'4
}
```
Return type: `Optional`[`str`]

`(Container).``components`

Gets components in container.

Return type: `tuple`
`implied_prolation`

Gets implied prolation of tuplet.

Defined equal to tuplet multiplier:

```>>> tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
```
```>>> tuplet.implied_prolation
Multiplier(2, 3)
```
Return type: `Multiplier`
`multiplied_duration`

Gets multiplied duration of tuplet.

```>>> tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
```
```>>> abjad.show(tuplet)
```
```>>> tuplet.multiplied_duration
Duration(1, 4)
```
Return type: `Duration`
`tweaks`

Gets tweaks.

```>>> tuplet_1 = abjad.Tuplet((2, 3), "c'4 ( d'4 e'4 )")
>>> abjad.tweak(tuplet_1).color = 'red'
```
```>>> tuplet_2 = abjad.Tuplet((2, 3), "c'4 ( d'4 e'4 )")
>>> abjad.tweak(tuplet_2).color = 'green'
```
```>>> tuplet_3 = abjad.Tuplet((5, 4), [tuplet_1, tuplet_2])
>>> abjad.tweak(tuplet_3).color = 'blue'
```>>> staff = abjad.Staff([tuplet_3])