The post Edifying The Young appeared first on Geometric Algebra Explorer.

]]>Two elementary courses common to modern physics, mathematics, and engineering curricula are Linear Algebra and Vector Calculus. Geometric Algebra is a natural and powerful extension of linear algebra and Geometric Calculus is even more so for vector calculus.

In this post, I interview Dr. Alan Macdonald who talks about his experience with both subjects and how he contributes in educating young undergraduate students about them through his books and online videos.

Dr. Alan Macdonald is Professor Emeritus of Mathematics at Luther College in Decorah Iowa. He received a Ph.D. in mathematics from The University of Michigan in 1970. His research interests include geometric algebra and the foundations of physics.

Dr. Alan is the author of two excellent books that introduce Geometric Algebra and Geometric Calculus to undergraduate students. In his first book * Linear and Geometric Algebra*, he develops the first undergraduate text to cover the essentials of linear algebra and its extension to geometric algebra. Prof. David Hestenes commented on his first book saying:

I commend Alan Macdonald for his excellent book! His exposition is clean and spare. He has done a fine job of engineering a gradual transition from standard views of linear algebra to the perspective of geometric algebra. The book is sufficiently conventional to be adopted as a textbook by an adventurous teacher without getting flack from colleagues. Yet it leads to gems of geometric algebra that are likely to delight thoughtful students and surprise even the most experienced instructors.

His second book * Vector and Geometric Calculus* distinguishes itself from similar books on advanced calculus by two attributes: its thoroughgoing use of Geometric Algebra and the clarity of its exposition at an undergraduate level.

**Tell us about your life work in mathematics. What motivations and goals drove you through your research and teaching career? What obstacles did you face and how did you overcome them?**

I have taught and published in several different areas of mathematics and physics. I faced no serious obstacles in pursuing my varied interests (except to find more than 24 hours in a day). Lucky!

**Tell us about what got you interested in Geometric Algebra. As a mathematician, what kinds of ideas in physics and geometry do you find naturally expressible using GA?**

I read strong claims about geometric algebra and decided to look for myself. I was smitten. I found that geometric algebra and its extension to geometric calculus unify, simplify, and generalize vast areas of mathematics involving geometric ideas, including linear algebra, vector calculus, complex analysis, exterior algebra and calculus, tensor algebra and calculus, quaternions (3D spinors), and euclidean, non-euclidean, and projective geometries. I also found that GA provides a common mathematical language for many areas of physics (classical and quantum mechanics, electrodynamics, special and general relativity), computer science (graphics, robotics, computer vision), engineering, and other fields. People in disparate fields can now talk to each other!

**Some people say “Why should we learn and use GA when we already have many mathematical tools that work?”. How do you respond to this kind of question?**

My response: * Geometric algebra unifies many of your mathematical tools and works better than any of them.* Unfortunately, this has not been sufficient to induce many to switch. GA takes time to learn. And once learned, there is the problem of communicating with others who haven’t learned. Nevertheless, geometric algebra is gaining adherents, slowly but surely.

**Tell us about the relation between Geometric Algebra and Linear Algebra. Can the basic ideas of linear algebra be reformulated using GA? How is that? What are the benefits of such reformulations and developments?**

Geometric algebra is a superset of linear algebra, with more objects, multivectors, and more operations; for example, the geometric product. So anything that linear algebra can do geometric algebra can do. Even within linear algebra, geometric algebra brings advantages. Here is a simple example. Consider the orthogonal complement of a subspace: the set of vectors orthogonal to all vectors in the subspace. For both linear and geometric algebra this ** geometric **definition tells us what the orthogonal complement

**Prof. David Hestenes talked in one of his lectures about your first undergraduates GA book and how it could have been a joint project. In what aspects does your vision for introducing GA to students relate to his?**

I share David Hestenes’ vision of wide acceptance of GA and the advantages this will bring.

A vital aspect of making this happen is encouraging and enabling GA’s inclusion in the undergraduate mathematics curriculum. The only way that mathematics faculties will consider this is to have available GA texts written in traditional mathematics textbook style. This is my small contribution to Hestenes’ vision.

Mathematicians have been infuriatingly slow in becoming interested in geometric algebra. We are repeating the short-sightedness of 120 years ago when **Engineers welcomed Gibbs’s and Heaviside’s vector analysis, though the mathematicians did not** ^{1}.

**What kind of software tools do you think should be used in explaining GA and GC to undergraduate students? Are there any missing features you would like to see in current tools?**

I chose Alan Bromborsky’s GAlgebra for my texts because it is free, it is multiplatform, it does ** symbolic **calculations, and it is well designed. But it is far from everything I could ask for: its syntax for expressions is sometimes awkward; it requires several other programs, e.g., Python, making installation difficult for some; and it has no graphics capability.

I would like to see a program with GAlgebra’s strengths but not its shortcomings.

**What are your expectations of the future of GA & GC in teaching?**

My experience is in teaching undergraduate mathematics in the United States, so I will speak to that. Students typically take a year of scalar calculus in their first year of college, then courses in linear algebra and vector calculus in their second year.

The most natural place to introduce GA & GC is right after scalar calculus. I believe that the current second-year linear algebra and vector calculus courses should be renamed *Geometric Algebra* and *Geometric Calculus*, their purpose being to provide the basic vocabulary of mathematics in dimensions greater than one. By judiciously trimming the current courses and taking advantage of the simplifications of GA & GC, a lot of GA & GC can be covered. My two textbooks *Linear and Geometric Algebra* and *Vector and Geometric Calculus* are attempts at this.

**Tell us about the mathematical developments you think are still necessary for GA & GC to take their rightful place as the primary mathematical modeling language for this century. What kind of research should be conducted to effectively relate GA & GC to mainstream mathematics and applications?**

GA & GC are well developed at the elementary level, ready for use. But there are problems to be solved before they can take their rightful place.

We face a chicken and egg problem: students must learn GA & GC to apply them, and those applying vector methods, but not brought up on GA & GC, must push for their inclusion in the curriculum. And if students learn GA & GC in their second year, this cannot be a dead end: instructors in later courses must use them in their courses. Another problem: people are reluctant to publish using a mathematical formalism unknown to most. We can only do our best, making incremental progress until a critical mass is achieved.

The post Edifying The Young appeared first on Geometric Algebra Explorer.

]]>The post Projective Insights appeared first on Geometric Algebra Explorer.

]]>**Projective Geometry** is the branch of geometry dealing with the properties and invariants of geometric figures under projection. In older literature, projective geometry is sometimes called “higher geometry,” “geometry of position,” or “descriptive geometry”. The most amazing result arising in projective geometry is the **duality principle**, which states that a duality exists between theorems such as Pascal’s theorem and Brianchon’s theorem which allows one to be instantly transformed into the other. More generally, all the propositions in projective geometry occur in dual pairs, which have the property that, starting from either proposition of a pair, the other can be immediately inferred by interchanging the parts played by the words “point” and “line.”

In this post, I interview Dr. Charles Gunn, a mathematician, movie-maker, and teacher whose mathematical activities center around projective geometry and its connection to the human being and the world. He is particularly excited by his recent work on **Projective Geometric Algebra (PGA)**, which he believes has a great role to play in bringing the benefits of GA to a wider audience.

**Tell us about your interest in Projective Geometric Algebra (PGA). Why do you focus on this particular area? Do you have specific PGA-related long-term goals?**

My interest in PGA is a natural outgrowth of my long-standing interest in projective geometry. One of the phases in this process was my work at the Geometry Center at the University of Minnesota (1987-1993), where we created interactive visualizations of hyperbolic and spherical space for the first time using the projective models of these spaces, under the guidance of the late Bill Thurston.

It was natural then that when I went back (quite a bit later) to get a Ph. D. I looked into how not just to make pictures but how to do physics in these non-euclidean spaces. That’s when I became aware of a certain family of geometric algebras that I have since christened PGA and that formed the technical foundation for my thesis (Technical University Berlin, 2011).

The non-euclidean cases were already familiar to the pioneers of GA in the 1870’s such as Clifford and Klein; the euclidean case, however, is a bit tricky and was first enunciated by Jon Selig in around 2000. I have gone on to explore PGA more thoroughly and have published a series of articles devoted especially to the euclidean case; since I think it’s a fantastic tool — both conceptually and practically — for doing euclidean geometry. It includes as sub-algebras the well-known vector, quaternion, and dual (or bi-) quaternion algebras, but offers much more besides. It deserves to be much better-known than it is, especially in the applied mathematics and engineering community. In the article “Geometric algebras for euclidean geometry” I have shown that for classical “flat” euclidean geometry, PGA exhibits distinct advantages over the alternative approaches. It serves also as an ideal stepping-stone both scientifically and pedagogically to more complex GAs such as CGA. This article and others can be accessed at my PGA resource page.

**What do you think about the great legacy of 19th-century geometry? Do you feel the scientific community is properly making good use of this legacy? Are there serious obstacles in the way of discovering the true power of 19th-century geometry? Can PGA be useful in this context?**

The development of mathematics in the 19th century was unique: radical advances were made in every field but an underlying unity was preserved so that leading mathematicians still had an overview of the whole. The transition to the 20th century saw an increasing specialization, the cost was a splintering of the whole. Decisions were made that in retrospect appear to have been motivated more by an ideology of abstraction than by a balanced practical judgment. PGA I think has the potential to stand as “living proof” that 19th-century mathematics still has much to offer to the contemporary community of applied geometry. It unifies two of William Clifford’s greatest inventions: biquaternions and geometric algebra, in the simplest, most elegant way imaginable, and provides an unsurpassed framework for doing kinematics and rigid body mechanics in euclidean (or non-euclidean) space.

On the other hand, it’s also important to note that PGA also contains seeds for the future. I’m particularly interested in this regard in dual euclidean space, which is a metric geometry obtained from euclidean geometry by dualizing it. It arises naturally as a variant of PGA. It was described by Felix Klein in the 19th century but was so unfamiliar that is was relegated to being a curiosity. There is an increasing volume of research, however, indicating that it might play an important role in future science by balancing a certain one-sidedness in our contemporary spatial awareness. Ch. 10 of my thesis contains an introduction to this fascinating theme, available on the resource site above.

The prospect of using PGA in this way to better understand Nature also resonates with the 19th-century heritage. The great pioneers of that era — Möbius, Plücker, Riemann, Grassmann, Clifford, and Klein, among others — were all inspired, in their mathematical research, by physical questions. I personally think that mathematics needs such real-world connections in order to develop healthily and am curious to see whether PGA can help to strengthen such connections.

**In one of your papers, you talk about representing N. J. Wildberger’s Rational Trigonometry via PGA. Tell us about some interesting aspects of Rational Trigonometry from your point of view. How can PGA representation exhibit distinct advantages over the original coordinates-based approach?**

I am no expert on Wildberger’s Rational Trigonometry, although I find the basic idea intriguing. One avoids the messiness of evaluating irrational and/or transcendental functions by working with the sine/cosine of the angle rather than with the angle itself, the square of the norm of a vector instead of the norm, etc. A friend loaned me a copy of Wildberger’s book as I was finishing my thesis and I made it a project to see how many of his results I could rephrase in the language of PGA. I was surprised myself by how well this process went. For example, the fundamental concepts of rational trigonometry — quadrance and spread — reveal themselves in PGA to be precisely dual to each other, a fact not obvious in the original treatment. Furthermore, many of the derivations in PGA are, in my humble opinion, clearer and shorter than the coordinate-based ones in the original. I determined that the whole subject could probably be rephrased in this way using PGA but the lack of time has prevented further work in this direction. This experience is typical when I “translate” standard treatments of euclidean geometry into PGA: often I discover a remarkable conciseness and elegance in the PGA version.

**Tell us about the process of creating software for PGA investigations. What characteristics should this kind of software have? Which software development paradigms you feel most suitable for this process? What are the components you find lacking in current programming languages in this regard?**

I am not a software purist; I used whatever helps me get the job done. Robustness and thorough documentation are my primary criteria. All my PGA investigations also involve visualization, so these two themes go hand-in-hand. Among commercial products, my favorite tool is Mathematica and I use it for prototype development. In fact, I used Mathematica to check all the results in my thesis for correctness.

For production software, I favor public domain software. Throughout my career (since writing my first hidden-surface removal algorithm on punch cards in 1978 at UNC-CH) I have developed such visualization software in parallel to my mathematical interests, as I found that existing 3D tools were/are generally not flexible enough to render what I wanted to. I worked on the geomview project at the Geometry Center in the early 90’s. The latest incarnation in this direction is the Java 3D scene graph jReality, which I’ve been involved with at the TU Berlin since 2003. Like geomview, it is built on the foundation of projective geometry and can be then specialized to support different metric geometries such as euclidean, hyperbolic, and spherical geometry, and has been further specialized by me for my PGA research.

I have also been learning Haskell recently since its pure functional, polymorphic style is particularly well-suited to reliably mapping mathematical domains such as PGA and it seems to be gaining quite a large following. I have looked at other GA packages, hoping to apply them to PGA, but at the time I looked none of them supported a degenerate metric (a key feature of euclidean PGA). If anyone reading this knows of a standard GA package that supports a non-metric “duality” operator please let me know (projgeom@gmail.com).

**In one of your papers, you describe an algorithm for decorating the edges of a regular tetrahedron with helical ribbons to generate new interesting forms. Do you feel there is a strong connection between Projective Geometry and Art? Can PGA be useful as an abstract generative modeling language for such activity?**

My work on “generative sculpture” grew out of my experimenting with 3D printing at the 3D Lab of the TU Berlin beginning about 10 years ago. I was interested in printing polyhedra with different sorts of symmetry. I set myself the challenge of seeing whether I could maintain the identity of the polyhedron while smoothing out the “sharp corners” at the vertices, and the “ribbon edges” paper was the outcome. (For details see my web page at the TUB). Although there was no direct connection to projective geometry in this work, I do think projective geometry can have a similar effect — compared to euclidean geometry (or any metric geometry) it is a much more flexible and mobile geometry and contains within it many possibilities for metamorphosis and polarities characteristic of change and interaction. These I think may have to do with how form, especially living form, emerges in the first place, before it arrives at its fixed euclidean form. There’s much work that remains to be done in this direction, I believe projective geometry itself still contains lots of surprises for inquiring minds.

The post Projective Insights appeared first on Geometric Algebra Explorer.

]]>The post Visualizing Scientific Insights appeared first on Geometric Algebra Explorer.

]]>Visualize this thing that you want, see it, feel it, believe in it. Make your mental blue print, and begin to build. — Robert Collier

Visualization is daydreaming with a purpose. — Bo Bennett

