1 | initial version |

Ragarding the first question, you should understand that when you write

```
sage: A = matrix(2,2,var('a', 'b', 'c', 'd'))
```

`A`

is a *Python name*, that is a kind of pointer to the matrix object, but the matrix object doesn't know anything about which names point to it. For example, you can then do:

```
sage: B = A
```

Here `B`

is just another Python name pointing to the very same object in memory as you can check with:

```
sage: B is A
True
```

So, if you want to type `A.as_symbol()`

, there is nowhere in the matrix object that registered the fact that the matrix has "A" as a string representation.

Of course, there could be cumbersome ways to try to find one of the Python names of the matrix object within the `locals()`

dictionary and pick the first one that appears, but it is kind of artificial (maybe a good exercise to understand what appends with Python names though).

Regarding the second question, it is a bit different, since the symbolic variable knows a string reprentation, and you can even tune a latex one as follows:

```
sage: A = SR.var('A', latex_name="\Bold{A}")
sage: B = SR.var('B', latex_name="\Bold{B}")
sage: c = SR.var('c')
sage: A*B
A*B
sage: latex(A*B)
{\Bold{A}} {\Bold{B}}
sage: e = (A+B)*c
sage: e
(A + B)*c
sage: e.expand()
A*c + B*c
sage: latex(e.expand())
{\Bold{A}} c + {\Bold{B}} c
```

2 | No.2 Revision |

Ragarding the first question, you should understand that when you write

```
sage: A = matrix(2,2,var('a', 'b', 'c', 'd'))
```

`A`

is a *Python name*, that is a kind of pointer to the matrix object, but the matrix object doesn't know anything about which names point to it. For example, you can then do:

```
sage: B = A
```

Here `B`

is just another Python name pointing to the very same object in memory as you can check with:

```
sage: B is A
True
```

So, if you want to type `A.as_symbol()`

, there is nowhere in the matrix object that registered the fact that the matrix has "A" as a string representation.

Of course, there could be cumbersome ways to try to find one of the Python names of the matrix object within the `locals()`

dictionary and pick the first one that appears, but it is kind of artificial (maybe a good exercise to understand what appends with Python names ~~though).~~though). A limited list is provided by `show_identifiers()`

Regarding the second question, it is a bit different, since the symbolic variable knows a string reprentation, and you can even tune a latex one as follows:

```
sage: A = SR.var('A', latex_name="\Bold{A}")
sage: B = SR.var('B', latex_name="\Bold{B}")
sage: c = SR.var('c')
sage: A*B
A*B
sage: latex(A*B)
{\Bold{A}} {\Bold{B}}
sage: e = (A+B)*c
sage: e
(A + B)*c
sage: e.expand()
A*c + B*c
sage: latex(e.expand())
{\Bold{A}} c + {\Bold{B}} c
```

3 | No.3 Revision |

Ragarding the first question, you should understand that when you ~~write ~~write:

```
sage: A = matrix(2,2,var('a', 'b', 'c', 'd'))
```

`A`

is a *Python name*, that is a kind of pointer to the matrix object, but the matrix object doesn't know anything about which names point to it. For example, you can then do:

```
sage: B = A
```

Here `B`

is just another Python name pointing to the very same object in memory as you can check with:

```
sage: B is A
True
```

So, if you want to type `A.as_symbol()`

, there is nowhere in the matrix object that registered the fact that the matrix has "A" as a string representation.

~~Of course, there could be cumbersome ways to try to find ~~We can define a function that finds one of the Python names of the matrix object within the

dictionary and pick the first one that ~~locals()~~globals()~~appears, ~~appears (and that is not ugly like `_42`

), but it is kind of ~~artificial (maybe a good exercise to understand what appends with Python names though). A limited list is provided by ~~`show_identifiers()`

sage: def sym(a): ....: for i in globals(): ....: if not i.startswith('_') and globals()[i] is a: ....: return SR.var(i, latex_name="Bold{{{}}}".format(i))

You have:

```
sage: latex(sym(A))
{\Bold{A}}
```

But of course:

```
sage: latex(sym(B))
{\Bold{A}}
```

Regarding the second question, it is a bit different, since the symbolic variable knows a string ~~reprentation, ~~reprentation of itself, and you can even tune a latex one as follows:

```
sage: A = SR.var('A', latex_name="\Bold{A}")
sage: B = SR.var('B', latex_name="\Bold{B}")
sage: c = SR.var('c')
sage: A*B
A*B
sage: latex(A*B)
{\Bold{A}} {\Bold{B}}
sage: e = (A+B)*c
sage: e
(A + B)*c
sage: e.expand()
A*c + B*c
sage: latex(e.expand())
{\Bold{A}} c + {\Bold{B}} c
```

4 | No.4 Revision |

Ragarding the first question, you should understand that when you write:

```
sage: A = matrix(2,2,var('a', 'b', 'c', 'd'))
```

`A`

is a *Python name*, that is a kind of pointer to the matrix object, but the matrix object doesn't know anything about which names point to it. For example, you can then do:

```
sage: B = A
```

Here `B`

is just another Python name pointing to the very same object in memory as you can check with:

```
sage: B is A
True
```

`A.as_symbol()`

, there is nowhere in the matrix object that registered the fact that the matrix has "A" as a string representation.

We can define a function that finds one of the Python names of the matrix object within the `globals()`

dictionary and pick the first one that appears (and that is not ugly like `_42`

), but it is kind of artificial, like:

```
sage: def sym(a):
....: for i in globals():
....: if not i.startswith('_') and globals()[i] is a:
....: return SR.var(i,
```~~latex_name="Bold{{{}}}".format(i))~~latex_name="\Bold{{{}}}".format(i))

You have:

```
sage: latex(sym(A))
{\Bold{A}}
```

But of course:

```
sage: latex(sym(B))
{\Bold{A}}
```

Regarding the second question, it is a bit different, since the symbolic variable knows a string reprentation of itself, and you can even tune a latex one as follows:

```
sage: A = SR.var('A', latex_name="\Bold{A}")
sage: B = SR.var('B', latex_name="\Bold{B}")
sage: c = SR.var('c')
sage: A*B
A*B
sage: latex(A*B)
{\Bold{A}} {\Bold{B}}
sage: e = (A+B)*c
sage: e
(A + B)*c
sage: e.expand()
A*c + B*c
sage: latex(e.expand())
{\Bold{A}} c + {\Bold{B}} c
```

Copyright Sage, 2010. Some rights reserved under creative commons license. Content on this site is licensed under a Creative Commons Attribution Share Alike 3.0 license.