# [FOM] vagueness in mathematics?

Annatala Wolf a.lupine at gmail.com
Mon Mar 6 18:52:40 EST 2017

```On Tue, Feb 28, 2017 at 11:55 AM Jacques Carette <carette at mcmaster.ca>
wrote:

> It is worth noting that there are similar issues elsewhere.  Most
> prominently, in computer science, most people incorrectly identify
> arrays and matrices; but arrays are a method of memory storage, while
> matrices are representations of (finite dimensional) linear operators
> with respect to a given basis.
>

I think the simple definition here on arrays is not entirely correct. The
term "array" refers to more than just a method of memory storage. (For sake
of argument, I'll gloss over the fact that arrays and the interface to
arrays is language-dependent, and there are frequently more than one
implementation of this concept in the same language.)

Generally, "array" refers to the mathematical abstraction that the
interface to the array represents to the programmer: a finite mathematical
string of some type, indexed from 0, along with specifications for its use
through code. This conceptual aspect of an array is the one in the mind of
the programmer, and it is purely a mathematical representation, not a
methodology. The interface to the data in code is also mathematical in
nature and function. Arrays providing a specific "means" to store and
access data isn't really a distinguishing characteristic. Everything in
computation is a means to store and access data.

The fact that arrays are usually concretely modeled as contiguous memory
isn't mathematically essential as long as the expected behavior matches the
interface to the array (by pointers, accessors, or other means). Memory
isn't even guaranteed to be contiguous in most cases, because the operating
system manages memory at a higher level.

The short version: to a programmer, arrays are mathematical strings with a
mathematically well-defined interface. We may also think of them as a
method of memory storage, but this does not preclude the importance of the
mathematical model they represent to the user. It is important to keep the
abstract mathematical structure separate from the concrete representation,
especially since the latter is not always certain.
--

/* Annatala Wolf, Lecturer
* Department of Computer Science and Engineering
* The Ohio State University
*/
enum E{A;System s;String t="/* Annatala Wolf, Lecturer%n * Department of
Computer Science and Engineering%n * The Ohio State University%n */%nenum
E{A;System s;String
t=%c%s%1\$c;{s.out.printf(t,34,t);s.exit(0);}}";{s.out.printf(t,34,t);s.exit(0);}}
-------------- next part --------------
An HTML attachment was scrubbed...
URL: </pipermail/fom/attachments/20170306/32dc3fb0/attachment.html>
```