The area of **Scientific Visualization (SciViz)** is an interdisciplinary branch of science. According to Friendly, it is “primarily concerned with the visualization of three-dimensional phenomena (architectural, meteorological, medical, biological, etc.), where the emphasis is on realistic renderings of volumes, surfaces, illumination sources, and so forth, perhaps with a dynamic (time) component”. It is also considered a subset of computer graphics, a branch of computer science. The purpose of scientific visualization is to graphically illustrate scientific data to enable scientists to understand, illustrate, and glean insight from their data.

In this post, I interview Dr. Werner Benger who describes his views on SciViz using Geometric Algebra and provides valuable insights about the use of SciViz in Big Data applications.

Dr. Werner Benger is Chief Designer, Software Architect, and Co-Founder at Airborne Hydro Mapping Software GmbH (AHMS). He worked on the design and development of the Vish Visualization Shell for Scientific Visualization of Big Data. Vish is designed to be suitable for scientific big data from any kind of application domain by using a generic data model. Within the context of AHMS, it is used for topo-bathymetric datasets from LIDAR measurements.

Dr. Werner Benger has a scientific background in astrophysics. His main research is in the area of Generic Visualization methods based on mathematical models for multidisciplinary applications, with a special focus on astrophysics and computational fluid dynamics. The applied methods are based on Differential Geometry, Geometric Algebra, Topology, and Fiber Bundles. His current special focus is on iso topo-bathymetric data via his work in AHMS.

**Tell us about your primary research interest: Scientific Visualization (SciViz). Why have you chosen to work in this field?**

Basically, there are three purposes of visualization of scientific data:

- Presentation (when all is known about the data),
- Analysis (when some questions need to be answered about the data),
- Exploration (when we have no clue about the data yet and want to find out something new).

Although user interface design is not necessarily part of SciViz, but in many cases, interactivity is needed. Particularly important is that the data that one deals with here are those with a spatio-temporal nature, it’s not just “any” data, but this specific subset.

Actually, I would not say that I have chosen to work in SciViz. It’s more that SciViz has chosen me. For most of the time I’ve considered myself rather an astrophysicist that became “delinquent” by engaging with computers too much. The origin came from the question how a black hole actually looks like. I asked that questions to one of my professors at university and he could not answer it, so I had to find out myself. I wrote a computer program for that purpose and that got me into this field. A couple of years ago I gave a presentation to students telling this story, you can find the presentation slides here.

**Do you see significant differences between Engineering and Computer Science when trying to solve practical problems?**

As you mention Engineering vs. Computer Science – I often feel the difference between these two is that in Engineering you worry to get things to work “somehow”, while in Computer Science you also worry how things are getting to work and you want to find a systematic, future-safe approach. I’m myself more behind this theoretical approach to finding a powerful general solution that also but not only works for a special case, rather than just solving one particular special case. I also want to know why things work or why things cannot work, rather than finding an algorithm that solves a problem “somehow”.

**What major branches of Engineering and Computer Science are directly related to SciViz research and applications?**

My own approach to scientific visualization is focusing on finding general methods that allow encapsulation and reuse of code and algorithms. Computer programmers are inherently lazy people; otherwise, they would not use computers. I’m no exception for that, and particularly lazy such that I want to implement an algorithm or data operation once, and not over and over again for similar data types. Consequently what is needed is one common concept that covers many cases under the same hood. I found that to be true through my background in astrophysics in General Relativity (GR); since this theory makes many otherwise implicit assumptions explicit.

The same is also true about Geometric Algebra, which “unfolds” otherwise collapsed mathematical entities, such as vectors and bivectors, and clearly states the properties of each object in a systematic way. So it is this unfolding and clarification of concepts via GA and GR (namely differential geometry and topology) that opens the path to a common data model that is powerful and reusable for those many cases that one encounters in scientific visualization. It is an overhead for a particular case, so many people who do their work under time-pressure or a close horizon don’t see the benefit of a more general data model, but in the longer term it is significantly less work and opens development resources towards more interesting topics rather than dealing with myriads of similar cases. Here is an article titled “On Safari in the File Format Jungle” that elaborates on this matter.

Systematic scientific visualization fuses all those interesting mathematical fields of differential geometry, topology, and geometric algebra. SciViz is also on the bridge between artwork and science, so touching both aspects is what many want, but only SciViz achieves if done well. You can read more about this aspect in my article “Visions of Numerical Relativity 1999“.

**What recent SciViz developments you find most important that you can tell us about?**

Concerning new developments – that is certainly “Big Data”, which has become a buzzword that is all around now. With more and advanced numerical and observation technology available, the trend is to no longer filter data during generation, but to just retrieve and store anything possible, leaving the crucial problem of identifying – i.e., visualizing – the important aspects of the data to the last data processing step, the visualization. This is a topic by itself of course, but just to mention that Big Data is often considered synonymous with High-Performance Computing (HPC). Actually, SciViz only covers one aspect of HPC, but indeed many methods and approaches from HPC are needed to deal with SciViz, even on single PCs and laptops. There it is of course all about parallelism, about GPU computing, about parallel I/O, and about scaling up algorithms to deal with bigger amounts of data.

**Tell us about the relations between Geometric Computing (GC) and SciViz. How does SciViz benefit from developments in GC and the other way around? **

Geometric Computing is a tool that is used in SciViz to solve its various detail problems. It’s frequent that in SciViz you want to achieve something and you need to search for the best GC algorithm to solve it. For the other way around, SciViz may help to develop a GC algorithm as it allows visual insight to what actually happens during the algorithm, not merely the result.

**What benefits can Geometric Algebra provide in this context for both domains? Do you find everyone agreeing with your point of view on using GA?**

I always try to solve a GC problem via GA since GA is much richer in expressiveness than linear algebra and the chances that a seemingly complex algorithm can be solved by some simple but powerful elements taken out of a GA “toolbox” are high. Once you are used to thinking in terms of GA, things become easier that way, and thinking in terms of linear algebra feels like a knot in the brain. Like when talking about a “normal vector”, which is not really a vector, it’s merely identified with a vector, but what is actually a better representation is a bivector algebraically describing a plane’s direction in space.

This sometimes leads to passionate discussions with colleagues who still think about geometry in linear algebra and wonder how to rotate around an axis in 3D, when it’s so much easier to think about a rotation in a plane spun by two vectors. Such GA-based representation does not require any thinking, you “just do it”. But it is so hard for people to think about a bivector when talking about a plane if they are used to think about a plane’s normal vector instead, which in fact is a construct involving orthogonality and orientation, much more complex than the original object, the plane itself.

But then, even GA complicates matters by considering bivectors as oriented planes, but there’s not really a concept of a plane “as-is”, i.e. without orientation. That is something that can be borrowed from differential geometry as a covector, an unoriented plane, which by means of using an orientation (via the pseudoscalar) is identifiable with a bivector, then describing an oriented plane. And all those items are identified in linear vector algebra with the same object, a three-component vector.

Now it’s a bit of matter of taste which side is more confusing, the one identifying different geometric concepts into the same algebraic representation, or the one that unfolds a widely used geometric concept into more expressive algebraic objects. For my taste, the latter, and the more you have unfolded those geometric concepts, the better you understand which algebraic structures are required for identification – and those structures may be non-trivial in general, thus need to be considered explicitly in a general-purpose data model, even though via various optimization techniques they would vanish. This should be the last step, not the first one. “Implicit assumptions” are the death of data descriptions and file formats, there must at least be a way to identify which assumptions have been made, and they need to be part of the data description.

**What is the importance of embedding the assumptions into Big Data descriptions and file formats? How can we approach this effectively?**

When we classify algebraic properties of geometric concepts we obtain a “zoo” of vector types. This determines the metadata that needs to be written to a file (or other means of persistent storage such as a database) such that the data remain identifiable. Just writing floating point data is simple, but problems occur when the need arises to know what the data mean when reading them. Self-description of data is important for archival purposes and restartable algorithms, which are particularly important for long-term archiving and out-of-memory data processing. There are not many file formats that even provide the required expressivity of meta-data as required for this purpose to describe such variety of vectorial types.

XML is one option, especially in the web context, **HDF5** is another one, designed for high-performance applications and big data. While via XML anything is in the open, in HDF5 there already is an API to describe the properties of types. In Addition, HDF5 provides functionality of type conversions, which in this context can be utilized to e.g. implicitly convert multivectors of different numerical precision or to read a partial multivector into full multivector (for instance, if data were written by an application that only knows about vectors, but later on these data are read into another application that only knows about full multivectors).

For a generic application, we need runtime type identification that maps a type description, may it be provided by HDF5 or another capable file format \ storage medium, into compile-time types such that the correct precompiled code for the respective vector types can be called. On the other hand, the I/O mechanisms should not need to know about the complexity of vector types, it only needs to know about arrays of floating points plus some metadata. Thus what is left is to map the compile-time type meta-information to some run-time meta-information about types. The mechanism of type traits comes into play here for writing data. For reading data, however, it is not sufficient. When a certain data type is identified in some persistent storage, the reading code has to look up some registry to find a routine that produces actual instances of data arrays of the given type (which is then known by application code only). Given such an application code produced data array, it remains sufficient for the reading code to look at its numerical values only.

**As I understand, SciViz is a core part of any practical simulator. In your opinion, what are the software engineering methods most suitable for designing and implementing scalable SciViz software components and systems? **

Well, in theory, it’s a complementary part of simulation; in practice many scientists performing 3D or 4D simulations still only look at numbers or 1D plots. This is partly due to “old-style” scientists being used to 1D plots, as this was the only way of “visualization” decades ago, and color printing of images with 3D visualizations is not possible in traditional high-profile journals where they want to publish. The other problem is the inconvenience of dealing with big data and advanced visualization systems. While there are lots of fancy visualization equipment such as Caves and Walls, only very few would make use of such. The typical scientist would not make use of anything that doesn’t run on their laptops right away. Even going to another room for doing visualization on a higher-end machine is too much overhead for many “end-users” and they would not do it unless they are forced to.

For design and engineering of SciViz software, I’m an advocator for using a common data model. I.e., use one central data structure to route as many types of data through this one, instead of cooking many little solutions that may or may not fit together.

Concerning code readability, I believe code should be written in a most intuitive way; mathematical algorithms as close to the mathematical notation as possible. For example, operator overloading and C++ 14 string literals provide syntactic sugar to do so, but a naive implementation may suffer performance issues. Expression templates have demonstrated how human-readable code can be transformed into efficient code by using C++ templates. The more constraints are known about some code, the better it can be optimized, and systems such as Gaalop or GMac that rely on symbolic algebra packages may be able to optimize a certain algorithm even better than the more generic C++ compiler. It is thus desirable that a C++ library providing GA algorithm allows for application code that is not only human-readable but also readable as a domain-specific language such that it is parseable by tools beyond the C++ compiler itself.

**How can GA be useful in this software design context? Are there any difficulties associated with using GA here?**

GA is as helpful here in software design as it is helpful in bridging different mathematical applications, by showing a common, unifying basis. The difficulty here is similar to using a common data model: we need the most general possible way of considering GA, not merely a version of GA for one particular case, even though that one may be very broadly used.

For instance, this means considering GA in arbitrary coordinate systems, not merely in orthonormal coordinate systems, which is what most implementations of GA do – because mathematically, it can be done, and the problem is solved thereby. But it’s only mathematically solved, and in practice, non-orthonormal coordinate systems are more common; for instance in numerical relativity or in computational fluid dynamic simulations. GA-based implementations need to be as general as possible to cover all such applications that can use GA as an algebraic representation. At the same time, we need to keep the highly optimized reductions that are possible for special cases, and at this time some automatic code generators may come into play to allow specifying constraints and knowledge available for a particular use case (e.g. global orthonormality of coordinates) which are not available on the level of a compiler.

**How do you think designing GA-based SciViz software, like your Vish Shell, for Big Data processing can be different from small scale GC applications?**

A certain difference is that one must avoid any overhead “per vector element” and consider doing operations on “arrays of multivectors”. This comes with constraints that need to be taken into consideration. Vish stems from a background of dealing with big data from numerical relativity and bases all its data operations on the concept of fiber bundles. This means operations are done as array operations as much as possible, which are parallelizable and allow optimal data throughput, for both I/O and transferring data on the graphics card for rendering. Modern rendering is based on vertex buffers and vertex arrays, which mathematically are fiber bundles, whereas the old OpenGL 1.0 was about primitives and lists of primitives. This model did not scale to the highly parallel data processing that happens on GPUs and thus is considered deprecated now, whereas the fiber bundle data model, envisioned originally by D. Butler in 1989, shines, even though only a few people are aware that they actually do fiber bundles.

**What role does GA have in such Big-Data software design context?**

In this context, GA is complementary, as it basically implements fibers on the fiber bundle data model. So the basic change is to think about operations on arrays of multivectors and to extend solutions to consider array operations instead of single variables. Now that “should” be rather easy when an array of multivectors is homogenous, i.e. each array element consists of multivectors with the same zero and non-zero components. Fortunately, this will most likely be the case in practical applications, and code-generators such as GMac are able to predict which multivector components will always be zero within an algorithm – that is an essential part of applying GA algorithms for big data, both for computational speed and even more memory consumption.

For a single input operation, optimizing out zeroes is just some computational optimization, but the algorithm would still work without it. For big data having many inputs, keeping arrays which are all zero are performance killers and may prevent an entire application from becoming functional. So an optional optimization for small data applications becomes a mandatory component for big data applications. But things become really complex if we had to consider heterogeneous multivector arrays where the zeros would be different at each array element. This basically leaves us with two options: Carry all zeroes everywhere for the sake of parallelism, or use locally dynamic multivectors, which will be much slower but more memory-friendly. Let’s hope we don’t have many such application cases.

**Can you tell us about other interesting aspects of Vish?**

I would like to point out that Vish is adhering to a particular license with a non-military aspect. I think it’s important for developers of technology to also think how their technology can be used. Otherwise, the Oppenheimer effect may strike them later on. Many people would object, and promote “free software” just for the sake of freedom, saying the military would not respect a software license anyway. However, my experience on that matter has been just the opposite. It is respected, and I had a couple of requests from the military that I was putting down, and it was accepted.

**You mentioned earlier that most scientists don’t like to use advanced SciViz tools often. What can we do in terms of educating and training new generations of researchers to change this? Can GA provide help in solving this problem?**

This is a good and unsolved question. Actually, I don’t think much can be done to change the mind of current researchers, but new ones will embrace new technology in a natural way, similar to kids growing up with smartphones, while their grandparents still disapproving them. Parts of the process is due to the technology not just becoming functional, but also easy and available to use.

There is not much point of trying to “force” users into some technology, that is not really sustainable, but there are many people out there that would want to make their technology to be used and available, yet they struggle with the simple issue of obtaining funding for it, because in the scientific world, you don’t get papers and publications for making your software easier to use. It’s more the scientific publication culture, or rather, using “scientific publications” as a measure for funding agencies that inhibits making such tools easier. SciViz, in particular, has the problem that everyone wants and likes glossy images to present and sell their work, but hardly anyone wants to invest resources into it or pay for it. There are few exceptions, for instance, I heard about research centers with the policy that 10% of all project budgets must be allocated for doing visualization; this is a great model. By that model, even projects that don’t need visualization contribute to visualization research and deployment. With a proper funding model for SciViz development and supplementing, development and increased use of advanced SciViz tools will come naturally.

On the other hand, GA is more an educational topic, it does not really help to understand a data analysis in its entity, it could only help to understand a certain data analysis tool or method, to see what it does. But understanding the data itself is independent, and that is up to the scientist who produced the data to determine whether GA is of benefit in this step. But similar to SciViz tools, there is no point of trying to enforce or promote GA to those who don’t want it, but those who don’t know it yet should be made aware that it exists and what it is good for, and that should be done as early as possible in someone’s learning career. Of course, the problem is that it comes with a choice – it can be used or not, so to not burden people with unnecessary mental ballast, it would not be taught early on. But at least, it should be mentioned, so people inspired by it can look it up themselves.

The post Visualizing Scientific Insights appeared first on Geometric Algebra Explorer.

]]>The post GMac: The Next Generation (2 of 2) appeared first on Geometric Algebra Explorer.

]]>There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult. — C. A. R. Hoare.

Planning for the next generation of GMac began in August 2011. I started to design the new version of GMac from scratch by reading significant parts of Terence Parr’s book “Language Implementation Patterns” ^{1}, Robert W. Sebesta’s classic book “Concepts of Programming Languages“, and the second edition of the bestseller Dragon Book “Compilers: Principles, Techniques, and Tools“. I had learned many lessons during developing the first GMac prototype. These books provided a solid conceptual framework for designing the new version of GMac containing all the lessons I’d learned before.

In the previous post, I talked about the first part of my journey developing GMac, the fascinating discoveries I made, and the difficulties I faced along the way. In this final part, I explain the design decisions I made for GMac and how I came to select them, in addition to the developments I hope to make in the future.

… with proper design, the features come cheaply. This approach is arduous, but continues to succeed. –Dennis Ritchie.

The first line of code I wrote was in the most basic of its foundations; namely the interface between GMac and a mathematical symbolic processing system like Mathematica. In addition, I created a library of utilities and basic data structures that grew over time called **UtilsLib**. I initially started out trying to design a single library that is capable of unifying and handling symbolic processing for a number of **Computer Algebra Systems** **(CAS)** like Mathematica, Maple, Mathcad, SageMath, Maxima, etc. In order to create such class library, I would have to learn the basics of all these systems to abstract a common interface. This was a huge project by itself that would delay my dream considerably. I eventually concentrated on designing an Object Oriented (OO) interface to Mathematica’s NET Link API in the hope that I would have the time to expand it later to other symbolic processing systems.

Computer algebra systems mostly use homogeneous trees of objects, like Mathematica’s Expr class, to store information about the structure of all their expressions. These homogenous trees are suitable for computer algebra but not easy to handle using OO design. This is a similar problem to needing an OO interface between tables in relational databases and the OO applications interacting with them, we call that the **Data Access Layer (DAL)**.

The final result is my **SymbolicInterface** component class library, a kind of **Symbolic Processing Access Layer (SPAL)** to Mathematica. The main purpose of this library is to add low-level symbolic processing capabilities to GMac on symbolic scalars. A symbolic scalar is the most basic unit of computation that GMac can handle; it represents an expression that can be evaluated into a real number after substituting values into its symbolic variables if any are present. For example, all the following are basic symbolic scalars in GMac based on Mathematica syntax for symbolic expressions:

- -109
- 2.3456
- Rational[6,11]
- Pi
- Sin[2*Pi/3]
- Exp[-t/5]
- x + 3 * Power[y, 2] – 5 x * y

The restrictions on the Mathematica values and functions used in scalar expressions is that each value or function should be convertible into the target language in which code generation is desired. Each symbolic variable, like x, y, and t in the above expressions, should be associated with a data store in the target code; for example, a local variable, an array element, a class member, a named constant etc. Additional kinds of symbolic expressions with unified OO interfaces can be defined and evaluated like matrices, vectors, boolean expressions, rules, etc.

Using the SymbolicInterface classes I could now define basic operations on multivectors in any selected GA frame. I could define symbolic basis blades and their linear combinations using an approach similar to the one described in “Geometric Algebra for Computer Science“. I could create and manipulate symbolic multivectors as linear combinations of basis blades with any given signature, even non-orthogonal ones like the 5D Conformal GA. The coefficients of these symbolic multivectors are symbolic scalars, not just numeric floating point numbers. I began implementing all standard operations on multivectors and blades like the geometric, outer, and inner products, inversions and involutions, outermorphisms, etc.

The SymbolicInterface classes are used extensively across all layers and components of GMac to communicate with Mathematica through a unified OO interface. This interface can be used in similar projects. I hope I could make it an open source component in the near future, if I could obtain proper funding for GMac, to be further developed by interested people. I also need to add automatic symbolic multivector differentiation to increase the range of applications that GMac can be used in.

It’s OK to figure out murder mysteries, but you shouldn’t need to figure out code. You should be able to read it. — Steve McConnell.

The next logical step to make was to design and implement the main user interface to the GMac system, its **Domain Specific Language (DSL)**. One of the lessons I’d learned during my Ph.D. was that using sophisticated software systems requires a well-designed interface close to the user’s specific domain of knowledge, not the software engineer’s. Two approaches, DSLs and **Visual Programming Languages (VPLs)**, are the best candidates for the job. A VPL can always be built around a DSL but would require an additional layer to visually interface with the user, So I decided to start with a simple Geometric Algebra based DSL ^{2}. I hope in the future I could implement a visual environment for GMac that can be used to define GA-models using visual GA-notation and relate the DSL’s components together visually.

It took a lot of experimentation and re-design, but the final result is **GMacDSL**. The language design of GMacDSL is simple and focused on the domain; namely GA-based modeling. GMacDSL is not Turing-complete because it doesn’t need to be. The main elements of GMacDSL are:

**Namespaces:**These are simple logical named containers for the other elements of GMacDSL similar ti Java packages and C# namespaces.**Frames:**Using GMacDSL, the user can define any fixed set of named basis vectors along with their relative metric relations including Euclidean, Orthonormal, Orthogonal, and Non-orthogonal frames. Frames are the basic abstraction on which all subsequent symbolic computations occur inside GMac.**Subspaces:**A subspace is a set of basis blades of a given frame. They are useful in many cases for selecting or defining parts of multivectors during symbolic computations.**Pre-defined Data Types:**Two types are present in GMacDSL. Scalars are symbolic expressions of real values, including number literals. In addition, each frame automatically defines an associated Multivector type; a list of scalars defining a symbolic linear combination of the Frame’s basis blades.**Structures:**User-defined combinations of named members having given types including scalars, multivectors, or other structures. These are similar to user-defined types and structs in other languages. The main purpose of structures is to implement the pattern of Geometric Generators in GMacDSL.**Constants:**These are constant-valued named data containers of any type including scalars, multivectors, and structures. The scalar values inside constants can be large symbolic expressions; they needn’t be number literals.**Fixed Outermorphisms:**These are simple outermorphisms with fixed scalar elements that are mainly used to transform related frames. For example, we can define a non-orthogonal frame using an orthogonal one and an invertible change of basis matrix. Then GMac automatically defines two fixed outermorphisms to transform multivectors between the two frames.**Multivector Expressions:**The main function of GMac is to handle standard GA operations on symbolic multivectors. Multivector expressions provide this capability to define macros and construct constants.**Macros:**A macro in GMacDSL is the most important unit of computation. Simply speaking, a macro is a list of GA-based high-level computations on scalars, multivectors, and structures that produce a single value of any type from computations performed on a number of inputs, also of any type. A macro is not a procedure or function in the familiar way of common programming languages. A macro can only call other macros defined before it in the DSL code and allows no recursion.

This structure is simple to understand and use for non-programmers working with GA models while being sufficient for covering many practical GA models. In the future, I hope to develop GMacDSL using the Functional Programming Paradigm. This would provide elegant and powerful syntax and semantics for GA-based models that would take great benefit from GA’s unified and elegant mathematical abstractions.

When debugging, novices insert corrective code; experts remove defective code. — Richard Pattis.

In order to experiment with various designs of GMacDSL I had to implement a compiler to parse and translate GMacDSL code into a suitable intermediate data structure. In 2012, I began writing the **GMacCompiler** front-end for that purpose. The first step in creating a typical compiler is to implement its parser. I initially tried to code my own parser using the elegant functional capabilities of F# but I later found a much better solution called **Irony **by Roman Ivantsov ^{3}. Irony has many good features that attract computer language designers to use it as a base for their language tools. Using Irony I could easily parse GMacDSL code into a homogeneous **Parse Tree**. This parse tree is not useful by itself because it’s based on a context-free Irony Grammar, but it can be converted into a more useful **Abstract Syntax Tree (AST)** through semantic analysis.

Based on Irony, I developed an infrastructure for creating simple DSLs. I call this infrastructure **IronyGrammars **^{4}; it provides many services needed by typical DSL compilers like source code handling, error and warning messages reporting, symbol table management, semantic analysis, AST construction and navigation, interpretation services, etc. Naturally, the most difficult part of implementing the IronyGrammars infrastructure is the debugging. Many cycles of refactoring, testing, and debugging were made. The implementation finally settled in a relatively satisfying state after removing much code.

I used IronyGrammars to create the GMacCompiler front-end as a specific compiler of GMacDSL code. The GMacCompiler front-end parses and translates the GMacDSL code into the desired intermediate data structure; the **GMacAST** structure used as the primary GA-based high-level information source for further symbolic processing at later stages. I also created mini-compilers that can translate partial GMacDSL code like a single multivector expression, a single user defined structure, or a single macro. This kind of small compilers is very useful during code composition for adding temporary structure to an already created GMacAST.

Perfection (in design) is achieved not when there is nothing more to add, but rather when there is nothing more to take away. — Antoine de Saint-Exupery.

By 2013 I had a solid perception of the main components that GMac should have. I also was almost finished with two of GMac’s core components: GMacDSL and the GMacCompiler front-end that translated GMacDSL code into the high-level GMacAST intermediate structure. It was about time to create a proper, but simple, **Integrated Development Environment (IDE)**; the **GMacIDE**.

The first thing I needed is a simple colored TextBox control for Syntax Highlighting. I soon found the nice FastColoredTextBox control by Pavel Torgashov ^{5}. I implemented a simple interface for GMacDSL code management to handle projects containing multiple code files, to compile and report errors and warnings, explore the GMacAST, generate sample code from a single macro, and perform other functions.

The current GMacIDE is very simple, I hope in the future it can be extended to contain a set of Visual Editors for creating and modifying GMacDSL code and manage the details of code composition from GA-models. In addition, I need to add some form of interactive multivector visualization component to enable exploring GA-based geometry visually.

Talk is cheap. Show me the code. — Linus Torvalds.

The GMacIDE enables the GMac user to perform many functions. One of the most important of these functions is interfacing with the **GMac Scripting Engine**. Implementing a scripting engine for a system like GMac is essential. GMacDSL is not Turing-complete, the user can describe GA-based models but can’t properly interact with them unless he uses more programming structure like loops, conditional execution, expression evaluation, etc. These functions require an interpreter, at least, to be implemented properly. In addition, the powerful symbolic processing capabilities supporting GMac can be accessed using such scripting engine.

GMac scripting is intended for exploration of geometric ideas through GA-based geometric models and algorithms. Three languages can be integrated into a single GMac script, each for a specific purpose:

- C# code comprises the main body of the script. C# is not originally designed for scripting purposes, nevertheless, C# is a very powerful compiled statically typed object-oriented language that can be used for scripting. To simplify using C# as a scripting interface for GMac some syntactic sugar is used to “sweeten” the process of reading and writing GMac scripts.
- GMacDSL code can be executed on multivector values and user-defined structures. The scalar coefficients of multivectors can be numerical, symbolic, or a mix of both. GMac code is passed, as C# public method calls, to GMac internal services in string form to be automatically compiled and executed by the GMacCompiler.
- Mathematica code can be executed on the Mathematica kernel used in the background by GMac. The Mathematica text code is passed through C# service method calls to the Mathematica kernel through the SymbolicInterface classes. This can be used to exploit the full power of Mathematica through GMac to perform many symbolic manipulations and graphing tasks related to the purpose of the GA-based script exploration.

The main input to the script is always a GMacAST structure compiled from the main GMacDSL code. This combination of GMacAST structure, C#, GMac, and Mathematica code, make GMac scripting a very powerful method for GA-models exploration from the simple to the complex.

Scripting in GMac is not intended for efficient execution of GA-based algorithms. If the user is satisfied by the final algorithm, GMacAPI can be used by a good software designer to implement an efficient, well-structured version of the script in any desired programming language, with specific types of multivectors and GA algorithms.

In science, if you don’t do it, somebody else will. Whereas in art, if Beethoven didn’t compose the ‘Ninth Symphony,’ no one else before or after is going to compose the ‘Ninth Symphony’ that he composed; no one else is going to paint ‘Starry Night’ by van Gogh. — Neil deGrasse Tyson.

The final stage in any compiler is code generation from some intermediate representation of the input source code. This stage is the most demanding for creativity because it relies on designing and implementing many optimizations to generate target code suitable for its specific consumer. Traditional compilers typically generate machine code for native hardware or byte code for virtual machine frameworks. This form of code is machine-oriented, cold and repetitive code not intended for reading or understanding by humans. GMac, being a DSL based source-to-source compiler, produces programmer-oriented textual source code in some high-level human-readable language. The difference between designing the code generator of any typical compiler vs. the code generator of a system like GMac is similar to the difference between designing a machine that creates mechanical parts and designing a tool-set for an artist.

If we look up the verb * compose* in the Merriam-Webster online dictionary we’ll find the following meanings:

**A) to form by putting together**: fashion; ‘a committee composed of three representatives’

**B) to form the substance of**: constitute; ‘composed of many ingredients’

**C) to produce (as columns or pages of type) by composition****A) to create by mental or artistic labor**: produce; ‘compose a sonnet’

**B) to formulate and write (a piece of music)**: to compose music for**to deal with or act on so as to reduce to a minimum**‘compose their differences’**to arrange in proper or orderly form****to free from agitation**: calm, settle ‘composed himself’

My personal view of coding is a form of:

Creative composition of highly structured, human-understandable, and machine-compilable text holding all the meanings of the verb

stated above.compose

To me writing code is not just about execution efficiency or blind implementation of algorithms; writing code is fundamentally artistic such that no two skilled software developers may produce the same code for a single problem. Like there can be no machine that may creatively produce music or paintings, there can be no single code generator that can, by itself, write human-understandable code with all its rich content of information, creativity, and beauty. Nevertheless, we can certainly make many smaller tool sets to help the skilled code developer layout code in the way humanly and creatively desired, while automatically generating machine-oriented code from the intermediate representation to free the * coding artist* from its repetitive cold nature.

The text generation tool set specifically created for GMac, but independently usable otherwise, is a C# library called **TextComposerLib**. I made the decision of creating my own text generation component in 2013 after an extensive search for many similar libraries. I found no libraries that satisfied my vision for GMac. The TextComposerLib library is like a set of paint brushes to artists. The user can combine several of its text composition tools to create highly structured text. The structure can be generated on the internal level of a single document, or on the external level of files and folders.

In the future, I hope to make TextComposerLib more versatile and reliable by introducing Multithreading capabilities and designing a Service-Oriented interface. I also hope to release it as an open-source component for general text composition tasks.

Make everything as simple as possible, but not simpler. — Albert Einstein.

In 2014 I began implementing the GMac part I enjoyed the most; the **GMacAPI **code assembly component. If TextComposerLib is like a set of tools for artists to compose with, then GMacAPI is like a fully configurable production line for assembling structured code. Using this extensive and sophisticated **Application Programming Interface (API)**, you can perform a full process of assembling code libraries in any desired target programming language. Using the GMacAPI you can:

- Supply raw materials to the assembly line; mainly a compiled GMacAST data structure that is independent of any particular target language, like C#, Python, C++, Java, etc., from any particular external computing libraries, and from any particular software architecture required.
- Use the full composition capabilities of TextComposerLib for producing the final code.
- Define sub-processes for assembling subsets of the final code library by inheriting from the GMacAPI core classes.
- Monitor and log each step of the code assembly process for debugging and maintenance.
- Use GMacDSL macros to produce a series of optimized computationally equivalent low-level code in the target language of choice.

I’m very proud of my work in the GMacAPI as it contains many interesting techniques from computer science and software engineering; especially techniques related to code block optimization. The tasks in which GMacAPI can be used are diverse and wide-ranging. I’ve tried my best to make it as simple as possible for a good software Engineer to use a given GA-model and create a full code library out of it. Because such goal is not easy to reach, using the GMacAPI component requires a good deal of learning and experimentation. I hope in the future to make it more accessible through some form of Visual Interface in which the software engineer can lay out the components, connect, and configure them visually with few lines of code as possible.

Conceptual integrity is the most important consideration in system design. — Fred Brooks, “The Mythical Man-Month”

Software documentation is a hard but necessary part of any software system. GMac is a sophisticated system with lots of interacting components. For a good part of 2015 and 2016, I concentrated on writing the online **GMac Guides**. The GMac Guides explain in good details the structure of the main components of GMac and how to use them as intended. While writing these guides I discovered some design deficiencies in some parts of GMac that needed fixing or enhancing. This is simply because I couldn’t explain them to myself in plain English, or with a direct example when I tried to write the GMac Guides.

Naturally, the full power of GMac can only be illustrated through practical examples. I’ve created the **GMac Samples** page on this website for this purpose. In time this page should contain enough examples that I hope would motivate users to explore the computational space using Geometric Algebra and GMac.

Space: the final frontier. These are the voyages of the starship Enterprise. Its continuing mission: to explore strange new worlds, to seek out new life and new civilizations, to boldly go where no one has gone before. — Captain Jean-Luc Picard, Star Trek: The Next Generation

I’m writing these words on the 9th of February 2017; it is my 40th birthday. This post is my final thoughts on the 8 years journey creating my own vessel for exploration, GMac. I don’t know if I will actually get to use it, as I hope, to explore the computational universe. I still need to add a visualization component and a multivector differentiation component to the mix. I also hope I could modify the design to use other CAS like SymPy or Maple and add a Visual Interface to create GMacDSL code that should be developed to apply functional programming techniques. Many other enhancements and components are possible. Nevertheless, I have learned a lot as I initially expected. I’m now ready to explore applications and algorithms with my own tool. I’m ready to contact other people to exchange ideas and investigate possibilities. I’m ready to begin a new journey as this one ends.

The post GMac: The Next Generation (2 of 2) appeared first on Geometric Algebra Explorer.

]]>The post GMac: The Next Generation (1 of 2) appeared first on Geometric Algebra Explorer.

]]>The belief that complex systems require armies of designers and programmers is wrong. A system that is not understood in its entirety, or at least to a significant degree of detail by a single individual, should probably not be built. — Niklaus Wirth.

In the summer of 2003, I was almost at the end of my M.Sc. thesis. One day I was surfing the web searching for some references to add to the thesis I’d been writing. I ran into Mikael Nilsson’s interesting M.Sc. thesis “Geometric Algebra with Conzilla: Building a Conceptual Web of Mathematics”. His work contains a nice introduction to Geometric Algebra, with accompanying UML-based conceptual models. It got me very curious about GA. I made some more searches finding a few papers, books, and tutorials. After reading some of them I was suddenly transferred into a new world of algebraic abstractions. For the first time in my life as a student, engineer, and software developer I could hope to express, explore, and manipulate geometric abstractions with such clarity. I then decided that my Ph.D. will be about exploring Geometric Algebra using the best way I know: developing software. It was a natural decision to make given GA’s potential, but a hard and lonely journey to make. About 8 years have passed now developing my tool, **GMac**, into its current state all by myself passing through difficult events I could only have passed by Allah’s well and mercy.

In this post and the next, I talk about this journey and some of the lessons I learned along the way. I talk about how the current GMac design came to appear and the joys I found learning the hard way that profound belief ^{1}, solid foundation, clear goals, and lots of patience are together the only way to realizing distant dreams.

I had a very selfish reason for building Mathematica. I wanted to use it myself, a bit like Galileo got to use his telescope four hundred years ago. But I wanted to look, not at the astronomical universe, but at the computational universe. — Stephen Wolfram.

In the Autumn of 2005, I’d just begun my Ph.D. preparatory courses when I had another perceptual shift, this time in how I think about computations. I found Stephen Wolfram’s 2002 fascinating book **“A New Kind of Science” (NKS)** after watching one of his lectures about it. After reading a few pages of NKS online, I couldn’t stop until I finished reading the whole book, without the endnotes, in just 2 weeks. I couldn’t wait to buy the book because it would take at least a month to arrive back then so I read it online.

Reading this book made me rethink about many concepts of science, mathematics, and computation that I took for granted. Concepts like numbers, chaos, randomness, complexity, intelligence, mathematical models, and the nature of computation. Although I don’t agree with everything he says in his book, Wolfram’s insights and explorations are fascinating and inspiring for someone like me. The most intriguing of all the concepts he talks about is the **Computational Universe**. Wolfram used cellular automata and similar computational tools for mapping and mining the computational universe.

I instantly realized that Geometric Algebra can be a uniquely valuable tool in any attempt to explore the computational universe. I just needed the right computational vessel to make such explorations. I searched a lot but found none that suited my goals. I read that Wolfram had created **Mathematica** as his personal lab for doing computational experiments. All this made me decide to create my own GA-based tool for voyaging and exploring the computational universe, and so my journey began.

Good judgment comes from experience, and experience comes from bad judgment. — Frederick P. Brooks

When it comes to repetitive tasks, good software developers are the laziest of people; they prefer to create programs to do the repetitive tasks for them ^{2}. To be more accurate, their deep creativity drives their apparent laziness. They never want to do the same task twice, and if they have to, they never want to do it in the same way. They almost always enjoy finding the most general framework for doing several tasks at once with minimum effort; I’m one of those people.

I started my actual Ph.D. research work in 2007 by studying GA mathematics through reading the excellent book “Geometric Algebra for Computer Science“. In 2008 I started to investigate several software designs and implementations in hope to implement a single perfect universal GA-based software library.

Driven by my creative laziness, I initially thought that the powerful unification GA brings to mathematics can be directly translated into a unified software library suitable for all Geometric Computing purposes. I was naive back then with little experience in the difficult problems that face designing large sophisticated multi-purpose software systems. I gradually realized that this perfect software library is a myth. While working on the development of two big decision support software systems based on relational databases for several years, I gradually gained experience in the true meaning of the phrase “Necessity is the Mother of Invention”.

Successful software libraries are mainly driven by necessity not only by the elegance of some underlying abstraction, even a beautiful algebraic abstraction such as GA. Each particular application has its own set of necessities that we, software engineers, call requirements: functional, non-functional, financial, scope related, performance related, etc. There can never be a single perfect software library suitable for all applications in a wide-ranging domain like Geometric Computing.

Failing in my initial attempt I went higher in the level of abstraction. I had a good background in Object-Oriented (OO) Software Design. Why not, I asked myself, create an OO design based on the mathematical concepts of Geometric Algebra and then derive specific concrete implementations for specific applications. After all, this is how I learned about GA originally; using UML to diagram GA’s main concepts and relations. I soon found that OO design is a good conceptual tool to study some domain, but there can never be a single OO design suitable for all purposes either; especially when good memory\processing performance is critical ^{3}. This got me to learn about other programming paradigms I’ve never considered reading about before.

One principle problem of educating software engineers is that they will not use a new method until they believe it works and, more importantly, that they will not believe the method will work until they see it for themselves. — W. S. Humphrey, The Personal Software Process

Back in 2009, I only knew about procedural programming and object oriented programming. I did some reading and discovered many other paradigms like functional, aspect-oriented, concurrent, dynamic, feature-oriented, and more. I realized that GA can be used equally well as an algebraic base for creating software in all of these paradigms. My deep creative laziness led me to the most general of all paradigms: Automatic Meta-Programming.

In April 2009 I bought and read the book “Generative Programming: Methods, Tools, and Applications” in which the authors present a grand tour of Generative Programming that is bound to become a classic. The book focuses on the generally unappreciated connection, back then, between **Domain Specific Languages (DSLs)** and Generative Programming as a motivation for future developments. I immediately started designing and implementing the first prototype of my dream GA-based software vessel for exploring the computational universe; I called it GMac. The prototype took a couple of months to be functional for the purpose of completing my Ph.D. ^{4}.

I tried to apply some of what I’d learned from the Generative Programming book to implement simple GA-based algorithms, which I call * G*eometric

Using Automatic Programming and Code Generation is a fundamental design decision I made for GMac. My experience with OO design can be expected to extend to all other programming paradigms. There can be no universal design methodology suitable for all applications. Even more, in a single large application, we might need several paradigms to be used ^{5}. The only common activity between all paradigms is the creative composition of structured textual code that is both human-readable and machine-compilable. Instead of trying to force some kind of fixed design method upon GA-based application developers, we can just provide a set of powerful tools to help them in composing their application in whatever programming paradigm, software system design, or programming language they choose. I still believe this is the best, most effective, and most general way to use GA in software development.

I had to resign from the University to continue my intellectual research project. — Professor Abdel-Wahab Elmessiri

^{6}

My Ph.D. part of the journey was completed in April 2010 when I defended my thesis. It was an exhausting part of my life with many difficulties resulting from working in an anti-scientific, anti-creative environment by design; especially for introverted people like me ^{7}. In this difficult environment, I met many talented, highly creative, and mostly self-educated people. These people motivated their colleagues and students to make the best research possible and sincerely promoted good education. I’m very grateful for their presence in my life. The system itself is designed to kill the hope in such talented people or drive them out into more scientifically and humanly attractive environments ^{8}. As Barry Schwartz ^{9} describes it in his beautiful TED talk:

It is not true that you “just can’t get good help anymore.” It is true that you “can’t get good help anymore” when you give people work to do that is demeaning and soulless. And interestingly enough, Adam Smith — the same guy who gave us this incredible invention of mass production, and division of labor — understood this. He said, of people who worked in assembly lines, of men who worked in assembly lines, he says: “He generally becomes as stupid as it is possible for a human being to become.” Now, notice the word here is “become.” “He generally becomes as stupid as it is possible for a human being to become.” Whether he intended it or not, what Adam Smith was telling us there, is that the very shape of the institution within which people work creates people who are fitted to the demands of that institution and deprives people of the opportunity to derive the kinds of satisfactions from their work that we take for granted.

You can get some idea about the results of this sad situation by reading this 2011 article by Hillel Ofek: “Why the Arabic World Turned Away From Science“. I can only pray and hope this situation changes in the near future.

In 2010 I made a mistake trying to publish my Ph.D. work as an article in a high-profile journal not concerned about Geometric Algebra. They rejected the article for good reasons, mostly not related to GA but to the article itself. The editor gave me a piece of advice going around Geometric Algebra having nothing new to offer in terms of applications in computer science. He emphasized that more effort must be made by the GA community to overcome this situation by finding new insights that only GA can provide. I realized then that choosing to do research using GA is a lonely path to take. Recently, I made some interviews with leading researchers in the GA community who stated this experience in similar words. The situation has gotten much better in the last couple of years where GA-related research started to appear at increasing rates in many fields in engineering and computer science.

After completing my Ph.D. back in 2010 I knew I had to design a new version of GMac to realize my dream vessel for exploring the computational universe with Geometric Algebra. I knew it would be a difficult journey to make. As Walter Bright puts it in his article “So You Want To Write Your Own Language?“:

First off, you’re in for a lot of work…years of work…most of which will be wandering in the desert. The odds of success are heavily stacked against you. If you are not strongly self-motivated to do this, it isn’t going to happen. If you need validation and encouragement from others, it isn’t going to happen.

Nevertheless, I was certain that GA will be accepted in the near future as a major language for mathematical modeling in computer science and engineering. I was also certain that I will gain much experience and feel many joys developing the next generation of GMac. I could only work on my project alone against the surrounding environment for two to four months per year because of my many family obligations and non-research work duties. These available months weren’t even consecutive; they were spread along the year with no apparent order. During all these years whenever I got an opportunity to make research I faced a difficult question. Should I focus on writing papers in computer science topics not related to Geometric Algebra to be promoted? Or should I invest the little time I had in developing my dream vessel? I always chose the second.

After I finally got promoted to Assistant Professor ^{10} in July 2010 and for another full year up to Summer 2011, I had to find additional jobs to support my family, so I had to delay developing the next generation of GMac until August 2011.

In the final part of this series, I will talk about the next phase of my journey developing GMac’s next generation. I will explain its main components and how I arrived at their design.

The post GMac: The Next Generation (1 of 2) appeared first on Geometric Algebra Explorer.

]]>The post Elements of Geometric Algebra appeared first on Geometric Algebra Explorer.

]]>Geometry can in no way be viewed… as a brach of mathematics; instead, geometry relates to something already given in nature, namely, space. I also had realized that there must be a branch of mathematics which yields in a purely abstract way laws similar to geometry. — Hermann Grassmann

Any useful mathematical structure consists of some integrating abstract elements. The mathematical structure of Geometric Algebra is sophisticated but very elegant and easy to understand. In my view as a software engineer, I could identify 10 main elements ^{1} of the mathematical structure of GA. Some of these elements are well studied mathematical disciplines by their own right. The integration of the 10 elements, however, produces a rich mathematical language capable of expressing much more than the mere sum of its parts. In this post, I will describe each component and talk a little about its significance and varieties without delving into any mathematical details. The interested reader can find many tutorials and links to explain in full details the mathematics of Geometric Algebra on my GA Online Resources page. The information in this post can be useful for someone starting to study GA and wanting a clear roadmap for understanding and relating its main concepts and algebraic tools.

You don’t see something until you have the right metaphor to let you perceive it. — James Gleick, Chaos: Making a New Science

It’s physically hard to leave the Earth into space. We need to construct a complex system with lots of engineering effort to overcome Earth’s gravity. It’s been conceptually harder for people at some times in history to imagine this is even possible, or that the Earth is actually round for that matter. As soon as we got out there, we could create a whole new world of concepts, possibilities, activities, and applications related to space exploration that affects our daily lives.

A similar situation exists in the way we understand and model our physical reality. We tend to be conceptually limited to think geometrically using 3D Euclidean space; even 2D for many people. This tendency is most apparent in our reliance for more than a century on 3D vector analysis with its limited mathematical structure and special-case algebraic operations of dot product and cross product extracted from Hamilton’s algebra of quaternions ^{2}. To escape from this conceptual prison, we need to embrace 19th-century geometry ^{3} with its transcending dimension independent concepts and ideas. The problems we face while trying to understand and use this fascinating set of geometric ideas are analogous to difficulties we faced trying to reach the escape velocity of the Earth. We need a powerful mathematical structure to symbolically encode, manipulate, and explore such concepts and ideas freely. Geometric Algebra is the most powerful candidate for this difficult task. To understand the reason, we need to understand GA’s main elements and how they integrate to construct an algebraic language suitable for exploring these transcending geometric ideas better than any other single algebraic tool currently available.

At the base of geometric algebra structure, we find the scalars (i.e. numbers) used in representing and processing geometric quantities. We mostly work with rational, real, and complex scalars in our geometric models and applications. At the most abstract level, all three number systems have essential abstract properties in common, given the mathematical name of Fields. Many other, rather strange, mathematical fields (number systems) exist and can be the basis of constructing a geometric algebra for some specific application, such as finite fields, p-adic numbers, and hyperreal numbers. On the other extreme, in the lowest level of any geometric computing software implementation, concrete representations of numbers, like the notorious floating-points, are the practical data representation method. All geometric processing happens through primitive operations on numbers inside computers.

Historically, the first attempts to find an algebra to represent geometry resulted in trigonometry and analytic geometry. These two methods, still used today, essentially relate sets of numbers (representing coordinates, lengths, angles, areas, volumes, etc.) using many equations that can be useful in simple 2D and 3D geometric applications ^{4}. For more involved or abstract geometric reasoning tasks, the equations become too complex to be useful even for geometrically simple curves and surfaces. Eventually, the need for representing geometry in higher dimensions led to the development of vector spaces.

The second component in the mathematical structure of geometric algebra is a finite dimensional Vector Space over the selected field. Here the term “vector” is taken in its most abstract meaning as a mathematical entity satisfying specific properties. The main purpose of vector spaces is to study properties of sets of entities closed under Linear Combinations. Many objects in mathematics can be used as vectors in this abstract context including:

- Classical Euclidean vectors over real numbers (straight arrows having “length” and “direction” in space).
- Any field is actually a 1D vector space over itself.
- Coordinate spaces which are tuples of the same size along with addition and scalar multiplication are common representations of vector spaces.
- Matrices are vectors with additional structure.
- Polynomials of one or more variables.

To correctly understand Geometric Algebra we must first understand Vector Spaces. This can only be done from the Abstract Algebra point of view ^{5}. not the coordinates-based Matrix Algebra point of view ^{6}. It’s important for engineering and computer science students to be exposed to abstract algebra in their early study to free their minds of the numerical coordinate based representations and ascend to the level of abstraction necessary for Abstract Geometric Thinking ^{7}. In summary, a vector is a symbolic abstraction different from the concrete tuple of coordinates that can represent it numerically within a given basis set.

One of the simplest geometric figures we know about from early childhood is the circle. When we grow up a little, we are told that a circle is the set of all points having **equal distance** from a fixed point, its center. When we grow up more we discover that the concept of **distance** has many meanings. For example, if we study physics and read about relativity we find a very strange kind of distance defining what is called the Minkowski Space where two different points can have a distance equal to zero! Because the difference between two points (positions) is, geometrically, a vector (direction), we may have a non-zero vector with zero length in this strange space! Such kinds of distances are found all over physics, engineering, and computer science. The familiar Euclidean Space is just a special case in this collection.

Mathematically, we capture the concept of distance using Metrics and use it to define Metric Spaces having Metric Geometry. It’s not possible to model many important relations between points, vectors, and subspaces without first defining a metric. Properties and relations like distance, length, angles, orthogonality, etc. require a well-defined metric. By associating different metrics with the same vector space, we completely change the kinds of geometric concepts we can describe. This is why the metric we select for constructing a Geometric Algebra is very important in all following geometric interpretations of the space and its multivectors.

Applying the Geometric Generators pattern to different metrics results in very different sets of points. For example, using a point C and number r we can generate a circle by finding all other points having distance r from C. In Euclidean space this generates the familiar round set of points we call a circle. In other metrics, the result is quite different. The beauty of 19th-century geometry can only be viewed using such important mathematical concept, which is also a fundamental part of the construction of Geometric Algebra.

Algebraically, we can use the **inner product**, the **dot product** in Euclidean space, of vectors to represent the metric associated with their vector space. For the construction of Geometric Algebra, a better algebraic foundation of a metric is to use a **symmetric bilinear form** or the equivalent **quadratic form**.

As engineers, we tend to perceive a Linear Transform as a matrix that when multiplied by a coordinate vector generates another. This is another case of mixing the representation with the concept. Just as vectors are abstractions, linear transforms are abstractions. We should understand that matrices are not the only, or even the best, representations for linear transforms in all cases.

This way of thinking explains why many properties of matrices, including square matrices, are invariant under change of basis linear transforms like rank, having an inverse, orthogonality of its row\column vectors, eigenvalues, determinant, etc. These properties are independent of the selected set of vector basis and are actually properties of the abstract linear transform the matrix represents. Some operations on matrices preserve such properties and can be used to study the linear transform, while other matrix operations are pure calculation without significant meaning with regard to the linear transformation the matrix represents. Studying Geometric Algebra requires this level of distinction especially when generalizing linear transformations from being applied to vectors to being applied to subspaces, i.e. outermophisms operating on GA blades.

In engineering, the use of linear transformations is particularly important. Most engineers are taught to use and analyze linear systems at an early stage of their study. If we model a physical system as an abstract linear system, we can analyze the response of the linear system to a complicated input signal by analyzing the signal into simpler ones. Here we consider a signal as a vector that can be expressed as a linear combination of basis vectors (basis signals). Now using the composite linear transform the system performs we can compute the system output for each basis signal and apply the same linear combination of outputs to obtain the total system output due to the full input signal. This is called the Superposition Principle; a cornerstone in modern engineering.

One important use of linear transforms in geometric modeling is the representation of Projective Transformations (Homographies) between Projective Spaces. The study and use of Projective Geometry are fundamental to many applications in Computer Graphics, Computer Vision, Robotics, and Image Processing. Geometric Algebra is a perfect fit for expressing and developing ideas related to projective geometry as illustrated by the many articles relating GA to Projective Geometry both theoretically and practically.

If we use GA to model some practical problem, we probably need several GA spaces each representing one aspect of the problem. In this case, we need to define several linear transforms to switch between the GA spaces. As I will explain shortly, linear transforms on vectors can be automatically extended to subspaces using Outermorphisms. This way, any multivector can be transformed between GA spaces as we need.

Now we get to the new, and fun, elements of geometric algebra. A direction vector V in Euclidean space can be used to represent an infinite straight line passing through the origin O parallel to the vector V. By multiplying a scalar with our vector and adding the result to the origin point we can generate any point on this specific line. We can also take any point P on this line and find the vector W = P – O. Now V and W are linearly dependent because they are just scaled versions of each other. This construction is familiar to most of us, but the following generalization is not. From this kind of construction we can abstract some general properties of a vector:

- A vector is an algebraic representation of a one-dimensional subspace of the vector space (the line passing through the origin in our Euclidean space example).
- Many vectors can represent the same subspace; just by varying the scalar they are multiplied by we get a new algebraic representation. All these vector representations are linearly dependent.
- The main geometric properties of any vector are: its dimension (one), its attitude in space, and the scalar it’s multiplied with (its geometric length in the special case of Euclidean spaces)
- Vectors within the same subspace can be linearly combined to produce other vectors in the same subspace, they can also be compared, by a division, to extract their relative “lengths” or associated scalars.

These 4 properties can be generalized to subspaces of higher dimension (2, 3, etc.) within the larger vector space. We can use new algebraic operation called the **Outer Product**, or the **Exterior Product**. Using the outer product of several vectors we get a new algebraic concept called the **Blade**. Blades come in grades depending on how many Linearly Independent (LID) vectors are multiplied using the outer product. We then have 0-Blades (simple scalars or numbers), 1-Blades (vectors), 2-Blades (bivectors or the outer product of two LID vectors), 3-Blades (trivectors), etc.

The general characteristics of blades follow a generalization of vectors with an additional structure provided by the outer product:

- A blade is an algebraic representation of a k-dimensional subspace of the vector space (the line, plane, volume, hyperplane passing through the origin in our Euclidean space example). Any vector having zero outer product with a blade is inside its subspace. This is called the
**Outer Product Null Space (OPNS)**representation of subspaces. - Many k-blades can represent the same k-dimensional subspace; just by varying the scalar they are multiplied by we get a new algebraic representation. All these blade representations are linearly dependent.
- The main geometric properties of any k-blade are: its dimension (k), its attitude in space, and the scalar it’s multiplied with (its geometric length, area, volume, etc. in the special case of Euclidean spaces).
- Blades representing the same subspace can be linearly combined to produce other blades
^{8}in the same subspace, they can also be compared, by a division, to extract their relative “weights” or associated scalars.

Many of the algebraic and geometric operations we are used to doing with vectors and numbers can be done more elegantly using blades. The most important benefit of using blades and the outer product is to algebraically capture the concept of linear independence. To find if a vector belongs to some subspace using classical matrix-based linear algebra, we need to solve a set of linear equations, This is essentially a complex algorithmic procedure, not a simple abstract algebraic operation that can be combined with other algebraic operations. Using a blade that represents our subspace, we can simply take the outer product with any vector and if the result is zero the vector belongs to the subspace. The more we reduce the need for “matrix manipulation algorithms” and use basic symbolic algebra instead, the more clear and unified our mathematical models become.

Vectors belonging to different 1-D subspaces in the Euclidean space can be compared and manipulated in several ways:

- We can find the “length” of a vector using its inner product with itself.
- We can find the “angle” between two vectors using their inner product and lengths.
- We can project a vector on another also using the inner product.
- We can convert a set of LID vectors into orthogonal ones also using an algebraic process that depends mostly on the inner product.

It seems that the inner product is an essential operation in vector algebra. Extending vectors to blades require comparing and manipulating blades using a similar operation. Many generalizations for the inner product exit with varying algebraic properties and geometric significance.

The **Left Contraction Product** is one such algebraic generalization defined on blades with strong geometric significance. In Euclidean space, if we have an r-dimensional subspace represented by the r-blade A, and an s-dimensional subspace represented by the s-blade B, and r is less or equal to s, then the contraction of A on B represents a new (s-r)-blade (an (s-r)-dimensional subspace) obtained as follows:

- Project A’s subspace on B’s subspace, assume this gives a subspace represented by a blade P.
- Find the orthogonal complement of P’s subspace within B’s subspace. This orthogonal complement is represented by blade C computed algebraically from the left contraction of A on B.

We can summarize this process saying tat the left contraction of A on B finds the blade orthogonal to A’s projection within B. This fundamental operation on blades has many important mathematical and geometric properties that can simplify computing with subspaces. Instead of computing with the vectors that span a subspace, using matrix algorithms, we can now directly do all the following operations on subspaces of any dimension without the need for their spanning vectors, and without the need for matrix algebra:

- Find the “norm” (length, area, volume, etc.) of a subspace.
- Find the unit blade that represents a subspace.
- Find the “inverse” of a blade; the same blade divided by its squared norm.
- Project a subspace on another subspace.
- Find the angle between two same-dimension subspaces (assuming they intersect in a single line).
- Test the orthogonality of a vector to a whole subspace.
- Find the orthogonal complement of a subspace within a larger subspace.
- Generalize the notorious cross product to any dimension. The cross product of two vectors in 3D Euclidean space is geometrically equivalent to the orthogonal complement of the plane spanned by the two vectors.
- Indirectly represent a subspace with a blade as the set of all vectors having a zero contraction with the blade. This method is called the
**Inner Product Null Space (IPNS)**representation of subspaces. We can convert between the IPNS and OPNS using a simple dualization algebraic operation.

In summary, using the outer product we create OPNS blades to directly represent subspaces. Using the contraction we convert between the OPNS blade and an IPNS blade representing the same subspace indirectly. Using both operations on blades we get a rich algebra for computing with subspaces of any dimension with any metric. Using the addition operation we can now define linear combinations of blades of different grades to construct **Multivectors**; a powerful and geometrically significant algebraic alternative to matrices and tensors. All linear operations on blades can be extended using linear combinations to act on multivectors. This beautiful mathematical structure is called the Grassmann-Cayley Algebra and is used extensively to study projective geometry; an important part in the full construction of Geometric Algebra.

As we generalized the metric, the inner product, to act on blades, we now generalize linear transforms on vectors to act on blades. An **Outermorphism** is a simple extension of a linear transform with many fascinating properties and implications:

- First, we begin with an abstract definition of a linear mapping f(.) between two vector spaces defined on the same scalar field. If the two vector spaces are the same, this mapping is called a linear operator or linear endomorphism. We may or may not use a matrix to define the linear mapping.
- Next, we extend the effect of the linear map to scalars by simply defining f(x) = x for all scalars x.
- Finally, we extend the linear map to act on blades by making it invariant to the outer product. Meaning that the transform of the outer product of some vectors equals the outer product of the transforms of the vectors.

Using this simple algebraic extension we can apply any linear transform to blades and multivectors. We can symbolically study in a coordinate-free manner the effects of linear transforms on subspaces, not just single vectors. We can numerically compute the outermorphisms of blades using sparse matrices. This can be very useful in many numerical linear algebra algorithms and certainly deserves much more attention than is currently given.

Using outermorphisms, many abstract concepts related to linear mappings are much easier to express and understand:

**Determinants**are classically associated with square matrices, but they are actually more related to linear operators. For a linear operator, its determinant is the ratio of the effect of the linear operator on the space Pseudo-scalar blade relative to the Pseudo-scalar blade itself. The whole theory of determinants can be derived from outermorphisms much more elegantly and clearly without any use of matrices or coordinates.- The
**adjoint linear operator**is also classically associated with square matrices while being a more abstract and fundamental concept of linear operators. Outermorphisms also represent adjoint operators in a more natural way both symbolically and numerically. - We can study many properties of the
**inverse of a linear operator**using outermorpisms. We find, for example, that to apply the inverse operator to an IPNS blade we need a different algebraic treatment^{9}than that in the case of an OPNS blade to get geometrically consistent results. - We can use outermorphisms to represent a very important class of linear operators: the
**Orthogonal Transformations**that preserve the metric of the vector space^{10}. Orthogonal transformations are typically represented using orthogonal matrices, but outermorphisms provide many useful and geometrically significant insights about their abstract coordinate-free properties.

With outermorphisms we have all the mathematical structure of Linear Transforms generalized to subspaces of any dimension. With the Outer Product, Contraction, and Outermorphisms we have a large toolset for computing with subspaces without the need for subspace decomposition or depending on matrices and coordinates.

The final algebraic ingredient of the fascinating GA mathematical structure is the **Geometric Product**. The geometric product is the most general bilinear product in GA between arbitrary multivectors. The outer product, contraction, and all other bilinear products are special cases of the geometric product and can, in fact, be defined based on the geometric product alone. The full algebraic structure of GA can be stated axiomatically based on the geometric product and addition operations without using the other products. Personally, I don’t like this pure mathematics approach because it delays the geometric significance to a later stage. For so many years, **Clifford Algebra** was treated just like any other algebra in pure mathematics, and the powerful geometrically significant structure we are talking about here was hidden behind the cold symbols and pure algebraic relations.

One important tool the geometric product provides is the ability to reflect a vector c in another vector n directly, or in the hyperplane n indirectly represents. This seemingly simple but very useful algebraic tool opens the door for the powerful versor representation for orthogonal linear operators we will talk about in the next section.

Versors constitute a very useful class of multivectors. A versor is the geometric product of several vectors, each having a non-zero inner product with itself. If the vectors are also orthogonal, the versor is actually a blade. Because of this, every versor has an inverse with respect to the geometric product. The geometric significance of these algebraic properties can be found by reading an important result of the

The geometric significance of these algebraic properties can be found by reading an important result of the **Cartan–Dieudonné theorem**:

Any Orthogonal Transformation is a composition of a series of reflections in homogeneous hyperplanes.

This theorem is the base of the Householder matrices in classical linear algebra for example. Because we can express reflections in hyperplanes using a simple geometric product of vectors, any orthogonal transformation in our GA can be expressed as a series of geometric products with vectors. This important algebraic tool is called the **Versor Product**.

Special kinds of versors exist having important practical applications. For example, a **rotor** in Euclidean GA is the geometric product of two unit vectors that is algebraically isomorphic to complex numbers (in the 2D GA case) or to quaternions (in the 3D GA case). Rotors are very useful and efficient tools for applying rotations to arbitrary subspaces with many properties better than rotation matrices and other related representations.

In fact, using the versor product all isometries of the base vector space can be algebraically represented using multivectors. In this way, multivectors represent both **Geometric States** (subspaces as blades) and metric-preserving **Geometric Actions** (orthogonal transforms as versors). We now have a very powerful, compact, and geometrically significant algebra ready for our final step: ascending to higher dimensions.

Thus, in a sense, mathematics has been most advanced by those who distinguished themselves by intuition rather than by rigorous proofs. — Felix Klein

The previous 9 elements of GA construct a set of algebraic tools to conceptually escape into higher dimensions. To understand the significance of this process, we can study a simpler example having a great practical impact in computer science and engineering: **Homogeneous Coordinates** and the related **Homogeneous Transformation Matrices**.

In Euclidean space, simple geometric concepts like points, general lines, and planes can’t be mathematically represented as elements of a linear vector space; they simply don’t satisfy the abstract axioms of vector spaces. In 1827, August Ferdinand Möbius introduced homogeneous coordinates, or projective coordinates, to solve this problem. By **embedding** our Euclidean space into a one-dimension-higher projective space, we could easily model additional geometric concepts as finite projective vectors like directions, points, points at infinity, and weighted points. This algebraic tool has greatly impacted many applications in engineering and computer science including robotics, computer graphics, computer vision, computer-aided design, and more.

Using the powerful algebraic elements of Geometric Algebra we can exploit the idea of embedding a space inside a larger space to its fullest. Many geometric concepts can be “algebraically linearized” this way; meaning they can be completely represented using multivectors, instead of the commonly used combinatorial geometric representations. This transition in representation can have profound conceptual and computational effects on many important areas like computational and discrete geometry, for example. To get an idea about such geometric concepts, here is a list of some geometric states (objects) and actions (transformations) that can be represented by multivectors (GA blades and versors) in the 5D Conformal Geometric Algebra (CGA). The 5D CGA is the result of embedding our 3D Euclidean space into a 2-dimensions larger conformal space having a Minkowski metric:

**Round and Flat Geometric Primitives:**Spheres and Planes in general positions in space – General Circles and Lines – Point Pairs resulting from intersecting a line and a sphere, for example – Points as zero-radius spheres. We can even have rounds with imaginary radius and lines and points at infinity useful for many intermediate geometric computations.**Tangent Geometric Primitives:****Similarity Transformations:**Rotations, Translations, Uniform Scaling, Reflection in arbitrary Planes, and their compositions including**Motors**used extensively in representing Screw Motions.**Special Kinds of Conformal Transformations:**Most notably, reflections in spheres that can be composed into many useful transformations used, for example, to study Inversive Geometry.

All these geometric concepts and their **incidence relations** can be represented and studied with GA’s linear multivectors without any use of matrices, just by adding two more dimensions with a Minkowski metric to our 3D Euclidean space. Many more higher-dimension GA embeddings are currently studied ^{11} that can add more complex geometric objects and transformations to our list of typical geometric primitives. We are just at the beginning of a great journey of fascinating geometric explorations.

The post Elements of Geometric Algebra appeared first on Geometric Algebra Explorer.

]]>The post Cybernetics with Transdisciplinary Geometric Algebra appeared first on Geometric Algebra Explorer.

]]>Hard sciences are successful because they deal with the soft problems; soft sciences are struggling because they deal with the hard problems. — Heinz von Foerster

A Cyberneticist, or cybernetician, is a person practicing Cybernetics: a transdisciplinary approach for exploring regulatory systems; their structures, constraints, and possibilities. Professor Eduardo Bayro-Corrochano is one such leading academic who uses Geometric Algebra to handle the diverse fields of theoretical knowledge and practical application he needs. Such fields include Robotics, Neural Computing, Computer Vision, and Lie Algebras. In this post, I interview Prof. Eduardo Bayro who tells us about how using GA in his work can simplify dealing with such diverse fields, and how can GA relate, generalize, and unify ideas from these fields together in his mind and the minds of his students.

Professor Eduardo Bayro started working on the applications of GA in the late 1990’s. His work is to stress the application of GA in cybernetics which typically involves Robotics, Neural Computing, Computer Vision, and Lie Algebras. Using GA-based geometric computing he tackled problems related to the building of intelligent machines, particularly Humanoids, to formulate algorithms for dealing with computer graphics curves, spheres, hyperplanes, and simple geometric tasks. Another goal is to build intelligent machines with real devices using geometric control, geometric perception and even quaternion wavelet transform, quaternion spike, or quantum quaternion neurons. Currently, he is preparing a new book series of 3 volumes on these topics. He is laying out the theory of future geometric intelligent robots and machines with powerful FPGA and Nvidia geometric accelerators.

**Tell us about the benefits of using Geometric Algebra in Geometric Computing applications. **

Geometric Algebra (GA) is a powerful geometric language for the modeling of the physics of systems. It is a highly intuitive language and provides many algebraic tools very useful to tackle complex equation manipulations. GA allows economical representations of transformations due to the GA multivector representation as opposite to analytic geometry or vector calculus. GA-based representations avoid redundant parameters and elegantly encapsulate the geometry of the problem. As a result due to its economical representations, GA is a well-suited framework for the development of real-time computations.

**How can using GA simplify dealing with the diverse fields of interdisciplinary applications you are working on? What about its range of applicability?**

GA achieves the unification of many domains like multilinear algebra, multivariable analysis, conformal geometry, Lie group and Lie algebras, projective geometry, quantum mechanics and general relativity. GA allows:

- Extending and completing algebraic operations on vectors and multi-vectors.
- Providing unified concepts for geometry and algebra.
- Providing explicit interpretation of geometric entities and operations on them in arbitrary dimensions with Euclidean and pseudo-Euclidean metrics.
- Acting as an advanced formalism for rotations and in general Lie groups in arbitrary dimensions.
- Acting as a metalanguage for high-level reasoning.

Because of these features, Geometric Algebra has a wide range of applications: graphics engineering, signal and image processing, computer vision, neural networks and quantum computing, machine learning, and robotics.

**Tell us about the recent developments of applying GA in your research activities.**

Recent achievements in geometric accelerators using packets like Versor (P. Colapinto) or Gaalop (Geometric Algebra Algorithms Optimizer, D. Hildenbrand) allow us with FPGA or NVidia to accelerate computations even more. In my lab, we develop and build intelligent machines like in medical robotics or humanoids. The development of GA algorithms follows: algorithmic modeling, using our own C++ programs or Versor, then simply the algorithms with Maple or Gaalop and accelerate them with either FPFGA or Nvidia. The results are quite impressive for real time applications and the visualization of computing in higher dimensions which in turn helps us to gain insight and achieve correctness in the prove of theorems and improve the performance of our algorithms. We are working now to develop in the next 3 years a single small chip for geometric computing using GA with a power superior as the Jetson TK1 Nvidia card.

**In your opinion, are there any relations between Neural Learning and Geometric Learning? How do you use GA as a tool for exploring such relations?**

The tricky question is what should be a true geometric learning? We started by generalizing the McCulloch-Pitts neuron replacing its inner product via the geometric product, so the neural network weights are then multivectors and the learning rules are formulated using the gradient of multivectors as well. Our networks for classification via their kernels map the data using multivectors to a direct product of Hilbert spaces to separate multivector clusters, this helps a lot to find optimal hyperplanes. We have worked on geometric neural computing since 1995, in fact, we have generalized in GA most of the neural networks: i.e. multivector valued [SOM, NeuralGAS, MLP, ART], Clifford SVM and Quaternion Spike neural Network, currently we are developing the quaternion quantum Neural Network. This year we are also focusing on geometric high-order recurrent Neural Networks.

**Tell us about your books describing your valuable work and experience with GA, and the new books you are currently preparing.**

I have been teaching since 1997 using the material of my work which was then published in two books:

- Geometric Computing for Perception Action Systems. Eduardo Bayro-Corrochano, Springer-Verlag, April 2001.
- Geometric Computing: for Wavelet Transforms, Robot Vision, Learning, Control, and Action. Eduardo Bayro-Corrochano, Springer-Verlag, 2010.

I am preparing a more comprehensive series in three volumes:

- Vol. I: GA for computer vision and machine learning,
- Vol. II: GA for Robotics,
- Vol. III: GA for Signal Processing, Filtering, Transforms and Quantum Computing.

These three volumes are based on my first two books, of course, while including new exciting results. My books generally differ from many the current books on GA applications because my books cover computer vision, graphics engineering, neural networks, machine learning, robotics, integral transforms, and ultimately the endeavor of building intelligent machines with GA; they present real applications. The other books are more related to the foundations of GA and its restricted use to the develop algorithms in computer science and its sub-fields like computer graphics. That is why my continuous work during all these years is helping to be able to prepare these new three volumes, which I believe will certainly establish the true geometric computing for the future development of intelligent machines.

**Tell us about your practical experience teaching applied Geometric Algebra. How do you overcome the challenges you face while using GA in teaching?**

I call for studying and applying GA for future cybernetics in my lectures at different universities in Europe, North America (MIT) and Latin America. I have students with different backgrounds as in physics, mathematics, or engineering; some well prepared for some topics and less for others, so I start as in a fractal approach for conveying knowledge:

- We study 2D- and 3D-GA to become acquainted with the formulation of the geometric primitives and the use of different Clifford operations.
- Then we model the kinematics of points, lines and planes particularly to understand well screw theory and differential kinematics.
- Then I explain the basic of differential geometry like the Geometric Laplace-Beltrami Operator for applications in Euclidean and pseudo-Euclidean spaces.
- We study in depth Lie Groups and Lie algebras using spinors and versors for Euclidean, Affine, and 2D and 3D projective geometry.
- Then I explain projective geometry using Euclidean and Minkowski metrics for the projective plane and spaces and extensions of the projective space in R(3,3).

In this manner, the students have learned the most important ingredients to move the Conformal Geometric Algebra and high dimensional geometric algebras like G(6,3) and G(8,2). Thanks to our optimized routines for GA in C++ (with NVidia) and Maple (using the Clifford 14.0 package of R. Ablamowicz), we can prove theorems and develop real-time algorithms for intelligent machines.

The post Cybernetics with Transdisciplinary Geometric Algebra appeared first on Geometric Algebra Explorer.

]]>The post Geometric Algebra in Computer Science appeared first on Geometric Algebra Explorer.

]]>[Computer science] is not really about computers and it’s not about computers in the same sense that physics is not really about particle accelerators, and biology is not about microscopes and Petri dishes… and geometry isn’t really about using surveying instruments. — Hal Abelson

One of the most important fields of application for Geometric algebra can be found in Computer Science. In this post, I interview 3 key researchers who apply Geometric Algebra in their work to share their valuable experience and insights. Their applied research spans many applications in computer science including Computer Graphics, Robotics, Computer Vision, Image Processing, Neural Computing, and more.

**Tell us about your primary research and teaching interests. What sort of satisfaction do you get when working on your primary interests?**

My primary interest is the interplay between geometry and its algebraic representation. It is great fun to derive some equation solving a problem, and then hearing it begin to talk to you about aspects you had never considered in the original formulation. This works most strongly in GA, which is why I love that framework. However, it is hard to find funding for this in abstracto. I am currently tying it into a project on restoring broken archaeological artifacts based on 3D scans (project-gravitate.eu); in a theoretical work package, this pulls in my earlier work on geometric path planning and mathematical morphology and offers an opportunity to study finite elements methods from a GA point of view.

**What do you think are the main characteristics of GA as a mathematical modeling language?**

GA clears your mind and your software, even when you decide to stick to LA in practice (at least, in the beginning). The disgusting number of different terms and techniques in LA which are all, in hindsight, ways to avoid using the outer product are a good example. Once you realize that outer product exists, much of the operations described in natural language (like ‘span’) coherently collapse to elementary and compact algebraic operations under your own control. Certainly, in computer science where 3D is just not enough (the spaces involved in machine learning are very high-dimensional), the outer product MUST be taught. And once you have the outer product, you might as well absorb the geometric product for generalized projections and rejections. As for operators, use rotors instead of quaternions, so you have something that is real and that generalizes to n-D.

**Tell us about your important book, coauthored with S. Mann and D. Fontijne, “Geometric Algebra for Computer Science” (GA4CS). How can the GA community make more books like it to help attract more people to learn and apply GA in their research and teaching?**

After I just learned GA, I was amazed by the clarity it provides at the computational basis for geometry, and its new elements and operators at an intermediate level of abstraction: it is great to have the very interesting new primitives, especially in CGA (conformal geometric algebra). What can we do more or better once we learn to think in terms of those primitives? I knew I could not develop the consequences for intermediate and high-level algorithms myself — there is just too much reform to do, in too many fields. So we wrote a book to convey the basic tools and the algebraically supported intuition of their interplay, for others to do that work, each in their own subfield. It has not quite taken off yet in the way I hoped, though there are some examples (such as work by Ishida at Honda on genetic algorithms for road-following using GA primitives and their interactions as the chromosomes and cross-over operations). We need more work at that intermediate level, showing how or when the possibility not to go down to the vector level pays off.

**If you were to write a second book on GA mathematics and applications after 10 years of GA4CS, what new GA topics would you include? What new applications?**

At some point it would be good to collate some convincing applications of the new thinking, directly employing the intermediate primitives (like the Honda example above, or the application to GIS). Our 2011 ‘Guide to GA in Practice’ contains some good chapters in those directions, but a proper book would need more tight editorial coherence. I would like to see parts on projective geometric algebra since that is so important to graphics (I believe R(3,3) is the right model, but we still need to learn to encode the world in its primitives, the line complexes), and on finite element methods done in GA (with special emphasis on 3D meshes).

**What reasons made you want to do research related to Geometric Algebra? Tell us about the difficulties you faced ****and the satisfactions you felt during your journey with GA until now.**

When I started to work with GA in 2003, I was immediately very impressed how easy it is to develop 3D algorithms dealing with geometric objects and operations based on GA. I was very happy to use a tool providing me an immediate visual result for mathematical expressions: CLUCalc from Christian Perwass. I am still developing most of my GA algorithms with CLUCalc and, in my opinion, CLUCalc is still today the best tool in order to learn how to use Geometric Algebra for 3D applications.

In 2004, when I organized and presented a GA tutorial at the Eurographics conference in Grenoble together with Christian Perwass, Daniel Fontijne, and Leo Dorst, the feedback was positive and negative at the same time.

On one hand, many people were happy about the expressiveness of GA, but on the other hand, it was clear for everybody that implementations of computer graphics applications were not competitive in terms of runtime performance.

I realized that improving the runtime performance of GA will be the key to convincing engineers to use GA in their applications. At that time, nobody really expected that it could be possible for implementations of GA algorithms to be faster than the conventional implementation. But, in 2006, we were happy to present even two different implementations proving exactly that for a computer animation application (the movement of the arm of a virtual character).

**Tell us about Geometric Algebra Computing (GAC). What were your initial expectations when you started working ****on that topic? What is its current state? How do you see the future of GAC and its applications in computer science ****and engineering?**

Our approach for the just mentioned proof-of-concept application was very specific. This is why our next goal was a general system making it possible for almost every engineer to include GA in his/her application. And, the description of GA algorithms should be as much as possible similar to how CLUCalc ist doing that.

Now, we are happy to provide the Gaalop (Geometric Algebra Algorithms Optimizer) precompiler for the integration of GA into standard programming languages such as C++, OpenCL, CUDA and C++ AMP.

The integration is done based on GaalopScript, which is very much inspired by the CLUCalc scripting language. This technology is described in my book “Foundations of Geometric Algebra Computing” from 2013. Since 2015 this technology is part of the ecosystem of the HSA Foundation of more than 40 companies dealing with new heterogeneous computing architectures. Now, we have this technology available, as well as some other GA tools such as GMac, Gaigen, Gaalet and Versor, but the community working with it is still very small. The future of GAC and its applications in computer science and engineering relies heavily on whether we will succeed in closing this gap.

**What steps do you think should the GA community take to gain wider spread of GA among the larger community of engineers and computer scientists?**

Today, we indeed have this GAC technology available for easy to develop, geometrically intuitive, robust and fast engineering applications, but there is still only a small number of people knowing it. Exactly at this point, the book “Introduction to Geometric Algebra Computing”, that I am just writing, comes into place. The main goal of this book is to close the gap with an introduction of GA from an engineering/computing perspective. The intended audiences are students, engineers, and researchers interested in learning GAC. This book is intended to give a rapid introduction to the computing with Geometric Algebra and its power for geometric modeling. From the geometric objects point of view, it focuses on the most basic ones, namely points, lines, and circles. We call this algebra Compass Ruler Algebra since you are able to handle it comparable to working with compass and ruler. It offers the possibility to compute with these geometric objects and their geometric operations and transformations in a very intuitive way. While focusing on 2D it is easily expandable to 3D computations as used in many books dealing with the very popular Conformal Geometric Algebra in engineering applications such as computer graphics, computer vision, and robotics. This book follows a top-down approach. Focusing first on how to use GA, it is up to the reader how much he/she would like to go into the details.

Another attempt to gain wider spread is the ENGAGE (Empowering Novel Geometric Algebra for Graphics & Engineering) workshop as part of the CGI (Computer Graphics International) conference. This year, this will be in Japan (http://fj.ics.keio.ac.jp/cgi17/). But, sure, there is still the need of many good ideas in order to attract more and more engineers.

**I know you are interested in teaching GA in schools. From your point of view, what steps are required in the near future to reach a wide acceptance of this idea? What are the difficulties you see facing its achievement?**

Yes, you are right, I already have some experience with GA at schools. Because of its geometric intuitiveness, it is very easy for children to develop algorithms in GA. In some workshops, I could see that children are happy to solve simple robotics problems which they normally are not able to before university. A colleague of mine already taught special relativity based on GA at school. But the main problem is to make GA really part of the curriculum. Maybe some teachers/responsibles for curricula will use my above mentioned new book for teaching themselves and for introducing it already in school.

**During the previous years, you’ve been following the developments in applied GA through your GA Updates blog. How do you see the current state of GA research? In what application areas do you expect the next developments will probably be?**

Geometric Algebra research is not only revolutionizing algorithm development in many fields (robotics, visualization, mapping, virtual reality, GIS, molecular dynamics, telecommunication, offshore mechatronics, 3D cadastres, navigation, …), it also begins to exhibit superior accuracy, stability, and speed, and is increasingly introduced in mainstream computing ecosystems.

**What types of problems, from your experience, can be handled with GA more effectively relative to classical techniques in neural computing and signal processing? What kinds of ideas can be investigated in these two areas using GA’s powerful mathematics?**

In neural computing and signal processing Geometric Algebra allows to generalize 1D and 2D algorithms seamlessly to higher dimensions with great advantages for electromagnetic signals, including light and color, and it fully captures, analyzes and reproduces complex high dimensional geometric relationships and topology. It begins to be used for technologies needed for autonomous driving, color face recognition, land mine detection, speech recognition, new forms of tomography, …

**If you are talking to a new post-graduate student and trying to explain the benefits of using GA in his future research activities, what would you tell him about GA? What pitfalls would you warn him not to get into? What expectations should he have related to the future of GA research?**

Be ready to unlearn often inefficient, inaccurate, unintuitive matrix methods and systems of linear equations. Instead learn to think and work directly in terms of geometric entities, their relations, transformations, and interactions, all efficiently and invariantly expressed directly by geometric algebra entities and their products. Resist the initial temptation to fall back into coordinate system component techniques, which hide geometric realities behind veils of stupendous numerical arrays. Expect to liberate your geometric intuition, and be able to work with an advanced single universal integrative mathematical system for whatever problem or task you may face in the future.

**How can the GA community gain more supporters and members in the near future? What kinds of events, funding proposals, online activities, etc. should the GA community focus on to attain this goal?**

Organizing sessions and workshops at major science and engineering conferences is a good way. International collaborative projects might be another. Submitting research papers to all types of science and engineering journals, when the applications topic permits that, rather than highly specialized journals. Preprints published ASAP on servers like vixra.org, preprint.org, etc. and open access, will also help. In addition, sharing lectures and software demos on YouTube will help interested students, professionals, and engineers to know about geometric algebra even outside formal educational and academic workshop settings.

The post Geometric Algebra in Computer Science appeared first on Geometric Algebra Explorer.

]]>The post Founders of Geometric Calculus appeared first on Geometric Algebra Explorer.

]]>Our minds are finite, and yet even in those circumstances of finitude, we are surrounded by possibilities that are infinite, and the purpose of human life is to grasp as much as we can out of that infinitude. — Alfred North Whitehead

Foundations of modern Geometric Algebra and Geometric Calculus were laid down by Prof. David Hestenes and Dr. Garret Sobczyk 50 years ago. In this post, I interview Dr. Garret Sobczyk who tells us about his fascinating life journey with Prof. Hestenes. Their journey eventually inspired many researchers to follow their lead in learning, developing, and applying Geometric Algebra and Geometric Calculus to many fields of science.

**Dr. Garret Sobczyk**

Dr. Garret Sobczyk is Emeritus Professor of Mathematics, Universidad de las Americas-Puebla, Mexico. Dr. Sobczyk first learned about Clifford geometric algebras from Prof. David Hestenes as a graduate student in mathematics at Arizona State University in 1966. He became convinced early on that geometric algebra is rightly considered to be the completion of the real number system to include the concept of direction. He obtained his Ph.D. in mathematics in 1971 and eagerly set forth to convince the world. This quest led him to spend 5 years in Poland as a postdoctoral student at the Institute of Theoretical Physics in Wroclaw, before returning to the United States in 1983. He coauthored with Prof. David Hestenes the book, “Clifford Algebra to Geometric Calculus: A Unified Language for Mathematics and Physics”, published in 1985. He held several academic positions in the United States and Mexico, before settling with his Polish wife Wanda at the Universidad de Las Americas in Cholula, Mexico in 1993. He has published over 30 articles exploring the close relationships between geometric algebra and linear and multilinear algebra and other topics and is a member of Sistema Nacional de Investigadores de Mexico.

**Tell us about your early work with Dr. David Hestenes. What made you decide to work with him on the development of Geometric Algebra (GA) and Geometric Calculus (GC)?**

Thank you, Ahmad, for giving me the opportunity to share with you some of my early memories as a graduate student at Arizona State University (ASU) working in geometric algebra.

It was in 1965 when I had just completed my Master’s Degree in Mathematics and was looking for direction to continue my studies for a Ph.D. that I decided to explore possibilities in mathematical physics. Professor David Hestenes, a new professor at ASU, was offering a course in electrodynamics that caught my attention. On the first day of class, he began by introducing Geometric Algebra (GA) and the geometric product of vectors. I was amazed that I had never heard of the concept of a bivector as a directed area, or of the geometric product of vectors. It was over the course of that year that I decided that I wanted to dedicate my efforts for my Ph.D. into developing GA as a basic language in mathematics that I believed it to be then, and still do now a half a century later!

**I suspect it wasn’t easy for you to learn and apply Geometric Algebra back then. What did you do?**

Indeed, I did not have an easy beginning. David, at first suggested topics in Kellogg’s Potential Theory and Harmonic Analysis or generalizing Elliptic Functions. All of these were very good topics which have been extensively developed by European groups such as the Delanghe-Sommen group in Belgium, and others, but I was unable to make any real progress in these areas. It was at this point, almost in desperation, that I started to look at very basic ideas in linear algebra and differential geometry. Surely, if GA was indeed a basic language (over the continual skepticism of my Father; then a Professor of Mathematics at Clemson University, with a Ph.D. from Princeton University when he was a 23 year old), GA should offer new insights in these basic fields. Even to this day, most mathematicians believe that trying to reformulate differential geometry in GA is only putting old wine in new bottles.

I undertook a serious study of linear and multilinear algebra out of books by Gel’fand, Shilov, and Greub, and basic differential geometry. I was also greatly influenced by books such as “Science Awakening” by van der Waerden, Tobias Dantzig’s book, “Number The Language of Science”, Wilder’s “Evolution of Mathematical Concepts”, and Michael Crowe’s “History of Vector Analysis”. I considered my first “breakthrough” in linear algebra to be when I discovered how to derive the Cayley-Hamilton theorem in GA by first looking at the simplest 2-dimensional case. I spent a great deal of time developing the notion of the vector and simplicial derivatives in GA as a basic tool in linear algebra. Almost all of my 1971 Ph.D. thesis consisted of a systematic development of the general simplicial derivative as a basic tool in linear algebra.

It was only toward the end of my thesis that I was able to start making progress in laying down the basic ideas of Riemannian Curvature in differential geometry, material which David and I developed further over a period of four years afterwards, and would later make up the heart of our book “Clifford Algebra to Geometric Calculus: A Unified Language for Mathematics and Physics”, which wasn’t published until a decade later in 1984.

**Tell us about your steps after finishing your Ph.D. Were you able to easily get recognition for your groundbreaking work with Prof. Hestenes?**

After finishing my Ph.D. at ASU in 1971, I was unsuccessful in obtaining any academic position. The first academic job crunch was on and for every teaching position at a University or College there were hundreds of applicants, and Mathematics Departments to which I applied were suspicious of me working in an unknown area and with a young theoretical physicist as my thesis adviser. Fortunately, ASU kept me on for an additional year as a Visiting Assistant Professor, which gave us the chance to continue working closely together in developing GA. At first, we planned on publishing four papers, which later formed the basis of our book. The following year, I was still unsuccessful in obtaining any academic position.

At first, I visited a number of American University Mathematics Departments with well-known people in differential geometry, but none were interested in GA or in my work. I also realized that my basic knowledge of differential geometry was insufficient to convince anyone of any need to reformulate it in a new language. In 1973, I visited European Universities in different countries and was invited to give a number of talks about GA, but it was only in Poland that I was offered a Research Fellowship with the Polish Academy of Sciences, which allowed me to continue to develop basic tools in GA that eventually went into our book CA to GC in 1984. I returned to Poland in 1976 with a Postdoctoral Research Grant from Stoney Brook University in NY, allowing me to continue my work with new colleagues at the Institute of Theoretical Physics in Wroclaw until 1980.

**Were you able to use your knowledge of GA in teaching? How did you manage that in the following years?**

I enjoyed two academic appointments as an Assistant and Associate professor of Mathematics at Spring Hill College, Mobile, Ala., and at Lander College, Greenwood, SC in the 1980’s, and began developing material to teach undergraduate students GA and calculus. Finally, in 1984, our book CA to GC was published, which provided a needed boost to my career, but even to this day, the book has been largely ignored by the majority of the Mathematics Community.

It was difficult to teach GA and GC to students at this level because it usually takes a full year to get students comfortable with GA, and an undergraduate student is expected to master many other subjects as well. As my Finnish friend and colleague, the late Professor Pertti Lounesto remarked, about the best you can do is “smuggled it in” under the guise of closely related material, such as vector analysis and differential forms.

**We can see how difficult your journey had been following your ideas. Did the situation get better at a later stage?**

Fortunately, during the 1990’s and into the new century, Professor Hestenes was successful at drawing considerable new interest to the area among computer scientists and engineers, by utilizing GA in an innovative way to lay down the foundations of projective and conformal geometries.

In 1990 I accepted a very promising offer by Professor Jaime Keller of the Universidad Nacional Autonoma de Mexico to work with him as Assistant Editor of the new International Journal that he was creating, “Advances in Applied Clifford Algebras”, with the hope of both consolidating this growing field of research, and promoting wider international recognition. It was an exciting two years of growth, and of discovering the exotic culture of modern Mexico, alongside the ancient Mayan civilization that may well have been among the earliest to invent the concept of the number zero, and a base 20 type number system.

At the Universidad de Las Americas – Puebla, over the years 1993 – present, I continued to develop material for teaching GA at the undergraduate level, with an emphasis on basic linear algebra and elementary differential geometry, leading to the publication of my book, “New Foundations in Mathematics: The Geometric Concept of Number”, Birkhauser-Springer 2013. In this book, I emphasize the development of linear algebra and basic ideas of differential geometry in terms of GA, including the basic concept of the spectral basis. The idea of a spectral basis is what really connects the ideas of a geometric algebra to the traditional approaches to linear algebra and ubiquitous matrices. When GA is properly understood as providing a geometric basis for matrices, the well-established consistency of matrix algebra, in turn, proves the mathematical soundness of GA, without the need to go into more complicated arguments involving tensor analysis and the higher level abstract concepts of advanced mathematics. Also, in the book, I lay down preliminary material on application of the idea of a spectral basis in basic ideas in numerical analysis, such as Hermite interpolation and rational approximation.

**How do you see the current state of GA and GC among researchers?**

Clifford analysis, as developed by various groups, both in the United States and Europe enjoys recognition as a respectable area of research in advanced mathematics. In addition to the work of Professor Hestenes, Professor Baylis in Canada, other researchers in Mexico, China and around the World, geometric algebra has enjoyed increasing success among theoretical physicists in relativity and quantum mechanics. Clifford algebra is also used by some of the top theoretical physicists at prestigious universities in string theory and its generalizations. As you know, it has also attracted significant and growing attention in the computer science and engineering communities.

**What are your expectations of the future of GA and GC in teaching? What kind of research do you believe should be conducted to effectively relate GA and GC to mainstream mathematics and applications?**

I have no easy answer to this question. One of the main obstacles to teaching GA is the lack of powerful computer software to aid and check abstract hand calculations, although many new software products are becoming available. Two software packages that I have found to be useful in my teaching and research is the original stand-alone early numerical software package “CLICAL” by Lounesto, and the Mexican developed Mathematica Package [cliffordt.nb] 2007, by G. Aragon-Camarasa, J.L. Aragon, and M.A. Rodriguez. There are quite are a number of recent attempts to introduce GA at the undergraduate level that I am aware of. However, GA is still hardly recognized at all at the undergraduate level, as I firmly believe that it should be. I believe that it is the natural completion of the concept of number to include the concept of direction, and it should be taught that way down into the high school level. It is in this area that I have concentrated my own efforts. There is much left to be done to correctly lay down the foundations, even at a fundamental level, in order to facilitate progress at progressively more advanced levels in mathematics, physics, computer science, and engineering, including diverse areas such as quantum computing, robotics, the structure Lie groups and Lie Algebras, and artificial intelligence. The future lies in the hands of the younger generations.

The post Founders of Geometric Calculus appeared first on Geometric Algebra Explorer.

]]>The post Knowing About the World via GIS appeared first on Geometric Algebra Explorer.

]]>Our world is evolving without consideration, and the result is a loss of biodiversity, energy issues, congestion in cities. But geography, if used correctly, can be used to redesign sustainable and more livable cities. — Jack Dangermond

In this post, I interview Dr. Yu Zhaoyuan who explains the importance of Geographical Information Science (GIS) and the potential of Geometric Algebra as a mathematical modeling tool in this fascinating field of study. Dr. Zhaoyuan talks about the deep relations between Geometric Computing and GIS. He then tells us about the difficulties facing the creation of good GIS simulators and how GA can help in this regard. Finally, he talks about the recent GAGIS conference and the important research presented there.

**Dr. Yu Zhaoyuan**

Dr. Yu Zhaoyuan has a Ph.D. in Cartography and Geographic Information Science (GIS), Nanjing Normal University (2010). His research interests include GIS, geographical modeling, and human geography.

For the last eight years, Dr. Yu has systematically introduced GA into the GIS construction and developed key theories and technologies. He has made solid studies to develop GA-based unified multiscale representation theory for geographical space-time and also developed GA-based geographical data models, data structures, computational models, analysis algorithms, software systems and application/demonstration in various fields. He has been funded for 10 GA-related projects and joined 17 different projects as a core member or contributor. He published a total of 72 journal papers and gained 8 authorized software copyrights until the Dec-2016.

**Geographical Information Science (GIS) is a fascinating field of research, tell us about it and its impact on our lives.**

Geography is the study of the earth and its’ features, inhabitants, and phenomena, which is a discipline system studying the interaction, changes and spatial difference in all spheres of earth surface system. So, about 80% of everyday information is strongly related to the geographic position, and can all be called Geographic information.

GIS is a comprehensive technology system used for collecting, processing, management, analysis, expression and transmission of geographic information. The strong capabilities of data analysis and processing make GIS like the brain of Geography. Therefore, GIS can be a key platform not only for Geography research but also for social services. Until now, GIS is applied to various areas like resource investigation, environmental assessment, disaster prediction, land management, transportation, military police, water conservancy and so on.

To a country, GIS is closely linked to national development and security. For example, when first Gulf War broke out, the US military had won a decisive victory at a modest price, hitting the Iraqi army with a precise strike. The City GIS system of Iraqi, which is built with the help of U.S., provides critical battlefield geographic information to the U.S., largely determining the outcome of the war.

To industry applications, GIS undoubtedly enhances the production efficiency. Let’s take China’s logistics industry as an example. GIS established a perfect management system for it, which includes supply management, personnel management, path planning and so on. So, everyone can sit at home to buy all the things from Internet and then get your commodities after one or two days. To everyone’s daily life, “Uber Taxi” may be one of the best examples of GIS applications. People can search the taxi at service nearby, plan the route to your own destination with real-time calculated prices and query for interest points around all by smartphones, which profoundly changes the way travel.

**What other major branches of Engineering and Computer Science are directly related to GIS applications?**

GIS is an interdisciplinary science and makes use of many advanced achievements of Engineering and Computer Science. The major branches directly related to GIS applications I think are Topography, Graphics, Data Science and High-performance heterogeneous computing. Topography provides the data source and measurement calculation methods to GIS, and Data Science instructs the data storage, management, and analysis process of GIS data models. Graphics provides strong tools for GIS visualization. At last, High-performance heterogeneous computing gives GIS an efficient method for calculating, which is the energy of GIS applications.

**Tell us about the deep relations between Geometric Computing and GIS. **

According to the characteristics of GIS mentioned above, geographical objects expression and computation based on Euclidean geometry are highly dependent on object coordinates and coordinate systems and the expression and analysis of different dimensional geographical objects are at disunity. So, we need to find out a corresponding unified coordinate system to represent the geographical objects of a different scale from global to local. In GIS, we are not only studying the geographical objects but also the geographical phenomena and geographical process. Geographical phenomena and process are usually characterized as multidimensional features and span many different spatio-temporal scales. Moreover, as the fusion analysis of geometric objects with different dimensions, it is rather difficult to be linked and integrated effectively with geographical models. All in all, in GIS, we have got a lot of multi-source heterogeneous data which is referenced as geometry and developed much more analysis models which are referenced as algebra, but they cannot be integrated appropriately.

**So what benefits can Geometric Algebra provide in this context?**

Based on philosophical and physical considerations, it seems that only Geometry Algebra can solve these problems effectively. As a unified descriptive language, GA can connect algebra and geometry, mathematics and physics, abstract space-time and entity space-time. So, introducing GA to GIS has a prospective to improve the multidimensional expression and analysis ability of GIS.

Products in GA define spatial operation sets as geometries, measurements, topologies and directions, and have the ability to achieve expression and mutual transformation among various kinds of space, and thus support unification and expression of various algebra and geometric system. Under the GA framework, operation rules and operators are designed to support the complex geometric calculation, in order to construct GIS computing engine based on GA.

The ability of geometric computation and expression in GA makes time an equivalent dimension to space in computational space construction, thus the expression and computation of unified time and space are achieved. For example, if we want to track a ship moving in the ocean together with cameras (optical remote sensing), sonar (acoustic remote sensing) and radar (electromagnetic remote sensing), we have to deal with images, waves, and fields with different speeds through very large scales, we need to integrate different spatio-temporal references. And classical Euclidean geometry will be invalid for this situation due to numerical computational precision. However, with GA, we can easily deal with this situation using frame-based representations and versors like what we have already done in spacetime algebra.

GA intrinsically mixes the dimensional computation of definite geometric meaning, achieves integrative expression and storage of objects of different dimensions in mathematical structures, and supports expression, modeling, and analysis of complex geographical phenomena and geographical process.

GIS data models and analysis models can also be extended in GA framework, which will help to build a unified descriptive framework of multidimensional geographical time and space. Besides, present analysis models and algorithms such as statistical model, dynamic model, and differential equation model can be inherited and unified to support geographical models and compact integration of GIS analysis and geographical analysis.

**As I understand, simulation plays a fundamental role in GIS research and applications. In your opinion, what are the difficulties of creating good GIS simulators?**

The real world is complex, so does the geographic information obtained from the world. GIS is considered as a common platform, which needs a spatio-temporal coordinate system, static or dynamic state, and geographical phenomena or process. This condition leads to the huge amount of heterogeneous data, geometric or algebraic expressions, and analysis models. So, the difficulties of creating good GIS simulators I think maybe in four aspects:

(1) How to develop a unified spatio-temporal framework that can integrate geographical objects, phenomenon and geoscience data at different scales with different characteristics? How to make the translation and coupling of the global spatio-temporal framework/reference with a local or several local frameworks/references seamlessly.

(2) How to develop an efficient scene-based data model that can not only have enough power to represent real geographic objects/phenomenon in a parametric way but also can support efficient organization, storage, computation and visualization in current computer framework.

(3) How to integrate users with different requirements (e.g. geographer, common publics, policy makers, developers and computer scientists) with a common, flexible but powerful expression and computation language, which can both easy use but also efficient for dynamical computing.

(4) How to deal with dynamical simulation and continues data updating and visualization by coupling various different geographical models. How can we combine them in an integrating framework and make them work together.

**How do you think GA can be used to create better GIS simulators?**

The above three conflicts all points to one thing: that a transmission tool is an urgent need. So, Geometric Algebra is found from the areas of mathematics and physics to act as a convergence tool. The unity of geometry and algebra, time and space, different dimensions, expression and computation of GA is just as the effective way to solve the existing problem.

In our past work, we have done the Multi-dimensional complex object expression based on Blade, the Multi-dimensional complex scenes expression based on Multivector, and the Multi-dimensional unified computation based on geometric algebra, which laid the foundation for the new GIS simulator through the data structure, expression, and calculation.

GA can effectively represent the relationship and measurement of different shapes, and Multivectors can realize the integration and unification of different dimensions and types of geometric objects. Then in the computation part, GA calculation is almost based on operators, which have good compatibility with various analysis models, such as dynamic model or differential equation model. A famous example is the expression of Maxwell’s equation, which can be transformed into a single equation by GA. So, to geographic computation, it’s of great significance to integrating and optimizing the existing models.

In the GA simulation, a series of compilers can be created to translate all these models into GA expressions, and then into the C++ codes, which improves the efficiency and reduces the computational complexity. On the basis of those compilers, high-performance heterogeneous parallel computing can also be easily realized. Above all, GA does the overall rebuild to the old simulators and makes GIS simulators more efficient, concise and smart.

**Tell us about your experiences in the recently organized 2016 conference Geometric Algebra and Geographical Information Science: Development and Applications (GAGIS). What were your expectations before the conference? What can you tell us about the conference benefits to both the GA and GIS communities?**

In GAGIS, the most impressive thing for me is that all of the researchers had done excellent works in their research area. Because of the characteristics of GIS, It attracts people in many directions and fields. During the meeting, each researcher made a wonderful report and after the report, the participants put out a lot of questions and I also learned much about it from their response. On the last day of the meeting, we also visited the laboratory and learn about the wonderful work that they had done.

As a common platform, GIS has the potential to support the development and application of geometric algebra and its related fields as a representative work. For example, image processing can rely on the GIS platform to design the corresponding image processing algorithms and validate it directly with GIS data. However, until now, all we have done is primary, and we need to collaborate with the international GA and GIS related researchers. We also want to show our work to the international society and attract more researcher to join us, letting them collaborate with us under this framework.

Before the conference, I expected to learn more about geometric algebra in various fields of research and introduce our achievement to everyone in order to attract more intelligent people to join us. And now, it works. From the perspective of geography at home and abroad, GA is high-profile in GIS because of the characteristics of GIS itself. There are a series of teams doing the research about it and there are some projects supporting it. Unfortunately, international geometric algebra teams are relatively dispersed. How to unite this group of people to form a complete organization is the key point to promote the development and influence of GA. The most important thing that I want to say is that international conference is important to publicize what we do and strengthen communication, publicity, and cooperation. That is what we have never done before.

The post Knowing About the World via GIS appeared first on Geometric Algebra Explorer.

]]>